+# Copyright 2011,2013,2017 Free Software Foundation, Inc.

+message(STATUS "")

+

+GR_PYTHON_CHECK_MODULE_RAW(

+ "python2 >= 2.7.6 or python3 >= 3.4.0"

+ "import sys; \

+ requirement = (3, 4, 0) if sys.version_info.major >= 3 else (2, 7, 6); \

+ assert sys.version_info[:3] >= requirement"

+ PYTHON_MIN_VER_FOUND

+)

+

+GR_PYTHON_CHECK_MODULE_RAW(

+ "PyYAML >= 3.10"

+ "import yaml; assert yaml.__version__ >= '3.11'"

+ PYYAML_FOUND

+)

+

+GR_PYTHON_CHECK_MODULE_RAW(

+ "mako >= 0.9.1"

+ "import mako; assert mako.__version__ >= '0.9.1'"

+ MAKO_FOUND

+)

+

+GR_PYTHON_CHECK_MODULE_RAW(

+ "lxml >= 1.3.6"

+ "import lxml.etree; assert lxml.etree.LXML_VERSION >= (1, 3, 6, 0)"

+ LXML_FOUND

+)

+

+GR_PYTHON_CHECK_MODULE_RAW(

+ "pygobject >= 2.28.6"

+ "import gi; assert gi.version_info >= (2, 28, 6)"

+ PYGI_FOUND

+)

+

+GR_PYTHON_CHECK_MODULE_RAW(

+ "Gtk (GI) >= 3.10.8"

+ "import gi; gi.require_version('Gtk', '3.0'); \

+ from gi.repository import Gtk; Gtk.check_version(3, 10, 8)"

+ GTK_GI_FOUND

+)

+

+GR_PYTHON_CHECK_MODULE_RAW(

+ "Cairo (GI) >= 1.0"

+ "import gi; gi.require_foreign('cairo', 'Context')" # Cairo 1.13.0

+ CAIRO_GI_FOUND

+)

+

+GR_PYTHON_CHECK_MODULE_RAW(

+ "PangoCairo (GI) >= 1.0"

+ "import gi; gi.require_version('PangoCairo', '1.0')" # pangocairo 1.36.3

+ PANGOCAIRO_GI_FOUND

+)

+

+GR_PYTHON_CHECK_MODULE_RAW(

+ "numpy"

+ "import numpy"

+ NUMPY_FOUND

+)

+ PYYAML_FOUND

+ MAKO_FOUND

+ PYGI_FOUND

+ GTK_GI_FOUND

+ CAIRO_GI_FOUND

+ PANGOCAIRO_GI_FOUND

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

+# Install (+ compile) python sources and data files

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

+ DESTINATION "${GR_PYTHON_DIR}/gnuradio/grc"

+)

+

+GR_PYTHON_INSTALL(

+ DIRECTORY core gui converter

+ DESTINATION "${GR_PYTHON_DIR}/gnuradio/grc"

+ FILES_MATCHING REGEX "\\.(py|dtd|grc|tmpl|png|mako)$"

+# Append NSIS commands to set environment variables

+file(GLOB yml_files "*.yml")

+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: message

+label: Message

+color: "#FFFFFF"

+

+multiple_connections_per_input: true

+multiple_connections_per_output: true

+

+templates:

+- type: [message, message]

+ connect: self.msg_connect(${ make_port_sig(source) }, ${ make_port_sig(sink) })

+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: stream

+label: Stream

+color: "#000000"

+

+multiple_connections_per_input: false

+multiple_connections_per_output: true

+

+templates:

+- type: [stream, stream]

+ connect: self.connect(${ make_port_sig(source) }, ${ make_port_sig(sink) })

+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())

+from .core.platform import Platform

+ prefs=gr.prefs(),

+ platform.build_library()

+

+# Copyright 2016 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

+

+from .main import Converter

+# Copyright 2016 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

+

+# TODO: implement cli

+

+# Copyright 2016 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

+"""

+Converter for legacy block definitions in XML format

+

+- Cheetah expressions that can not be converted are passed to Cheetah for now

+- Instead of generating a Block subclass directly a string representation is

+ used and evaluated. This is slower / lamer but allows us to show the user

+ how a converted definition would look like

+"""

+

+from __future__ import absolute_import, division, print_function

+

+from collections import OrderedDict, defaultdict

+from itertools import chain

+

+from ..core.io import yaml

+from . import cheetah_converter, xml

+

+current_file_format = 1

+reserved_block_keys = ('import', ) # todo: add more keys

+

+

+def from_xml(filename):

+ """Load block description from xml file"""

+ element, version_info = xml.load(filename, 'block.dtd')

+

+ try:

+ data = convert_block_xml(element)

+ except NameError:

+ raise ValueError('Conversion failed', filename)

+

+ return data

+

+

+def dump(data, stream):

+ out = yaml.dump(data)

+

+ replace = [

+ ('parameters:', '\nparameters:'),

+ ('inputs:', '\ninputs:'),

+ ('outputs:', '\noutputs:'),

+ ('templates:', '\ntemplates:'),

+ ('documentation:', '\ndocumentation:'),

+ ('file_format:', '\nfile_format:'),

+ ]

+ for r in replace:

+ out = out.replace(*r)

+ prefix = '# auto-generated by grc.converter\n\n'

+ stream.write(prefix + out)

+

+

+no_value = object()

+dummy = cheetah_converter.DummyConverter()

+

+

+def convert_block_xml(node):

+ converter = cheetah_converter.Converter(names={

+ param_node.findtext('key'): {

+ opt_node.text.split(':')[0]

+ for opt_node in next(param_node.iterfind('option'), param_node).iterfind('opt')

+ } for param_node in node.iterfind('param')

+ })

+

+ block_id = node.findtext('key')

+ if block_id in reserved_block_keys:

+ block_id += '_'

+

+ data = OrderedDict()

+ data['id'] = block_id

+ data['label'] = node.findtext('name') or no_value

+ data['category'] = node.findtext('category') or no_value

+ data['flags'] = node.findtext('flags') or no_value

+

+ data['parameters'] = [convert_param_xml(param_node, converter.to_python_dec)

+ for param_node in node.iterfind('param')] or no_value

+ # data['params'] = {p.pop('key'): p for p in data['params']}

+

+ data['inputs'] = [convert_port_xml(port_node, converter.to_python_dec)

+ for port_node in node.iterfind('sink')] or no_value

+

+ data['outputs'] = [convert_port_xml(port_node, converter.to_python_dec)

+ for port_node in node.iterfind('source')] or no_value

+ data['value'] = (

+ converter.to_python_dec(node.findtext('var_value')) or

+ ('${ value }' if block_id.startswith('variable') else no_value)

+ )

+

+ data['asserts'] = [converter.to_python_dec(check_node.text)

+ for check_node in node.iterfind('check')] or no_value

+

+ data['templates'] = convert_templates(node, converter.to_mako, block_id) or no_value

+

+ docs = node.findtext('doc')

+ if docs:

+ docs = docs.strip().replace('\\\n', '')

+ data['documentation'] = yaml.MultiLineString(docs)

+

+ data['file_format'] = current_file_format

+

+ data = OrderedDict((key, value) for key, value in data.items() if value is not no_value)

+ auto_hide_params_for_item_sizes(data)

+

+ return data

+

+

+def auto_hide_params_for_item_sizes(data):

+ item_size_templates = []

+ vlen_templates = []

+ for port in chain(*[data.get(direction, []) for direction in ['inputs', 'outputs']]):

+ for key in ['dtype', 'multiplicity']:

+ item_size_templates.append(str(port.get(key, '')))

+ vlen_templates.append(str(port.get('vlen', '')))

+ item_size_templates = ' '.join(value for value in item_size_templates if '${' in value)

+ vlen_templates = ' '.join(value for value in vlen_templates if '${' in value)

+

+ for param in data.get('parameters', []):

+ if param['id'] in item_size_templates:

+ param.setdefault('hide', 'part')

+ if param['id'] in vlen_templates:

+ param.setdefault('hide', "${ 'part' if vlen == 1 else 'none' }")

+

+

+def convert_templates(node, convert, block_id=''):

+ templates = OrderedDict()

+

+ imports = '\n'.join(convert(import_node.text)

+ for import_node in node.iterfind('import'))

+ if '\n' in imports:

+ imports = yaml.MultiLineString(imports)

+ templates['imports'] = imports or no_value

+

+ templates['var_make'] = convert(node.findtext('var_make') or '') or no_value

+

+ make = convert(node.findtext('make') or '')

+ if make:

+ check_mako_template(block_id, make)

+ if '\n' in make:

+ make = yaml.MultiLineString(make)

+ templates['make'] = make or no_value

+

+ templates['callbacks'] = [

+ convert(cb_node.text) for cb_node in node.iterfind('callback')

+ ] or no_value

+

+ return OrderedDict((key, value) for key, value in templates.items() if value is not no_value)

+

+

+def convert_param_xml(node, convert):

+ param = OrderedDict()

+ param['id'] = node.findtext('key').strip()

+ param['label'] = node.findtext('name').strip()

+ param['category'] = node.findtext('tab') or no_value

+

+ param['dtype'] = convert(node.findtext('type') or '')

+ param['default'] = node.findtext('value') or no_value

+

+ options = yaml.ListFlowing(on.findtext('key') for on in node.iterfind('option'))

+ option_labels = yaml.ListFlowing(on.findtext('name') for on in node.iterfind('option'))

+ param['options'] = options or no_value

+ if not all(str(o).title() == l for o, l in zip(options, option_labels)):

+ param['option_labels'] = option_labels

+

+ attributes = defaultdict(yaml.ListFlowing)

+ for option_n in node.iterfind('option'):

+ for opt_n in option_n.iterfind('opt'):

+ key, value = opt_n.text.split(':', 2)

+ attributes[key].append(value)

+ param['option_attributes'] = dict(attributes) or no_value

+

+ param['hide'] = convert(node.findtext('hide')) or no_value

+

+ return OrderedDict((key, value) for key, value in param.items() if value is not no_value)

+

+

+def convert_port_xml(node, convert):

+ port = OrderedDict()

+ label = node.findtext('name')

+ # default values:

+ port['label'] = label if label not in ('in', 'out') else no_value

+

+ dtype = convert(node.findtext('type'))

+ # TODO: detect dyn message ports

+ port['domain'] = domain = 'message' if dtype == 'message' else 'stream'

+ if domain == 'message':

+ port['id'], port['label'] = label, no_value

+ else:

+ port['dtype'] = dtype

+ vlen = node.findtext('vlen')

+ port['vlen'] = int(vlen) if vlen and vlen.isdigit() else convert(vlen) or no_value

+

+ port['multiplicity'] = convert(node.findtext('nports')) or no_value

+ port['optional'] = bool(node.findtext('optional')) or no_value

+ port['hide'] = convert(node.findtext('hide')) or no_value

+

+ return OrderedDict((key, value) for key, value in port.items() if value is not no_value)

+

+

+def check_mako_template(block_id, expr):

+ import sys

+ from mako.template import Template

+ try:

+ Template(expr)

+ except Exception as error:

+ print(block_id, expr, type(error), error, '', sep='\n', file=sys.stderr)

+# Copyright 2016 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

+"""

+Converter for legacy block tree definitions in XML format

+"""

+

+from __future__ import absolute_import, print_function

+

+from ..core.io import yaml

+from . import xml

+

+

+def from_xml(filename):

+ """Load block tree description from xml file"""

+ element, version_info = xml.load(filename, 'block_tree.dtd')

+

+ try:

+ data = convert_category_node(element)

+ except NameError:

+ raise ValueError('Conversion failed', filename)

+

+ return data

+

+

+def dump(data, stream):

+ out = yaml.dump(data, indent=2)

+ prefix = '# auto-generated by grc.converter\n\n'

+ stream.write(prefix + out)

+

+

+def convert_category_node(node):

+ """convert nested <cat> tags to nested lists dicts"""

+ assert node.tag == 'cat'

+ name, elements = '', []

+ for child in node:

+ if child.tag == 'name':

+ name = child.text.strip()

+ elif child.tag == 'block':

+ elements.append(child.text.strip())

+ elif child.tag == 'cat':

+ elements.append(convert_category_node(child))

+ return {name: elements}

+# Copyright 2016 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

+

+import collections

+import re

+import string

+

+delims = {'(': ')', '[': ']', '{': '}', '': ', #\\*:'}

+identifier_start = '_' + string.ascii_letters + ''.join(delims.keys())

+string_delims = '"\''

+

+cheetah_substitution = re.compile(

+ r'^\$((?P<d1>\()|(?P<d2>\{)|(?P<d3>\[)|)'

+ r'(?P<arg>[_a-zA-Z][_a-zA-Z0-9]*(?:\.[_a-zA-Z][_a-zA-Z0-9]*)?)(?P<eval>\(\))?'

+ r'(?(d1)\)|(?(d2)\}|(?(d3)\]|)))$'

+)

+cheetah_inline_if = re.compile(r'#if (?P<cond>.*) then (?P<then>.*?) ?else (?P<else>.*?) ?(#|$)')

+

+

+class Python(object):

+ start = ''

+ end = ''

+ nested_start = ''

+ nested_end = ''

+ eval = ''

+ type = str # yaml_output.Eval

+

+

+class FormatString(Python):

+ start = '{'

+ end = '}'

+ nested_start = '{'

+ nested_end = '}'

+ eval = ':eval'

+ type = str

+

+

+class Mako(Python):

+ start = '${'

+ end = '}'

+ nested_start = ''

+ nested_end = ''

+ type = str

+

+

+class Converter(object):

+

+ def __init__(self, names):

+ self.stats = collections.defaultdict(int)

+ self.names = set(names)

+ self.extended = set(self._iter_identifiers(names))

+

+ @staticmethod

+ def _iter_identifiers(names):

+ if not isinstance(names, dict):

+ names = {name: {} for name in names}

+ for key, sub_keys in names.items():

+ yield key

+ for sub_key in sub_keys:

+ yield '{}.{}'.format(key, sub_key)

+

+ def to_python(self, expr):

+ return self.convert(expr=expr, spec=Python)

+

+ def to_python_dec(self, expr):

+ converted = self.convert(expr=expr, spec=Python)

+ if converted and converted != expr:

+ converted = '${ ' + converted.strip() + ' }'

+ return converted

+

+ def to_format_string(self, expr):

+ return self.convert(expr=expr, spec=FormatString)

+

+ def to_mako(self, expr):

+ return self.convert(expr=expr, spec=Mako)

+

+ def convert(self, expr, spec=Python):

+ if not expr:

+ return ''

+

+ elif '$' not in expr:

+ return expr

+

+ try:

+ return self.convert_simple(expr, spec)

+ except ValueError:

+ pass

+

+ try:

+ if '#if' in expr and '\n' not in expr:

+ expr = self.convert_inline_conditional(expr, spec)

+ return self.convert_hard(expr, spec)

+ except ValueError:

+ return 'Cheetah! ' + expr

+

+ def convert_simple(self, expr, spec=Python):

+ match = cheetah_substitution.match(expr)

+ if not match:

+ raise ValueError('Not a simple substitution: ' + expr)

+

+ identifier = match.group('arg')

+ if identifier not in self.extended:

+ raise NameError('Unknown substitution {!r}'.format(identifier))

+ if match.group('eval'):

+ identifier += spec.eval

+

+ out = spec.start + identifier + spec.end

+ if '$' in out or '#' in out:

+ raise ValueError('Failed to convert: ' + expr)

+

+ self.stats['simple'] += 1

+ return spec.type(out)

+

+ def convert_hard(self, expr, spec=Python):

+ lines = '\n'.join(self.convert_hard_line(line, spec) for line in expr.split('\n'))

+ if spec == Mako:

+ # no line-continuation before a mako control structure

+ lines = re.sub(r'\\\n(\s*%)', r'\n\1', lines)

+ return lines

+

+ def convert_hard_line(self, expr, spec=Python):

+ if spec == Mako:

+ if '#set' in expr:

+ ws, set_, statement = expr.partition('#set ')

+ return ws + '<% ' + self.to_python(statement) + ' %>'

+

+ if '#if' in expr:

+ ws, if_, condition = expr.partition('#if ')

+ return ws + '% if ' + self.to_python(condition) + ':'

+ if '#else if' in expr:

+ ws, elif_, condition = expr.partition('#else if ')

+ return ws + '% elif ' + self.to_python(condition) + ':'

+ if '#else' in expr:

+ return expr.replace('#else', '% else:')

+ if '#end if' in expr:

+ return expr.replace('#end if', '% endif')

+

+ if '#slurp' in expr:

+ expr = expr.split('#slurp', 1)[0] + '\\'

+ return self.convert_hard_replace(expr, spec)

+

+ def convert_hard_replace(self, expr, spec=Python):

+ counts = collections.Counter()

+

+ def all_delims_closed():

+ for opener_, closer_ in delims.items():

+ if counts[opener_] != counts[closer_]:

+ return False

+ return True

+

+ def extra_close():

+ for opener_, closer_ in delims.items():

+ if counts[opener_] < counts[closer_]:

+ return True

+ return False

+

+ out = []

+ delim_to_find = False

+

+ pos = 0

+ char = ''

+ in_string = None

+ while pos < len(expr):

+ prev, char = char, expr[pos]

+ counts.update(char)

+

+ if char in string_delims:

+ if not in_string:

+ in_string = char

+ elif char == in_string:

+ in_string = None

+ out.append(char)

+ pos += 1

+ continue

+ if in_string:

+ out.append(char)

+ pos += 1

+ continue

+

+ if char == '$':

+ pass # no output

+

+ elif prev == '$':

+ if char not in identifier_start: # not a substitution

+ out.append('$' + char) # now print the $ we skipped over

+

+ elif not delim_to_find: # start of a substitution

+ try:

+ delim_to_find = delims[char]

+ out.append(spec.start)

+ except KeyError:

+ if char in identifier_start:

+ delim_to_find = delims['']

+ out.append(spec.start)

+ out.append(char)

+

+ counts.clear()

+ counts.update(char)

+

+ else: # nested substitution: simply match known variable names

+ found = False

+ for known_identifier in self.names:

+ if expr[pos:].startswith(known_identifier):

+ found = True

+ break

+ if found:

+ out.append(spec.nested_start)

+ out.append(known_identifier)

+ out.append(spec.nested_end)

+ pos += len(known_identifier)

+ continue

+

+ elif delim_to_find and char in delim_to_find and all_delims_closed(): # end of substitution

+ out.append(spec.end)

+ if char in delims['']:

+ out.append(char)

+ delim_to_find = False

+

+ elif delim_to_find and char in ')]}' and extra_close(): # end of substitution

+ out.append(spec.end)

+ out.append(char)

+ delim_to_find = False

+

+ else:

+ out.append(char)

+

+ pos += 1

+

+ if delim_to_find == delims['']:

+ out.append(spec.end)

+

+ out = ''.join(out)

+ # fix: eval stuff

+ out = re.sub(r'(?P<arg>' + r'|'.join(self.extended) + r')\(\)', '\g<arg>', out)

+

+ self.stats['hard'] += 1

+ return spec.type(out)

+

+ def convert_inline_conditional(self, expr, spec=Python):

+ if spec == FormatString:

+ raise ValueError('No conditionals in format strings: ' + expr)

+ matcher = r'\g<then> if \g<cond> else \g<else>'

+ if spec == Python:

+ matcher = '(' + matcher + ')'

+ expr = cheetah_inline_if.sub(matcher, expr)

+ return spec.type(self.convert_hard(expr, spec))

+

+

+class DummyConverter(object):

+

+ def __init__(self, names={}):

+ pass

+

+ def to_python(self, expr):

+ return expr

+

+ def to_format_string(self, expr):

+ return expr

+

+ def to_mako(self, expr):

+ return expr

+<!--

+Copyright 2008 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

+-->

+<!--

+ flow_graph.dtd

+ Josh Blum

+ The document type definition for flow graph xml files.

+ -->

+<!ELEMENT flow_graph (timestamp?, block*, connection*)> <!-- optional timestamp -->

+<!ELEMENT timestamp (#PCDATA)>

+<!-- Block -->

+<!ELEMENT block (key, param*, bus_sink?, bus_source?)>

+<!ELEMENT param (key, value)>

+<!ELEMENT key (#PCDATA)>

+<!ELEMENT value (#PCDATA)>

+<!ELEMENT bus_sink (#PCDATA)>

+<!ELEMENT bus_source (#PCDATA)>

+<!-- Connection -->

+<!ELEMENT connection (source_block_id, sink_block_id, source_key, sink_key)>

+<!ELEMENT source_block_id (#PCDATA)>

+<!ELEMENT sink_block_id (#PCDATA)>

+<!ELEMENT source_key (#PCDATA)>

+<!ELEMENT sink_key (#PCDATA)>

+# 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, division

+

+import ast

+from collections import OrderedDict

+

+from ..core.io import yaml

+from . import xml

+

+

+def from_xml(filename):

+ """Load flow graph from xml file"""

+ element, version_info = xml.load(filename, 'flow_graph.dtd')

+

+ data = convert_flow_graph_xml(element)

+ try:

+ file_format = int(version_info['format'])

+ except KeyError:

+ file_format = _guess_file_format_1(data)

+

+ data['metadata'] = {'file_format': file_format}

+

+ return data

+

+

+def dump(data, stream):

+ out = yaml.dump(data, indent=2)

+

+ replace = [

+ ('blocks:', '\nblocks:'),

+ ('connections:', '\nconnections:'),

+ ('metadata:', '\nmetadata:'),

+ ]

+ for r in replace:

+ out = out.replace(*r)

+ prefix = '# auto-generated by grc.converter\n\n'

+ stream.write(prefix + out)

+

+

+def convert_flow_graph_xml(node):

+ blocks = [

+ convert_block(block_data)

+ for block_data in node.findall('block')

+ ]

+

+ options = next(b for b in blocks if b['id'] == 'options')

+ blocks.remove(options)

+ options.pop('id')

+

+ connections = [

+ convert_connection(connection)

+ for connection in node.findall('connection')

+ ]

+

+ flow_graph = OrderedDict()

+ flow_graph['options'] = options

+ flow_graph['blocks'] = blocks

+ flow_graph['connections'] = connections

+ return flow_graph

+

+

+def convert_block(data):

+ block_id = data.findtext('key')

+

+ params = OrderedDict(sorted(

+ (param.findtext('key'), param.findtext('value'))

+ for param in data.findall('param')

+ ))

+ states = OrderedDict()

+ x, y = ast.literal_eval(params.pop('_coordinate', '(10, 10)'))

+ states['coordinate'] = yaml.ListFlowing([x, y])

+ states['rotation'] = int(params.pop('_rotation', '0'))

+ enabled = params.pop('_enabled', 'True')

+ states['state'] = (

+ 'enabled' if enabled in ('1', 'True') else

+ 'bypassed' if enabled == '2' else

+ 'disabled'

+ )

+

+ block = OrderedDict()

+ if block_id != 'options':

+ block['name'] = params.pop('id')

+ block['id'] = block_id

+ block['parameters'] = params

+ block['states'] = states

+

+ return block

+

+

+def convert_connection(data):

+ src_blk_id = data.findtext('source_block_id')

+ src_port_id = data.findtext('source_key')

+ snk_blk_id = data.findtext('sink_block_id')

+ snk_port_id = data.findtext('sink_key')

+

+ if src_port_id.isdigit():

+ src_port_id = 'out' + src_port_id

+ if snk_port_id.isdigit():

+ snk_port_id = 'in' + snk_port_id

+

+ return yaml.ListFlowing([src_blk_id, src_port_id, snk_blk_id, snk_port_id])

+

+

+def _guess_file_format_1(data):

+ """Try to guess the file format for flow-graph files without version tag"""

+

+ def has_numeric_port_ids(src_id, src_port_id, snk_id, snk_port_id):

+ return src_port_id.isdigit() and snk_port_id.is_digit()

+

+ try:

+ if any(not has_numeric_port_ids(*con) for con in data['connections']):

+ return 1

+ except:

+ pass

+ return 0

+# Copyright 2016 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

+

+from codecs import open

+import json

+import logging

+import os

+

+import six

+

+from . import block_tree, block

+

+path = os.path

+logger = logging.getLogger(__name__)

+

+excludes = [

+ 'qtgui_',

+ '.grc_gnuradio/',

+ 'blks2',

+ 'wxgui',

+ 'epy_block.xml',

+ 'virtual_sink.xml',

+ 'virtual_source.xml',

+ 'dummy.xml',

+ 'variable_struct.xml', # todo: re-implement as class

+ 'digital_constellation', # todo: fix template

+]

+

+

+class Converter(object):

+

+ def __init__(self, search_path, output_dir='~/.cache/grc_gnuradio'):

+ self.search_path = search_path

+ self.output_dir = os.path.expanduser(output_dir)

+ logger.info("Saving converted files to {}".format(self.output_dir))

+

+ self._force = False

+

+ converter_module_path = path.dirname(__file__)

+ self._converter_mtime = max(path.getmtime(path.join(converter_module_path, module))

+ for module in os.listdir(converter_module_path)

+ if not module.endswith('flow_graph.py'))

+

+ self.cache_file = os.path.join(self.output_dir, '_cache.json')

+ self.cache = {}

+

+ def run(self, force=False):

+ self._force = force

+

+ try:

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

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

+ self.cache = byteify(json.load(cache_file))

+ except (IOError, ValueError):

+ self.cache = {}

+ self._force = True

+ need_cache_write = False

+

+ if not path.isdir(self.output_dir):

+ os.makedirs(self.output_dir)

+ if self._force:

+ for name in os.listdir(self.output_dir):

+ os.remove(os.path.join(self.output_dir, name))

+

+ for xml_file in self.iter_files_in_block_path():

+ if xml_file.endswith("block_tree.xml"):

+ changed = self.load_category_tree_xml(xml_file)

+ elif xml_file.endswith('domain.xml'):

+ continue

+ else:

+ changed = self.load_block_xml(xml_file)

+

+ if changed:

+ need_cache_write = True

+

+ if need_cache_write:

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

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

+ json.dump(self.cache, cache_file)

+

+ def load_block_xml(self, xml_file):

+ """Load block description from xml file"""

+ if any(part in xml_file for part in excludes):

+ return

+

+ block_id_from_xml = path.basename(xml_file)[:-4]

+ yml_file = path.join(self.output_dir, block_id_from_xml + '.block.yml')

+

+ if not self.needs_conversion(xml_file, yml_file):

+ return # yml file up-to-date

+

+ logger.info('Converting block %s', path.basename(xml_file))

+ data = block.from_xml(xml_file)

+ if block_id_from_xml != data['id']:

+ logger.warning('block_id and filename differ')

+ self.cache[yml_file] = data

+

+ with open(yml_file, 'w', encoding='utf-8') as yml_file:

+ block.dump(data, yml_file)

+ return True

+

+ def load_category_tree_xml(self, xml_file):

+ """Validate and parse category tree file and add it to list"""

+ module_name = path.basename(xml_file)[:-len('block_tree.xml')].rstrip('._-')

+ yml_file = path.join(self.output_dir, module_name + '.tree.yml')

+

+ if not self.needs_conversion(xml_file, yml_file):

+ return # yml file up-to-date

+

+ logger.info('Converting module %s', path.basename(xml_file))

+ data = block_tree.from_xml(xml_file)

+ self.cache[yml_file] = data

+

+ with open(yml_file, 'w', encoding='utf-8') as yml_file:

+ block_tree.dump(data, yml_file)

+ return True

+

+ def needs_conversion(self, source, destination):

+ """Check if source has already been converted and destination is up-to-date"""

+ if self._force or not path.exists(destination):

+ return True

+ xml_time = path.getmtime(source)

+ yml_time = path.getmtime(destination)

+

+ return yml_time < xml_time or yml_time < self._converter_mtime

+

+ def iter_files_in_block_path(self, suffix='.xml'):

+ """Iterator for block descriptions and category trees"""

+ for block_path in self.search_path:

+ if path.isfile(block_path):

+ yield block_path

+ elif path.isdir(block_path):

+ for root, _, files in os.walk(block_path, followlinks=True):

+ for name in files:

+ if name.endswith(suffix):

+ yield path.join(root, name)

+ else:

+ logger.warning('Invalid entry in search path: {}'.format(block_path))

+

+

+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

+# 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, division

+

+import re

+from os import path

+

+try:

+ # raise ImportError()

+ from lxml import etree

+ HAVE_LXML = True

+except ImportError:

+ import xml.etree.ElementTree as etree

+ HAVE_LXML = False

+

+

+_validator_cache = {None: lambda xml: True}

+

+

+def _get_validator(dtd=None):

+ validator = _validator_cache.get(dtd)

+ if not validator:

+ if not path.isabs(dtd):

+ dtd = path.join(path.dirname(__file__), dtd)

+ validator = _validator_cache[dtd] = etree.DTD(dtd).validate

+ return validator

+

+

+def load_lxml(filename, document_type_def=None):

+ """Load block description from xml file"""

+

+ try:

+ xml_tree = etree.parse(filename)

+ _get_validator(document_type_def)

+ element = xml_tree.getroot()

+ except etree.LxmlError:

+ raise ValueError("Failed to parse or validate {}".format(filename))

+

+ version_info = {}

+ for inst in xml_tree.xpath('/processing-instruction()'):

+ if inst.target == 'grc':

+ version_info.update(inst.attrib)

+

+ return element, version_info

+

+

+def load_stdlib(filename, document_type_def=None):

+ """Load block description from xml file"""

+

+ with open(filename, 'rb') as xml_file:

+ data = xml_file.read().decode('utf-8')

+

+ try:

+ element = etree.fromstring(data)

+ except etree.ParseError:

+ raise ValueError("Failed to parse {}".format(filename))

+

+ version_info = {}

+ for body in re.findall(r'<\?(.*?)\?>', data):

+ element = etree.fromstring('<' + body + '/>')

+ if element.tag == 'grc':

+ version_info.update(element.attrib)

+

+ return element, version_info

+

+

+load = load_lxml if HAVE_LXML else load_stdlib

+"""Copyright 2016 Free Software Foundation, Inc.

+from __future__ import absolute_import

+

+ yml_block_cache = os.path.expanduser('~/.cache/grc_gnuradio') # FIXME: remove this as soon as converter is stable

+

+ def __init__(self, version, version_parts=None, name=None, prefs=None):

+ self._gr_prefs = prefs if prefs else DummyPrefs()

+ if not os.path.exists(self.yml_block_cache):

+ os.mkdir(self.yml_block_cache)

+

+ self.yml_block_cache,

+ self._gr_prefs.get_string('grc', 'local_blocks_path', ''),

+ self._gr_prefs.get_string('grc', 'global_blocks_path', ''),

+ self._gr_prefs.get_string('grc', 'default_flow_graph', '') or

+

+

+class DummyPrefs(object):

+

+ def get_string(self, category, item, default):

+ return str(default)

+

+ def set_string(self, category, item, value):

+ pass

+

+ def get_long(self, category, item, default):

+ return int(default)

+

+ def save(self):

+ pass

+from __future__ import absolute_import

+

+from .base import Element

+from .utils.descriptors import lazy_property

+ def __init__(self, parent, source, sink):

+ source: a port (any direction)

+ sink: a port (any direction)

+ Element.__init__(self, parent)

+

+ if not source.is_source:

+ source, sink = sink, source

+ if not source.is_source:

+ if not sink.is_sink:

+

+ self.source_port = source

+ self.sink_port = sink

+ self.source_block, self.source_port, self.sink_block, self.sink_port,

+ def __eq__(self, other):

+ if not isinstance(other, self.__class__):

+ return NotImplemented

+ return self.source_port == other.source_port and self.sink_port == other.sink_port

+ def __hash__(self):

+ return hash((self.source_port, self.sink_port))

+

+ def __iter__(self):

+ return iter((self.source_port, self.sink_port))

+

+ @lazy_property

+ def source_block(self):

+ return self.source_port.parent_block

+

+ @lazy_property

+ def sink_block(self):

+ return self.sink_port.parent_block

+ @lazy_property

+ def type(self):

+ return self.source_port.domain, self.sink_port.domain

+

+ @property

+ def enabled(self):

+ return self.source_block.enabled and self.sink_block.enabled

+ def validate(self):

+ """

+ Validate the connections.

+ The ports must match in io size.

+ """

+ Element.validate(self)

+ platform = self.parent_platform

+ if self.type not in platform.connection_templates:

+ self.add_error_message('No connection known between domains "{}" and "{}"'

+ ''.format(*self.type))

+

+ source_size = self.source_port.item_size

+ sink_size = self.sink_port.item_size

+ if source_size != sink_size:

+ self.add_error_message('Source IO size "{}" does not match sink IO size "{}".'.format(source_size, sink_size))

+ return (

+ self.source_block.name, self.source_port.key,

+ self.sink_block.name, self.sink_port.key

+ )

+from __future__ import absolute_import

+

+import numpy

+

+

+BLOCK_DESCRIPTION_FILE_FORMAT_VERSION = 1

+GR_STREAM_DOMAIN = "stream"

+GR_MESSAGE_DOMAIN = "message"

+PARAM_TYPE_NAMES = (

+ 'raw', 'enum',

+ 'complex', 'real', 'float', 'int',

+ 'complex_vector', 'real_vector', 'float_vector', 'int_vector',

+ 'hex', 'string', 'bool',

+ 'file_open', 'file_save', '_multiline', '_multiline_python_external',

+ 'id', 'stream_id',

+ 'gui_hint',

+ 'import',

+)

+

+INT_TYPES = [int, numpy.int, numpy.int8, numpy.int16, numpy.int32, numpy.uint64,

+# Updating colors. Using the standard color palette from:

+# http://www.google.com/design/spec/style/color.html#color-color-palette

+ ('Complex Float 64', 'fc64', 16, GRC_COLOR_BROWN),

+ ('Complex Float 32', 'fc32', 8, GRC_COLOR_BLUE),

+ ('Complex Integer 64', 'sc64', 16, GRC_COLOR_LIGHT_GREEN),

+ ('Complex Integer 32', 'sc32', 8, GRC_COLOR_GREEN),

+ ('Complex Integer 16', 'sc16', 4, GRC_COLOR_AMBER),

+ ('Complex Integer 8', 'sc8', 2, GRC_COLOR_PURPLE),

+ ('Float 64', 'f64', 8, GRC_COLOR_CYAN),

+ ('Float 32', 'f32', 4, GRC_COLOR_ORANGE),

+ ('Integer 64', 's64', 8, GRC_COLOR_LIME),

+ ('Integer 32', 's32', 4, GRC_COLOR_TEAL),

+ ('Integer 16', 's16', 2, GRC_COLOR_YELLOW),

+ ('Integer 8', 's8', 1, GRC_COLOR_PURPLE_A400),

+ ('Bits (unpacked byte)', 'bit', 1, GRC_COLOR_PURPLE_A100),

+ ('Async Message', 'message', 0, GRC_COLOR_GREY),

+ ('Bus Connection', 'bus', 0, GRC_COLOR_WHITE),

+ ('Wildcard', '', 0, GRC_COLOR_WHITE),

+ 'float': (4, GRC_COLOR_ORANGE),

+ 'int': (4, GRC_COLOR_TEAL),

+ 'short': (2, GRC_COLOR_YELLOW),

+ 'byte': (1, GRC_COLOR_PURPLE_A400),

+ 'bits': (1, GRC_COLOR_PURPLE_A100),

+TYPE_TO_SIZEOF = {key: sizeof for name, key, sizeof, color in CORE_TYPES}

+TYPE_TO_SIZEOF.update((key, sizeof) for key, (sizeof, _) in ALIAS_TYPES.items())

+from __future__ import absolute_import, print_function

+

+import collections

+import itertools

+from operator import methodcaller, attrgetter

+from . import Messages, blocks

+from .base import Element

+from .utils import expr_utils

+from .utils.backports import shlex

+ def __init__(self, parent):

+ parent: a platforms with blocks and element factories

+ Element.__init__(self, parent)

+ self._options_block = self.parent_platform.make_block(self, 'options')

+ self.blocks = [self._options_block]

+ self.connections = set()

+ def imports(self):

+ a list of import statements

+ return [block.templates.render('imports') for block in self.iter_enabled_blocks()]

+ variables = [block for block in self.iter_enabled_blocks() if block.is_variable]

+ return expr_utils.sort_objects(variables, attrgetter('name'), methodcaller('get_var_make'))

+ parameters = [b for b in self.iter_enabled_blocks() if b.key == 'parameter']

+ monitors = [b for b in self.iter_enabled_blocks() if 'ctrlport_monitor' in b.key]

+ if block.key == 'epy_module':

+ yield block.name, block.params[1].get_value()

+ return (block for block in self.blocks if block.enabled)

+ return [block for block in self.blocks if block.get_bypassed()]

+ return [connection for connection in self.connections if connection.enabled]

+ return self._options_block.params[key].get_evaluated()

+ def get_block(self, name):

+ if block.name == name:

+ raise KeyError('No block with name {!r}'.format(name))

+ elements = list(self.blocks)

+ elements.extend(self.connections)

+ return elements

+ def children(self):

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

+ Element.rewrite(self)

+ for expr in self.imports():

+ exec(expr, namespace)

+ exec(expr, module.__dict__)

+ for parameter_block in self.get_parameters():

+ value = eval(parameter_block.params['value'].to_code(), namespace)

+ np[parameter_block.name] = value

+ for variable_block in self.get_variables():

+ value = eval(variable_block.value, namespace, variable_block.namespace)

+ namespace[variable_block.name] = value

+ def evaluate(self, expr, namespace=None, local_namespace=None):

+ if namespace is not None:

+ return eval(expr, namespace, local_namespace)

+ else:

+ return self._eval_cache.setdefault(expr, eval(expr, self.namespace))

+ def new_block(self, block_id, **kwargs):

+ block_id: the block key

+ if block_id == 'options':

+ return self._options_block

+ block = self.parent_platform.make_block(self, block_id, **kwargs)

+ connection = self.parent_platform.Connection(

+ parent=self, source=porta, sink=portb)

+ self.connections.add(connection)

+ def disconnect(self, *ports):

+ to_be_removed = [con for con in self.connections

+ if any(port in con for port in ports)]

+ for con in to_be_removed:

+ self.remove_element(con)

+

+ if element is self._options_block:

+ return

+

+ element = element.parent_block # remove parent block

+ self.disconnect(*element.ports())

+ def block_order(b):

+ return not b.key.startswith('variable'), b.name # todo: vars still first ?!?

+

+ data = collections.OrderedDict()

+ data['options'] = self._options_block.export_data()

+ data['blocks'] = [b.export_data() for b in sorted(self.blocks, key=block_order)

+ if b is not self._options_block]

+ data['connections'] = sorted(c.export_data() for c in self.connections)

+ data['metadata'] = {'file_format': FLOW_GRAPH_FILE_FORMAT_VERSION}

+ return data

+

+ def _build_depending_hier_block(self, block_id):

+ # we're before the initial fg update(), so no evaluated values!

+ # --> use raw value instead

+ path_param = self._options_block.params['hier_block_src_path']

+ file_path = self.parent_platform.find_file_in_paths(

+ filename=block_id + '.grc',

+ paths=path_param.get_value(),

+ cwd=self.grc_file_path

+ )

+ if file_path: # grc file found. load and get block

+ self.parent_platform.load_and_generate_flow_graph(file_path, hier_only=True)

+ return self.new_block(block_id) # can be None

+

+ def import_data(self, data):

+ Clear this flow graph of all previous blocks and connections.

+ data: the nested data odict

+ self.connections.clear()

+ file_format = data['metadata']['file_format']

+ self._options_block.import_data(name='', **data.get('options', {}))

+ self.blocks.append(self._options_block)

+

+ for block_data in data.get('blocks', []):

+ block_id = block_data['id']

+ block = (

+ self.new_block(block_id) or

+ self._build_depending_hier_block(block_id) or

+ self.new_block(block_id='_dummy', missing_block_id=block_id, **block_data)

+ )

+

+ if isinstance(block, blocks.DummyBlock):

+ print('Block id "%s" not found' % block_id)

+

+ block.import_data(**block_data)

+ ports = block.sinks if dir == 'sink' else block.sources

+ if key == port.key or key + '0' == port.key:

+ if not key.isdigit() and port.dtype == '' and key == port.name:

+ port = block.add_missing_port(key, dir)

+ had_connect_errors = False

+ _blocks = {block.name: block for block in self.blocks}

+

+ try:

+ # TODO: Add better error handling if no connections exist in the flowgraph file.

+ for src_blk_id, src_port_id, snk_blk_id, snk_port_id in data.get('connections', []):

+ source_block = _blocks[src_blk_id]

+ sink_block = _blocks[snk_blk_id]

+ src_port_id, snk_port_id = _update_old_message_port_keys(

+ src_port_id, snk_port_id, source_block, sink_block)

+ source_port = verify_and_get_port(src_port_id, source_block, 'source')

+ sink_port = verify_and_get_port(snk_port_id, sink_block, 'sink')

+

+ except (KeyError, LookupError) as e:

+ Messages.send_error_load(

+ 'Connection between {}({}) and {}({}) could not be made.\n\t{}'.format(

+ src_blk_id, src_port_id, snk_blk_id, snk_port_id, e))

+ had_connect_errors = True

+ self.rewrite() # global rewrite

+ return had_connect_errors

+ # get ports using the "old way" (assuming linear indexed keys)

+ source_port = source_block.sources[int(source_key)]

+ sink_port = sink_block.sinks[int(sink_key)]

+ if source_port.dtype == "message" and sink_port.dtype == "message":

+ source_key, sink_key = source_port.key, sink_port.key

+from __future__ import absolute_import

+

+def send_fail_connection(msg=''):

+ send('>>> Error: Cannot create connection.\n' + ('\t{}\n'.format(msg) if msg else ''))

+from __future__ import absolute_import

+

+import numbers

+import collections

+import six

+from six.moves import builtins, range

+from . import Constants, blocks

+from .base import Element

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

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

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

+except (ImportError, AttributeError):

+class TemplateArg(str):

+ def __new__(cls, param):

+ value = param.to_code()

+ instance = str.__new__(cls, value)

+ setattr(instance, '_param', param)

+ return instance

+@setup_names

+ 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._stringify_flag = False

+ self._lisitify_flag = False

+ self._init = False

+ @property

+ def template_arg(self):

+ return TemplateArg(self)

+ 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

+ 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'