+macro(REPLACE_IN_FILE _yml_block match replace)

+ set(yml_block_src "${CMAKE_CURRENT_SOURCE_DIR}/${_yml_block}")

+ set(yml_block "${CMAKE_CURRENT_BINARY_DIR}/${_yml_block}")

+ list(REMOVE_ITEM yml_files "${yml_block_src}")

+ file(READ "${yml_block_src}" yml_block_src_text)

+ yml_block_text "${yml_block_src_text}")

+ file(WRITE "${yml_block}" "${yml_block_text}")

+ list(APPEND generated_yml_files "${yml_block}")

+macro(GEN_BLOCK_YML _generator _yml_block)

+ set(yml_block ${CMAKE_CURRENT_BINARY_DIR}/${_yml_block})

+ list(APPEND generated_yml_files ${yml_block})

+ DEPENDS ${generator} OUTPUT ${yml_block}

+ COMMAND ${PYTHON_EXECUTABLE} ${generator} ${yml_block}

+GEN_BLOCK_YML(variable_struct.block.yml.py variable_struct.block.yml)

+ REPLACE_IN_FILE(options.yml PyQt5 PyQt4)

+add_custom_target(grc_generated_yml ALL DEPENDS ${generated_yml_files})

+ FILES ${yml_files} ${generated_yml_files}

+'[Core]':

+- Misc:

+ - pad_source

+ - pad_sink

+ - virtual_source

+ - virtual_sink

+ - epy_module

+ - note

+ - import

+- Variables:

+ - variable

+ - variable_struct

+ - variable_config

+ - variable_function_probe

+ - parameter

+id: import_

+label: Import

+

+parameters:

+- id: imports

+ label: Import

+ dtype: import

+

+templates:

+ imports: ${imports}

+

+documentation: |-

+ Import additional python modules into the namespace.

+

+ Examples:

+ from gnuradio.filter import firdes

+ import math,cmath

+ from math import pi

+

+file_format: 1

+id: note

+label: Note

+

+parameters:

+- id: note

+ label: Note

+ dtype: string

+

+file_format: 1

+id: options

+label: Options

+

+parameters:

+- id: title

+ label: Title

+ dtype: string

+ hide: ${ ('none' if title else 'part') }

+- id: author

+ label: Author

+ dtype: string

+ hide: ${ ('none' if author else 'part') }

+- id: description

+ label: Description

+ dtype: string

+ hide: ${ ('none' if description else 'part') }

+- id: window_size

+ label: Canvas Size

+ dtype: int_vector

+ hide: part

+- id: generate_options

+ label: Generate Options

+ dtype: enum

+ default: qt_gui

+ options: [qt_gui, bokeh_gui, no_gui, hb, hb_qt_gui]

+ option_labels: [QT GUI, Bokeh GUI, No GUI, Hier Block, Hier Block (QT GUI)]

+- id: category

+ label: Category

+ dtype: string

+ default: '[GRC Hier Blocks]'

+ hide: ${ ('none' if generate_options.startswith('hb') else 'all') }

+- id: run_options

+ label: Run Options

+ dtype: enum

+ default: prompt

+ options: [run, prompt]

+ option_labels: [Run to Completion, Prompt for Exit]

+ hide: ${ ('none' if generate_options == 'no_gui' else 'all') }

+- id: placement

+ label: Widget Placement

+ dtype: int_vector

+ default: (0,0)

+ hide: ${ ('part' if generate_options == 'bokeh_gui' else 'all') }

+- id: sizing_mode

+ label: Sizing Mode

+ dtype: enum

+ default: fixed

+ options: [fixed, stretch_both, scale_width, scale_height, scale_both]

+ option_labels: [Fixed, Stretch Both, Scale Width, Scale Height, Scale Both]

+ hide: ${ ('part' if generate_options == 'bokeh_gui' else 'all') }

+- id: run

+ label: Run

+ dtype: bool

+ default: 'True'

+ options: ['True', 'False']

+ option_labels: [Autostart, 'Off']

+ hide: ${ ('all' if generate_options not in ('qt_gui', 'bokeh_gui') else ('part'

+ if run else 'none')) }

+- id: max_nouts

+ label: Max Number of Output

+ dtype: int

+ default: '0'

+ hide: ${ ('all' if generate_options.startswith('hb') else ('none' if max_nouts

+ else 'part')) }

+- id: realtime_scheduling

+ label: Realtime Scheduling

+ dtype: enum

+ options: ['', '1']

+ option_labels: ['Off', 'On']

+ hide: ${ ('all' if generate_options.startswith('hb') else ('none' if realtime_scheduling

+ else 'part')) }

+- id: qt_qss_theme

+ label: QSS Theme

+ dtype: file_open

+ hide: ${ ('all' if generate_options != 'qt_gui' else ('none' if qt_qss_theme else

+ 'part')) }

+- id: thread_safe_setters

+ label: Thread-safe setters

+ category: Advanced

+ dtype: enum

+ options: ['', '1']

+ option_labels: ['Off', 'On']

+ hide: part

+- id: run_command

+ label: Run Command

+ category: Advanced

+ dtype: string

+ default: '{python} -u {filename}'

+ hide: ${ ('all' if generate_options.startswith('hb') else 'part') }

+- id: hier_block_src_path

+ label: Hier Block Source Path

+ category: Advanced

+ dtype: string

+ default: '.:'

+ hide: part

+

+asserts:

+- ${ not window_size or len(window_size) == 2 }

+- ${ not window_size or 300 <= window_size[0] <= 4096 }

+- ${ not window_size or 300 <= window_size[1] <= 4096 }

+- ${ len(placement) == 4 or len(placement) == 2 }

+- ${ all(i >= 0 for i in placement) }

+

+templates:

+ imports: |-

+ from gnuradio import gr

+ from gnuradio.filter import firdes

+ % if generate_options == 'qt_gui':

+ from PyQt5 import Qt

+ import sys

+ % endif

+ % if generate_options == 'bokeh_gui':

+ import time

+ import signal

+ import functools

+ from bokeh.client import push_session

+ from bokeh.plotting import curdoc

+ % endif

+ % if not generate_options.startswith('hb'):

+ from argparse import ArgumentParser

+ from gnuradio.eng_arg import eng_float, intx

+ from gnuradio import eng_notation

+ % endif

+ callbacks:

+ - 'if ${run}: self.start()

+

+ else: self.stop(); self.wait()'

+

+documentation: |-

+ The options block sets special parameters for the flow graph. Only one option block is allowed per flow graph.

+

+ Title, author, and description parameters are for identification purposes.

+

+ The window size controls the dimensions of the flow graph editor. The window size (width, height) must be between (300, 300) and (4096, 4096).

+

+ The generate options controls the type of code generated. Non-graphical flow graphs should avoid using graphical sinks or graphical variable controls.

+

+ In a graphical application, run can be controlled by a variable to start and stop the flowgraph at runtime.

+

+ The id of this block determines the name of the generated file and the name of the class. For example, an id of my_block will generate the file my_block.py and class my_block(gr....

+

+ The category parameter determines the placement of the block in the block selection window. The category only applies when creating hier blocks. To put hier blocks into the root category, enter / for the category.

+

+ The Max Number of Output is the maximum number of output items allowed for any block in the flowgraph; to disable this set the max_nouts equal to 0.Use this to adjust the maximum latency a flowgraph can exhibit.

+

+file_format: 1

+id: pad_sink

+label: Pad Sink

+

+parameters:

+- id: label

+ label: Label

+ dtype: string

+ default: out

+- id: type

+ label: Input Type

+ dtype: enum

+ options: [complex, float, int, short, byte, bit, message, '']

+ option_labels: [Complex, Float, Int, Short, Byte, Bits, Message, Wildcard]

+ option_attributes:

+ size: [gr.sizeof_gr_complex, gr.sizeof_float, gr.sizeof_int, gr.sizeof_short,

+ gr.sizeof_char, gr.sizeof_char, '0', '0']

+ hide: part

+- id: vlen

+ label: Vec Length

+ dtype: int

+ default: '1'

+ hide: ${ 'part' if vlen == 1 else 'none' }

+- id: num_streams

+ label: Num Streams

+ dtype: int

+ default: '1'

+ hide: part

+- id: optional

+ label: Optional

+ dtype: bool

+ default: 'False'

+ options: ['True', 'False']

+ option_labels: [Optional, Required]

+ hide: part

+

+inputs:

+- domain: stream

+ dtype: ${ type }

+ vlen: ${ vlen }

+ multiplicity: ${ num_streams }

+

+asserts:

+- ${ vlen > 0 }

+- ${ num_streams > 0 }

+

+documentation: |-

+ The inputs of this block will become the outputs to this flow graph when it is instantiated as a hierarchical block.

+

+ Pad sink will be ordered alphabetically by their ids. The first pad sink will have an index of 0.

+

+file_format: 1

+id: pad_source

+label: Pad Source

+

+parameters:

+- id: label

+ label: Label

+ dtype: string

+ default: in

+- id: type

+ label: Output Type

+ dtype: enum

+ options: [complex, float, int, short, byte, bit, message, '']

+ option_labels: [Complex, Float, Int, Short, Byte, Bits, Message, Wildcard]

+ option_attributes:

+ size: [gr.sizeof_gr_complex, gr.sizeof_float, gr.sizeof_int, gr.sizeof_short,

+ gr.sizeof_char, gr.sizeof_char, '0', '0']

+ hide: part

+- id: vlen

+ label: Vec Length

+ dtype: int

+ default: '1'

+ hide: ${ 'part' if vlen == 1 else 'none' }

+- id: num_streams

+ label: Num Streams

+ dtype: int

+ default: '1'

+ hide: part

+- id: optional

+ label: Optional

+ dtype: bool

+ default: 'False'

+ options: ['True', 'False']

+ option_labels: [Optional, Required]

+ hide: part

+

+outputs:

+- domain: stream

+ dtype: ${ type }

+ vlen: ${ vlen }

+ multiplicity: ${ num_streams }

+

+asserts:

+- ${ vlen > 0 }

+- ${ num_streams > 0 }

+

+documentation: |-

+ The outputs of this block will become the inputs to this flow graph when it is instantiated as a hierarchical block.

+

+ Pad sources will be ordered alphabetically by their ids. The first pad source will have an index of 0.

+

+file_format: 1

+id: parameter

+label: Parameter

+

+parameters:

+- id: label

+ label: Label

+ dtype: string

+ hide: ${ ('none' if label else 'part') }

+- id: value

+ label: Value

+ dtype: ${ type.type }

+ default: '0'

+- id: type

+ label: Type

+ dtype: enum

+ options: ['', complex, eng_float, intx, long, str]

+ option_labels: [None, Complex, Float, Int, Long, String]

+ option_attributes:

+ type: [raw, complex, real, int, int, string]

+ hide: ${ ('none' if type else 'part') }

+- id: short_id

+ label: Short ID

+ dtype: string

+ hide: ${ 'all' if not type else ('none' if short_id else 'part') }

+- id: hide

+ label: Show

+ dtype: enum

+ options: [none, part]

+ option_labels: [Always, Only in Properties]

+ hide: part

+

+asserts:

+- ${ len(short_id) in (0, 1) }

+- ${ short_id == '' or short_id.isalpha() }

+

+templates:

+ var_make: self.${id} = ${id}

+ make: ${value}

+

+documentation: |-

+ This block represents a parameter to the flow graph. A parameter can be used to pass command line arguments into a top block. Or, parameters can pass arguments into an instantiated hierarchical block.

+

+ The paramater value cannot depend on any variables.

+

+ Leave the label blank to use the parameter id as the label.

+

+ When type is not None, this parameter also becomes a command line option of the form:

+

+ -[short_id] --[id] [value]

+

+ The Short ID field may be left blank.

+

+ To disable showing the parameter on the hierarchical block in GRC, use Only in Properties option in the Show field.

+

+file_format: 1

+id: variable

+label: Variable

+

+parameters:

+- id: value

+ label: Value

+ dtype: raw

+ default: '0'

+value: ${ value }

+

+templates:

+ var_make: self.${id} = ${id} = ${value}

+ callbacks:

+ - self.set_${id}(${value})

+

+documentation: |-

+ This block maps a value to a unique variable. This variable block has no graphical representation.

+

+file_format: 1

+id: variable_config

+label: Variable Config

+

+parameters:

+- id: value

+ label: Default Value

+ dtype: ${ type }

+ default: '0'

+- id: type

+ label: Type

+ dtype: enum

+ default: real

+ options: [real, int, bool, string]

+ option_labels: [Float, Int, Bool, String]

+ option_attributes:

+ get: [getfloat, getint, getboolean, get]

+- id: config_file

+ label: Config File

+ dtype: file_open

+ default: default

+- id: section

+ label: Section

+ dtype: string

+ default: main

+- id: option

+ label: Option

+ dtype: string

+ default: key

+- id: writeback

+ label: WriteBack

+ dtype: raw

+ default: None

+value: ${ value }

+

+templates:

+ imports: import ConfigParser

+ var_make: 'self._${id}_config = ConfigParser.ConfigParser()

+

+ self._${id}_config.read(${config_file})

+

+ try: ${id} = self._${id}_config.${type.get}(${section}, ${option})

+

+ except: ${id} = ${value}

+

+ self.${id} = ${id}'

+ callbacks:

+ - self.set_${id}(${value})

+ - "self._${id}_config = ConfigParser.ConfigParser()\nself._${id}_config.read(${config_file})\n\

+ if not self._${id}_config.has_section(${section}):\n\tself._${id}_config.add_section(${section})\n\

+ self._${id}_config.set(${section}, ${option}, str(${writeback}))\nself._${id}_config.write(open(${config_file},\

+ \ 'w'))"

+

+documentation: |-

+ This block represents a variable that can be read from a config file.

+

+ To save the value back into the config file: enter the name of another variable into the writeback param. When the other variable is changed at runtime, the config file will be re-written.

+

+file_format: 1

+id: variable_function_probe

+label: Function Probe

+

+parameters:

+- id: block_id

+ label: Block ID

+ dtype: string

+ default: my_block_0

+- id: function_name

+ label: Function Name

+ dtype: string

+ default: get_number

+- id: function_args

+ label: Function Args

+ dtype: string

+ hide: ${ ('none' if function_args else 'part') }

+- id: poll_rate

+ label: Poll Rate (Hz)

+ dtype: real

+ default: '10'

+- id: value

+ label: Initial Value

+ dtype: raw

+ default: '0'

+ hide: part

+value: ${ value }

+

+templates:

+ imports: |-

+ import time

+ import threading

+ var_make: self.${id} = ${id} = ${value}

+ make: "\ndef _${id}_probe():\n while True:\n <% obj = 'self' + ('.'\

+ \ + block_id if block_id else '') %>\n val = ${obj}.${function_name}(${function_args})\n\

+ \ try:\n self.set_${id}(val)\n except AttributeError:\n\

+ \ pass\n time.sleep(1.0 / (${poll_rate}))\n_${id}_thread\

+ \ = threading.Thread(target=_${id}_probe)\n_${id}_thread.daemon = True\n_${id}_thread.start()\n\

+ \ "

+ callbacks:

+ - self.set_${id}(${value})

+

+documentation: |-

+ Periodically probe a function and set its value to this variable.

+

+ Set the values for block ID, function name, and function args appropriately: Block ID should be the ID of another block in this flow graph. An empty Block ID references the flow graph itself. Function name should be the name of a class method on that block. Function args are the parameters passed into that function. For a function with no arguments, leave function args blank. When passing a string for the function arguments, quote the string literal: '"arg"'.

+

+ The values will used literally, and generated into the following form:

+ self.block_id.function_name(function_args)

+ or, if the Block ID is empty,

+ self.function_name(function_args)

+

+ To poll a stream for a level, use this with the probe signal block.

+

+file_format: 1

+#!/usr/bin/env python

+

+MAX_NUM_FIELDS = 20

+

+HEADER = """\

+id: variable_struct

+label: Struct Variable

+

+parameters:

+"""

+

+TEMPLATES = """\

+

+templates:

+ imports: "def struct(data): return type('Struct', (object,), data)()"

+ var_make: |-

+ self.${{id}} = ${{id}} = struct({{

+ % for i in range({0}):

+ <%

+ field = getVar('field' + str(i))

+ %>

+ % if len(str(field)) > 2:

+ ${{field}}: getVar('value' + str(i)),

+ % endif

+ % endfor

+ }})

+ var_value: |-

+ struct({{

+ % for i in range({0}):

+ <%

+ field = getVar('field' + str(i))

+ %>

+ % if len(str(field)) > 2:

+ ${{field}}: getVar('field' + str(i)),

+ % endif

+ % endfor

+ }})

+"""

+

+FIELD0 = """\

+- id: field0

+ label: Field 0

+ category: Fields

+ dtype: string

+ default: ${field0}

+ hide: part

+"""

+

+FIELDS = """\

+- id: field{0}

+ label: Field {0}

+ category: Fields

+ dtype: string

+ hide: part

+"""

+

+VALUES = """\

+- id: value{0}

+ label: ${{field{0}}}

+ dtype: raw

+ default: '0'

+ hide: ${{ 'none' if field{0} else 'all' }}

+"""

+

+ASSERTS = """\

+- ${{ (str(field{0}) or "a")[0].isalpha() }}

+- ${{ (str(field{0}) or "a").isalnum() }}

+"""

+

+FOOTER = """\

+

+documentation: |-

+ This is a simple struct/record like variable.

+

+ Attribute/field names can be specified in the tab 'Fields'.

+ For each non-empty field a parameter with type raw is shown.

+ Value access via the dot operator, e.g. "variable_struct_0.field0"

+

+file_format: 1

+"""

+

+

+def make_yml(num_fields):

+ return ''.join((

+ HEADER.format(num_fields),

+ FIELD0, ''.join(FIELDS.format(i) for i in range(1, num_fields)),

+ ''.join(VALUES.format(i) for i in range(num_fields)),

+ 'value: ${value}\n\nasserts:\n',

+ ''.join(ASSERTS.format(i) for i in range(num_fields)),

+ ''.join(TEMPLATES.format(num_fields)),

+ FOOTER

+ ))

+

+

+if __name__ == '__main__':

+ import sys

+ try:

+ filename = sys.argv[1]

+ except IndexError:

+ filename = __file__[:-3]

+

+ data = make_yml(MAX_NUM_FIELDS)

+

+ with open(filename, 'wb') as fp:

+ fp.write(data.encode())

+import numbers

+CACHE_FILE = os.path.expanduser('~/.cache/grc_gnuradio/cache.json')

+

+PARAM_TYPE_NAMES = {

+}

+

+PARAM_TYPE_MAP = {

+ 'complex': numbers.Complex,

+ 'float': numbers.Real,

+ 'real': numbers.Real,

+ 'int': numbers.Integral,

+}

+ return itertools.chain(self.iter_enabled_blocks(), self.connections)

+ cls.loaded_from = '(build-in)'

+import collections

+import itertools

+from ..Constants import ADVANCED_PARAM_TAB

+from ..utils import to_list

+

+ cls = type(str(block_id), (Block,), {})

+ cls.flags = Flags(to_list(flags))

+ cls.flags.set(Flags.NOT_DSP, Flags.DISABLE_BYPASS)

+ cls.asserts = [_single_mako_expr(a, block_id) for a in to_list(asserts)]

+ cls.inputs_data = _build_ports(inputs, 'sink') if inputs else []

+ cls.outputs_data = _build_ports(outputs, 'source') if outputs else []

+ cls.parameters_data = _build_params(parameters or [],

+ bool(cls.inputs_data), bool(cls.outputs_data), cls.flags)

+def _build_ports(ports_raw, direction):

+ ports = []

+ port_ids = set()

+ stream_port_ids = itertools.count()

+

+ for i, port_params in enumerate(ports_raw):

+ port = port_params.copy()

+ port['direction'] = direction

+

+ port_id = port.setdefault('id', str(next(stream_port_ids)))

+ if port_id in port_ids:

+ raise Exception('Port id "{}" already exists in {}s'.format(port_id, direction))

+ port_ids.add(port_id)

+

+ ports.append(port)

+ return ports

+

+

+def _build_params(params_raw, have_inputs, have_outputs, flags):

+ params = []

+

+ def add_param(**data):

+ params.append(data)

+

+ add_param(id='id', name='ID', dtype='id', hide='part')

+

+ if not flags.not_dsp:

+ add_param(id='alias', name='Block Alias', dtype='string',

+ hide='part', category=ADVANCED_PARAM_TAB)

+

+ if have_outputs or have_inputs:

+ add_param(id='affinity', name='Core Affinity', dtype='int_vector',

+ hide='part', category=ADVANCED_PARAM_TAB)

+

+ if have_outputs:

+ add_param(id='minoutbuf', name='Min Output Buffer', dtype='int',

+ hide='part', value='0', category=ADVANCED_PARAM_TAB)

+ add_param(id='maxoutbuf', name='Max Output Buffer', dtype='int',

+ hide='part', value='0', category=ADVANCED_PARAM_TAB)

+

+ base_params_n = {}

+ for param_data in params_raw:

+ param_id = param_data['id']

+ if param_id in params:

+ raise Exception('Param id "{}" is not unique'.format(param_id))

+

+ base_key = param_data.get('base_key', None)

+ param_data_ext = base_params_n.get(base_key, {}).copy()

+ param_data_ext.update(param_data)

+

+ add_param(**param_data_ext)

+ base_params_n[param_id] = param_data_ext

+

+ add_param(id='comment', name='Comment', dtype='_multiline', hide='part',

+ value='', category=ADVANCED_PARAM_TAB)

+ return params

+

+

+ if not value:

+ return None

+ value = value.strip()

+ if not (value.startswith('${') and value.endswith('}')):

+ return value[2:-1].strip()

+class Flags(object):

+ def __init__(self, flags):

+ self.data = set(flags)

+

+ def __contains__(self, item):

+ return item in self.data

+ def set(self, *flags):

+ self.data.update(flags)

+ loaded_from = '(unknown)'

+ self.params = collections.OrderedDict(

+ (data['id'], param_factory(parent=self, **data))

+ for data in self.parameters_data

+ )

+ if self.key == 'options' or self.is_variable:

+ self.params['id'].hide = 'part'

+ self.sinks = [port_factory(parent=self, **params) for params in self.inputs_data]

+ self.sources = [port_factory(parent=self, **params) for params in self.outputs_data]

+ self.active_sources = [] # on rewrite

+ self.active_sinks = [] # on rewrite

+

+ self.states = {'state': True}

+# Copyright 2017 Free Software Foundation, Inc.

+# This file is part of GNU Radio

+#

+# GNU Radio Companion is free software; you can redistribute it and/or

+# modify it under the terms of the GNU General Public License

+# as published by the Free Software Foundation; either version 2

+# of the License, or (at your option) any later version.

+#

+# GNU Radio Companion is distributed in the hope that it will be useful,

+# but WITHOUT ANY WARRANTY; without even the implied warranty of

+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

+# GNU General Public License for more details.

+#

+# You should have received a copy of the GNU General Public License

+# along with this program; if not, write to the Free Software

+# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA

+

+from __future__ import absolute_import, print_function

+

+from io import open

+import json

+import logging

+import os

+

+import six

+

+from .io import yaml

+

+logger = logging.getLogger(__name__)

+

+

+class Cache(object):

+

+ def __init__(self, filename):

+ self.cache_file = filename

+ self.cache = {}

+ self.need_cache_write = True

+ self._accessed_items = set()

+ try:

+ os.makedirs(os.path.dirname(filename))

+ except OSError:

+ pass

+ try:

+ self._converter_mtime = os.path.getmtime(filename)

+ except OSError:

+ self._converter_mtime = -1

+

+ def load(self):

+ try:

+ logger.debug("Loading block cache from: {}".format(self.cache_file))

+ with open(self.cache_file, encoding='utf-8') as cache_file:

+ self.cache = json.load(cache_file)

+ self.need_cache_write = False

+ except (IOError, ValueError):

+ self.need_cache_write = True

+

+ def get_or_load(self, filename):

+ self._accessed_items.add(filename)

+ if os.path.getmtime(filename) <= self._converter_mtime:

+ try:

+ return self.cache[filename]

+ except KeyError:

+ pass

+

+ with open(filename, encoding='utf-8') as fp:

+ data = yaml.safe_load(fp)

+ self.cache[filename] = data

+ self.need_cache_write = True

+ return data

+

+ def save(self):

+ if not self.need_cache_write:

+ return

+

+ logger.info('Saving %d entries to json cache', len(self.cache))

+ with open(self.cache_file, 'w', encoding='utf8') as cache_file:

+ json.dump(self.cache, cache_file)

+

+ def prune(self):

+ for filename in (set(self.cache) - self._accessed_items):

+ del self.cache[filename]

+

+ def __enter__(self):

+ self.load()

+ return self

+

+ def __exit__(self, exc_type, exc_val, exc_tb):

+ self.save()

+

+

+def byteify(data):

+ if isinstance(data, dict):

+ return {byteify(key): byteify(value) for key, value in six.iteritems(data)}

+ elif isinstance(data, list):

+ return [byteify(element) for element in data]

+ elif isinstance(data, six.text_type) and six.PY2:

+ return data.encode('utf-8')

+ else:

+ return data

+ id: 'top_block'

+ "\n<% win = 'self.' + id %>"

+ "\n${ gui_hint % win }"

+# Copyright 2017 Free Software Foundation, Inc.

+# This file is part of GNU Radio

+#

+# GNU Radio Companion is free software; you can redistribute it and/or

+# modify it under the terms of the GNU General Public License

+# as published by the Free Software Foundation; either version 2

+# of the License, or (at your option) any later version.

+#

+# GNU Radio Companion is distributed in the hope that it will be useful,

+# but WITHOUT ANY WARRANTY; without even the implied warranty of

+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

+# GNU General Public License for more details.

+#

+# You should have received a copy of the GNU General Public License

+# along with this program; if not, write to the Free Software

+# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA

+

+from .param import Param

+# Copyright 2008-2017 Free Software Foundation, Inc.

+# This file is part of GNU Radio

+#

+# GNU Radio Companion is free software; you can redistribute it and/or

+# modify it under the terms of the GNU General Public License

+# as published by the Free Software Foundation; either version 2

+# of the License, or (at your option) any later version.

+#

+# GNU Radio Companion is distributed in the hope that it will be useful,

+# but WITHOUT ANY WARRANTY; without even the implied warranty of

+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

+# GNU General Public License for more details.

+#

+# You should have received a copy of the GNU General Public License

+# along with this program; if not, write to the Free Software

+# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA

+

+from __future__ import absolute_import

+

+import re

+

+from six.moves import builtins

+

+from .. import blocks

+from .. import Constants

+

+

+# Blacklist certain ids, its not complete, but should help

+ID_BLACKLIST = ['self', 'options', 'gr', 'math', 'firdes'] + dir(builtins)

+try:

+ from gnuradio import gr

+ ID_BLACKLIST.extend(attr for attr in dir(gr.top_block()) if not attr.startswith('_'))

+except (ImportError, AttributeError):

+ pass

+

+

+validators = {}

+

+

+def validates(*dtypes):

+ def decorator(func):

+ for dtype in dtypes:

+ assert dtype in Constants.PARAM_TYPE_NAMES

+ validators[dtype] = func

+ return func

+ return decorator

+

+

+class ValidateError(Exception):

+ """Raised by validate functions"""

+

+

+@validates('id')

+def validate_block_id(param):

+ value = param.value

+ # Can python use this as a variable?

+ if not re.match(r'^[a-z|A-Z]\w*$', value):

+ raise ValidateError('ID "{}" must begin with a letter and may contain letters, numbers, '

+ 'and underscores.'.format(value))

+ if value in ID_BLACKLIST:

+ raise ValidateError('ID "{}" is blacklisted.'.format(value))

+ block_names = [block.name for block in param.parent_flowgraph.iter_enabled_blocks()]

+ # Id should only appear once, or zero times if block is disabled

+ if param.key == 'id' and block_names.count(value) > 1:

+ raise ValidateError('ID "{}" is not unique.'.format(value))

+ elif value not in block_names:

+ raise ValidateError('ID "{}" does not exist.'.format(value))

+ return value

+

+

+@validates('stream_id')

+def validate_stream_id(param):

+ value = param.value

+ stream_ids = [

+ block.params['stream_id'].value

+ for block in param.parent_flowgraph.iter_enabled_blocks()

+ if isinstance(block, blocks.VirtualSink)

+ ]

+ # Check that the virtual sink's stream id is unique

+ if isinstance(param.parent_block, blocks.VirtualSink) and stream_ids.count(value) >= 2:

+ # Id should only appear once, or zero times if block is disabled

+ raise ValidateError('Stream ID "{}" is not unique.'.format(value))

+ # Check that the virtual source's steam id is found

+ elif isinstance(param.parent_block, blocks.VirtualSource) and value not in stream_ids:

+ raise ValidateError('Stream ID "{}" is not found.'.format(value))

+

+

+@validates('complex', 'real', 'float', 'int')

+def validate_scalar(param):

+ valid_types = Constants.PARAM_TYPE_MAP[param.dtype]

+ if not isinstance(param.get_evaluated(), valid_types):

+ raise ValidateError('Expression {!r} is invalid for type {!r}.'.format(

+ param.get_evaluated(), param.dtype))

+

+

+@validates('complex_vector', 'real_vector', 'float_vector', 'int_vector')

+def validate_vector(param):

+ # todo: check vector types

+

+ valid_types = Constants.PARAM_TYPE_MAP[param.dtype.split('_', 1)[0]]

+ if not all(isinstance(item, valid_types) for item in param.get_evaluated()):

+ raise ValidateError('Expression {!r} is invalid for type {!r}.'.format(

+ param.get_evaluated(), param.dtype))

+# Copyright 2008-2017 Free Software Foundation, Inc.

+# This file is part of GNU Radio

+#

+# GNU Radio Companion is free software; you can redistribute it and/or

+# modify it under the terms of the GNU General Public License

+# as published by the Free Software Foundation; either version 2

+# of the License, or (at your option) any later version.

+#

+# GNU Radio Companion is distributed in the hope that it will be useful,

+# but WITHOUT ANY WARRANTY; without even the implied warranty of

+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

+# GNU General Public License for more details.

+#

+# You should have received a copy of the GNU General Public License

+# along with this program; if not, write to the Free Software

+# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA

+

+from __future__ import absolute_import

+

+import ast

+import collections

+import textwrap

+

+import six

+from six.moves import range

+

+from .. import Constants

+from ..base import Element

+from ..utils.descriptors import Evaluated, EvaluatedEnum, setup_names

+

+from . import dtypes

+from .template_arg import TemplateArg

+

+

+@setup_names

+class Param(Element):

+

+ is_param = True

+

+ name = Evaluated(str, default='no name')

+ dtype = EvaluatedEnum(Constants.PARAM_TYPE_NAMES, default='raw')

+ hide = EvaluatedEnum('none all part')

+

+ # region init

+ def __init__(self, parent, id, label='', dtype='raw', default='',

+ options=None, option_labels=None, option_attributes=None,

+ category='', hide='none', **_):

+ """Make a new param from nested data"""

+ super(Param, self).__init__(parent)

+ self.key = id

+ self.name = label.strip() or id.title()

+ self.category = category or Constants.DEFAULT_PARAM_TAB

+

+ self.dtype = dtype

+ self.value = self.default = str(default)

+

+ self.options = self._init_options(options or [], option_labels or [],

+ option_attributes or {})

+ self.hide = hide or 'none'

+ # end of args ########################################################

+

+ self._evaluated = None

+ self._stringify_flag = False

+ self._lisitify_flag = False

+ self.hostage_cells = set()

+ self._init = False

+

+ def _init_options(self, values, labels, attributes):

+ """parse option and option attributes"""

+ options = collections.OrderedDict()

+ options.attributes = collections.defaultdict(dict)

+

+ padding = [''] * max(len(values), len(labels))

+ attributes = {key: value + padding for key, value in six.iteritems(attributes)}

+

+ for i, option in enumerate(values):

+ # Test against repeated keys

+ if option in options:

+ raise KeyError('Value "{}" already exists in options'.format(option))

+ # get label

+ try:

+ label = str(labels[i])

+ except IndexError:

+ label = str(option)

+ # Store the option

+ options[option] = label

+ options.attributes[option] = {attrib: values[i] for attrib, values in six.iteritems(attributes)}

+

+ default = next(iter(options)) if options else ''

+ if not self.value:

+ self.value = self.default = default

+

+ if self.is_enum() and self.value not in options:

+ self.value = self.default = default # TODO: warn

+ # raise ValueError('The value {!r} is not in the possible values of {}.'

+ # ''.format(self.get_value(), ', '.join(self.options)))

+ return options

+ # endregion

+

+ @property

+ def template_arg(self):

+ return TemplateArg(self)

+

+ def __str__(self):

+ return 'Param - {}({})'.format(self.name, self.key)

+

+ def __repr__(self):

+ return '{!r}.param[{}]'.format(self.parent, self.key)

+

+ def is_enum(self):

+ return self.get_raw('dtype') == 'enum'

+

+ def get_value(self):

+ value = self.value

+ if self.is_enum() and value not in self.options:

+ value = self.default

+ self.set_value(value)

+ return value

+

+ def set_value(self, value):

+ # Must be a string

+ self.value = str(value)

+

+ def set_default(self, value):

+ if self.default == self.value:

+ self.set_value(value)

+ self.default = str(value)

+

+ def rewrite(self):

+ Element.rewrite(self)

+ del self.name

+ del self.dtype

+ del self.hide

+

+ self._evaluated = None

+ try:

+ self._evaluated = self.evaluate()

+ except Exception as e:

+ self.add_error_message(str(e))

+

+ rewriter = getattr(dtypes, 'rewrite_' + self.dtype, None)

+ if rewriter:

+ rewriter(self)

+

+ def validate(self):

+ """

+ Validate the param.

+ The value must be evaluated and type must a possible type.

+ """

+ Element.validate(self)

+ if self.dtype not in Constants.PARAM_TYPE_NAMES:

+ self.add_error_message('Type "{}" is not a possible type.'.format(self.dtype))

+

+ validator = dtypes.validators.get(self.dtype, None)

+ if self._init and validator:

+ try:

+ validator(self)

+ except dtypes.ValidateError as e:

+ self.add_error_message(e.message)

+

+ def get_evaluated(self):

+ return self._evaluated

+

+ def evaluate(self):

+ """

+ Evaluate the value.

+

+ Returns:

+ evaluated type

+ """

+ self._init = True

+ self._lisitify_flag = False

+ self._stringify_flag = False

+ dtype = self.dtype

+ expr = self.get_value()

+

+ #########################

+ # ID and Enum types (not evaled)

+ #########################

+ if dtype in ('id', 'stream_id') or self.is_enum():

+ return expr

+

+ #########################

+ # Numeric Types

+ #########################

+ elif dtype in ('raw', 'complex', 'real', 'float', 'int', 'hex', 'bool'):

+ if expr:

+ try:

+ value = self.parent_flowgraph.evaluate(expr)

+ except Exception as e:

+ raise Exception('Value "{}" cannot be evaluated:\n{}'.format(expr, e))

+ else:

+ value = 0

+ if dtype == 'hex':

+ value = hex(value)

+ elif dtype == 'bool':

+ value = bool(value)

+ return value

+

+ #########################

+ # Numeric Vector Types

+ #########################

+ elif dtype in ('complex_vector', 'real_vector', 'float_vector', 'int_vector'):

+ if not expr:

+ return [] # Turn a blank string into an empty list, so it will eval

+ try:

+ value = self.parent.parent.evaluate(expr)

+ except Exception as value:

+ raise Exception('Value "{}" cannot be evaluated:\n{}'.format(expr, value))

+ if not isinstance(value, Constants.VECTOR_TYPES):

+ self._lisitify_flag = True

+ value = [value]

+ return value

+ #########################

+ # String Types

+ #########################

+ elif dtype in ('string', 'file_open', 'file_save', '_multiline', '_multiline_python_external'):

+ # Do not check if file/directory exists, that is a runtime issue

+ try:

+ value = self.parent_flowgraph.evaluate(expr)

+ if not isinstance(value, str):

+ raise Exception()

+ except:

+ self._stringify_flag = True

+ value = str(expr)

+ if dtype == '_multiline_python_external':

+ ast.parse(value) # Raises SyntaxError

+ return value

+ #########################

+ # GUI Position/Hint

+ #########################

+ elif dtype == 'gui_hint':

+ return self.parse_gui_hint(expr) if self.parent_block.state == 'enabled' else ''

+ #########################

+ # Import Type

+ #########################

+ elif dtype == 'import':

+ # New namespace

+ n = dict()

+ try:

+ exec(expr, n)

+ except ImportError:

+ raise Exception('Import "{}" failed.'.format(expr))

+ except Exception:

+ raise Exception('Bad import syntax: "{}".'.format(expr))

+ return [k for k in list(n.keys()) if str(k) != '__builtins__']

+

+ #########################

+ else:

+ raise TypeError('Type "{}" not handled'.format(dtype))

+

+ def to_code(self):

+ """

+ Convert the value to code.

+ For string and list types, check the init flag, call evaluate().

+ This ensures that evaluate() was called to set the xxxify_flags.

+

+ Returns:

+ a string representing the code

+ """

+ self._init = True

+ value = self.get_value()

+ # String types

+ if self.dtype in ('string', 'file_open', 'file_save', '_multiline', '_multiline_python_external'):

+ if not self._init:

+ self.evaluate()

+ return repr(value) if self._stringify_flag else value

+

+ # Vector types

+ elif self.dtype in ('complex_vector', 'real_vector', 'float_vector', 'int_vector'):

+ if not self._init:

+ self.evaluate()

+ return '[' + value + ']' if self._lisitify_flag else value

+ else:

+ return value

+

+ def get_opt(self, item):

+ return self.options.attributes[self.get_value()][item]

+

+ ##############################################

+ # GUI Hint

+ ##############################################

+ def parse_gui_hint(self, expr):

+ """

+ Parse/validate gui hint value.

+

+ Args:

+ expr: gui_hint string from a block's 'gui_hint' param

+

+ Returns:

+ string of python code for positioning GUI elements in pyQT

+ """

+ self.hostage_cells.clear()

+

+ # Parsing

+ if ':' in expr:

+ tab, pos = expr.split(':')

+ elif ',' in expr:

+ tab, pos = '', expr

+ else:

+ tab, pos = expr, ''

+

+ if '@' in tab:

+ tab, index = tab.split('@')

+ else:

+ index = '0'

+ index = int(index)

+

+ # Validation

+ def parse_pos():

+ e = self.parent_flowgraph.evaluate(pos)

+

+ if not isinstance(e, (list, tuple)) or len(e) not in (2, 4) or not all(isinstance(ei, int) for ei in e):

+ raise Exception('Invalid GUI Hint entered: {e!r} (Must be a list of {{2,4}} non-negative integers).'.format(e=e))

+

+ if len(e) == 2:

+ row, col = e

+ row_span = col_span = 1

+ else:

+ row, col, row_span, col_span = e

+

+ if (row < 0) or (col < 0):

+ raise Exception('Invalid GUI Hint entered: {e!r} (non-negative integers only).'.format(e=e))

+

+ if (row_span < 1) or (col_span < 1):

+ raise Exception('Invalid GUI Hint entered: {e!r} (positive row/column span required).'.format(e=e))

+

+ return row, col, row_span, col_span

+

+ def validate_tab():

+ tabs = (block for block in self.parent_flowgraph.iter_enabled_blocks()

+ if block.key == 'qtgui_tab_widget' and block.name == tab)

+ tab_block = next(iter(tabs), None)

+ if not tab_block:

+ raise Exception('Invalid tab name entered: {tab} (Tab name not found).'.format(tab=tab))

+

+ tab_index_size = int(tab_block.params['num_tabs'].value)

+ if index >= tab_index_size:

+ raise Exception('Invalid tab index entered: {tab}@{index} (Index out of range).'.format(

+ tab=tab, index=index))

+

+ # Collision Detection

+ def collision_detection(row, col, row_span, col_span):

+ my_parent = '{tab}@{index}'.format(tab=tab, index=index) if tab else 'main'

+ # Calculate hostage cells

+ for r in range(row, row + row_span):

+ for c in range(col, col + col_span):

+ self.hostage_cells.add((my_parent, (r, c)))

+

+ for other in self.get_all_params('gui_hint'):

+ if other is self:

+ continue

+ collision = next(iter(self.hostage_cells & other.hostage_cells), None)

+ if collision:

+ raise Exception('Block {block!r} is also using parent {parent!r}, cell {cell!r}.'.format(

+ block=other.parent_block.name, parent=collision[0], cell=collision[1]

+ ))

+

+ # Code Generation

+ if tab:

+ validate_tab()

+ layout = '{tab}_grid_layout_{index}'.format(tab=tab, index=index)

+ else:

+ layout = 'top_grid_layout'

+

+ widget = '%s' # to be fill-out in the mail template

+

+ if pos:

+ row, col, row_span, col_span = parse_pos()

+ collision_detection(row, col, row_span, col_span)

+

+ widget_str = textwrap.dedent("""

+ self.{layout}.addWidget({widget}, {row}, {col}, {row_span}, {col_span})

+ for r in range({row}, {row_end}):

+ self.{layout}.setRowStretch(r, 1)

+ for c in range({col}, {col_end}):

+ self.{layout}.setColumnStretch(c, 1)

+ """.strip('\n')).format(

+ layout=layout, widget=widget,

+ row=row, row_span=row_span, row_end=row+row_span,

+ col=col, col_span=col_span, col_end=col+col_span,

+ )

+

+ else:

+ widget_str = 'self.{layout}.addWidget({widget})'.format(layout=layout, widget=widget)

+

+ return widget_str

+

+ def get_all_params(self, dtype, key=None):

+ """

+ Get all the params from the flowgraph that have the given type and

+ optionally a given key

+

+ Args:

+ dtype: the specified type

+ key: the key to match against

+

+ Returns:

+ a list of params

+ """

+ params = []

+ for block in self.parent_flowgraph.iter_enabled_blocks():

+ params.extend(

+ param for param in block.params.values()

+ if param.dtype == dtype and (key is None or key == param.name)

+ )

+ return params

+# Copyright 2008-2017 Free Software Foundation, Inc.

+# This file is part of GNU Radio

+#

+# GNU Radio Companion is free software; you can redistribute it and/or

+# modify it under the terms of the GNU General Public License

+# as published by the Free Software Foundation; either version 2

+# of the License, or (at your option) any later version.

+#

+# GNU Radio Companion is distributed in the hope that it will be useful,

+# but WITHOUT ANY WARRANTY; without even the implied warranty of

+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

+# GNU General Public License for more details.

+#

+# You should have received a copy of the GNU General Public License

+# along with this program; if not, write to the Free Software

+# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA

+

+from __future__ import absolute_import

+

+

+class TemplateArg(str):

+ """

+ A cheetah template argument created from a param.

+ The str of this class evaluates to the param's to code method.

+ The use of this class as a dictionary (enum only) will reveal the enum opts.

+ The __call__ or () method can return the param evaluated to a raw python data type.

+ """

+

+ def __new__(cls, param):

+ value = param.to_code()

+ instance = str.__new__(cls, value)

+ setattr(instance, '_param', param)

+ return instance

+

+ def __getitem__(self, item):

+ return str(self._param.get_opt(item)) if self._param.is_enum() else NotImplemented

+

+ def __getattr__(self, item):

+ if not self._param.is_enum():

+ raise AttributeError()

+ try:

+ return str(self._param.get_opt(item))

+ except KeyError:

+ raise AttributeError()

+

+ def __str__(self):

+ return str(self._param.to_code())

+

+ def __call__(self):

+ return self._param.get_evaluated()

+ blocks, params, ports, errors, utils, schema_checker

+from .cache import Cache

+ # # FIXME: remove this as soon as converter is stable

+ # from ..converter import Converter

+ # converter = Converter(self.config.block_paths, self.config.yml_block_cache)

+ # converter.run()

+ # logging.info('XML converter done.')

+

+ with Cache(Constants.CACHE_FILE) as cache:

+ for file_path in self._iter_files_in_block_path(path):

+ data = cache.get_or_load(file_path)

+

+ if file_path.endswith('.block.yml'):

+ loader = self.load_block_description

+ scheme = schema_checker.BLOCK_SCHEME

+ elif file_path.endswith('.domain.yml'):

+ loader = self.load_domain_description

+ scheme = schema_checker.DOMAIN_SCHEME

+ elif file_path.endswith('.tree.yml'):

+ loader = self.load_category_tree_description

+ scheme = None

+ else:

+ continue

+

+ try:

+ checker = schema_checker.Validator(scheme)

+ passed = checker.run(data)

+ for msg in checker.messages:

+ logger.warning('{:<40s} {}'.format(os.path.basename(file_path), msg))

+ if not passed:

+ logger.info('YAML schema check failed for: ' + file_path)

+

+ loader(data, file_path)

+ except Exception as error:

+ logger.exception('Error while loading %s', file_path)

+ logger.exception(error)

+ raise

+ for dirpath, dirnames, filenames in os.walk(entry):

+ for filename in sorted(filter(lambda f: f.endswith('.' + ext), filenames)):

+ yield os.path.join(dirpath, filename)

+ block_id = data['id'] = data['id'].rstrip('_')

+ log.warning('Block with id "%s" loaded from\n %s\noverwritten by\n %s',

+ block_id, self.blocks[block_id].loaded_from, file_path)

+ block_cls = self.blocks[block_id] = self.new_block_class(**data)

+ block_cls.loaded_from = file_path

+ if not isinstance(name, six.string_types):

+ log.debug('Invalid name %r', name)

+ for element in utils.to_list(elements):

+ if isinstance(element, six.string_types):

+ None: params.Param, # default

+ def new_block_class(self, **data):

+ return blocks.build(**data)

+ category=str_,

+import six

+

+

+

+def to_list(value):

+ if not value:

+ return []

+ elif isinstance(value, six.string_types):

+ return [value]

+ else:

+ return list(value)

+

+from __future__ import absolute_import

+

+import six

+

+ if isinstance(value, six.text_type) and value.startswith('${') and value.endswith('}'):

+ if isinstance(allowed_values, six.string_types):

+ allowed_values = set(allowed_values.split())

+ self.allowed_values = allowed_values

+ default = default if default is not None else next(iter(self.allowed_values))

+ keypresses=["Delete"],

+ file_path, background_transparent = SaveScreenShotDialog(main, page.get_file_path()).run()

+ def __init__(self, param, changed_callback=None, editing_callback=None, transient_for=None):

+ self._transient_for = transient_for

+ self.param.parent_flowgraph.install_external_editor(self.param, parent=self._transient_for)

+ # get the paths

+ # build the dialog

+ file_dialog = Gtk.FileChooserDialog(

+ 'Open a Data File...', None, Gtk.FileChooserAction.OPEN,

+ ('gtk-cancel', Gtk.ResponseType.CANCEL, 'gtk-open', Gtk.ResponseType.OK),

+ transient_for=self._transient_for,

+ )

+ file_dialog = Gtk.FileChooserDialog(

+ 'Save a Data File...', None, Gtk.FileChooserAction.SAVE,

+ ('gtk-cancel', Gtk.ResponseType.CANCEL, 'gtk-save', Gtk.ResponseType.OK),

+ transient_for=self._transient_for,

+ )

+ file_dialog.set_current_name(basename) # show the current filename

+ file_dialog.set_current_folder(dirname) # current directory

+ if Gtk.ResponseType.OK == file_dialog.run(): # run the dialog

+ file_path = file_dialog.get_filename() # get the file path

+ def new_block_class(self, **data):

+ cls = CorePlatform.new_block_class(self, **data)

+ input_widget = param.get_input(self._handle_changed, self._activate_apply,

+ transient_for=self.get_transient_for())

+ label.set_markup('<span {color}>{name}</span>'.format(

+ color='foreground="red"' if not box_all_valid else '', name=Utils.encode(category)

+import numbers

+

+ if isinstance(num, numbers.Complex):

+ def install_external_editor(self, param, parent=None):

+ Dialogs.choose_editor(parent, config)) # todo: pass in parent

+import numbers

+from .drawable import Drawable

+from ...core.params import Param as CoreParam

+ elif isinstance(e, numbers.Complex):

+id: block_key

+label: testname

+

+parameters:

+- id: vlen

+ label: Vec Length

+ category: test

+ dtype: int

+ default: '1'

+ hide: ${ 'part' if vlen == 1 else 'none' }

+- id: out_type

+ label: Vec Length

+ dtype: string

+ default: complex

+ hide: part

+- id: a

+ label: Alpha

+ dtype: ${ (out_type) }

+ default: '0'

+

+inputs:

+- domain: stream

+ dtype: complex

+ vlen: ${ 2 * vlen }

+- domain: message

+ id: in2

+

+outputs:

+- domain: stream

+ dtype: ${ out_type }

+ vlen: ${ vlen }

+asserts:

+- ${ vlen > 0 }

+

+templates:

+ make: blocks.complex_to_mag_squared(${vlen})

+

+file_format: 1

+id: blocks_and_const_xx

+label: And Const

+

+parameters:

+- id: type

+ label: IO Type

+ dtype: enum

+ options: [int, short, byte]

+ option_attributes:

+ fcn: [ii, ss, bb]

+ hide: part

+- id: const

+ label: Constant

+ dtype: int

+ default: '0'

+

+inputs:

+- domain: stream

+ dtype: ${ type }

+

+outputs:

+- domain: stream

+ dtype: ${ type }

+

+templates:

+ imports: from gnuradio import blocks

+ make: blocks.and_const_${type.fcn}(${const})

+ callbacks:

+ - set_k(${const})

+

+file_format: 1

+id: variable_qtgui_check_box

+label: QT GUI Check Box

+

+parameters:

+- id: label

+ label: Label

+ dtype: string

+ hide: ${ ('none' if label else 'part') }

+- id: type

+ label: Type

+ dtype: enum

+ default: int

+ options: [real, int, string, bool, raw]

+ option_labels: [Float, Integer, String, Boolean, Any]

+ option_attributes:

+ conv: [float, int, str, bool, eval]

+ hide: part

+- id: value

+ label: Default Value

+ dtype: ${ type }

+ default: 'True'

+- id: 'true'

+ label: 'True'

+ dtype: ${ type }

+ default: 'True'

+- id: 'false'

+ label: 'False'

+ dtype: ${ type }

+ default: 'False'

+- id: gui_hint

+ label: GUI Hint

+ dtype: gui_hint

+ hide: part

+value: ${ value }

+

+asserts:

+- ${value in (true, false)}

+

+templates:

+ imports: from PyQt4 import Qt

+ var_make: self.${id} = ${id} = ${value}

+ callbacks:

+ - self.set_${id}(${value})

+ - self._${id}_callback(${id})

+ make: |-

+ <%

+ win = '_%s_check_box'%id

+ if not label:

+ label = id

+ %>

+ ${win} = Qt.QCheckBox(${label})

+ self._${id}_choices = {True: ${true}, False: ${false}}

+ self._${id}_choices_inv = dict((v,k) for k,v in self._${id}_choices.iteritems())

+ self._${id}_callback = lambda i: Qt.QMetaObject.invokeMethod(${win}, "setChecked", Qt.Q_ARG("bool", self._${id}_choices_inv[i]))

+ self._${id}_callback(self.${id})

+ ${win}.stateChanged.connect(lambda i: self.set_${id}(self._${id}_choices[bool(i)]))

+ ${gui_hint()(win)}

+

+documentation: |-

+ This block creates a variable check box. Leave the label blank to use the variable id as the label.

+

+ A check box selects between two values of similar type. Te values do not necessarily need to be of boolean type.

+

+ The GUI hint can be used to position the widget within the application. The hint is of the form [tab_id@tab_index]: [row, col, row_span, col_span]. Both the tab specification and the grid position are optional.

+

+file_format: 1