- "lxml >= 1.3.6"

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

- LXML_FOUND

-)

-

-GR_PYTHON_CHECK_MODULE_RAW(

- LXML_FOUND

- log.exception('Failed to evaluate expression in namespace', exc_info=True)

-"""

-Copyright 2008, 2015 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 lxml import etree

-

-import six

-from six.moves import map

-

-

-xml_failures = {}

-etree.set_default_parser(etree.XMLParser(remove_comments=True))

-

-

-class XMLSyntaxError(Exception):

- def __init__(self, error_log):

- self._error_log = error_log

- xml_failures[error_log.last_error.filename] = error_log

-

- def __str__(self):

- return '\n'.join(map(str, self._error_log.filter_from_errors()))

-

-

-def validate_dtd(xml_file, dtd_file=None):

- """

- Validate an xml file against its dtd.

-

- Args:

- xml_file: the xml file

- dtd_file: the optional dtd file

- @throws Exception validation fails

- """

- # Perform parsing, use dtd validation if dtd file is not specified

- parser = etree.XMLParser(dtd_validation=not dtd_file)

- try:

- xml = etree.parse(xml_file, parser=parser)

- except etree.LxmlError:

- pass

- if parser.error_log:

- raise XMLSyntaxError(parser.error_log)

-

- # Perform dtd validation if the dtd file is specified

- if not dtd_file:

- return

- try:

- dtd = etree.DTD(dtd_file)

- if not dtd.validate(xml.getroot()):

- raise XMLSyntaxError(dtd.error_log)

- except etree.LxmlError:

- raise XMLSyntaxError(dtd.error_log)

-

-

-def from_file(xml_file):

- """

- Create nested data from an xml file using the from xml helper.

- Also get the grc version information.

-

- Args:

- xml_file: the xml file path

-

- Returns:

- the nested data with grc version information

- """

- xml = etree.parse(xml_file)

-

- tag, nested_data = _from_file(xml.getroot())

- nested_data = {tag: nested_data, '_instructions': {}}

-

- # Get the embedded instructions and build a dictionary item

- xml_instructions = xml.xpath('/processing-instruction()')

- for inst in xml_instructions:

- if inst.target != 'grc':

- continue

- nested_data['_instructions'] = dict(inst.attrib)

- return nested_data

-

-

-WANT_A_LIST = {

- '/block': 'import callback param check sink source'.split(),

- '/block/param_tab_order': 'tab'.split(),

- '/block/param': 'option'.split(),

- '/block/param/option': 'opt'.split(),

- '/flow_graph': 'block connection'.split(),

- '/flow_graph/block': 'param'.split(),

- '/cat': 'cat block'.split(),

- '/cat/cat': 'cat block'.split(),

- '/cat/cat/cat': 'cat block'.split(),

- '/cat/cat/cat/cat': 'cat block'.split(),

- '/domain': 'connection'.split(),

-}

-

-

-def _from_file(xml, parent_tag=''):

- """

- Recursively parse the xml tree into nested data format.

-

- Args:

- xml: the xml tree

-

- Returns:

- the nested data

- """

- tag = xml.tag

- tag_path = parent_tag + '/' + tag

-

- if not len(xml):

- return tag, xml.text or '' # store empty tags (text is None) as empty string

-

- nested_data = {}

- for elem in xml:

- key, value = _from_file(elem, tag_path)

-

- if key in WANT_A_LIST.get(tag_path, []):

- try:

- nested_data[key].append(value)

- except KeyError:

- nested_data[key] = [value]

- else:

- nested_data[key] = value

-

- return tag, nested_data

-

-

-def to_file(nested_data, xml_file):

- """

- Write to an xml file and insert processing instructions for versioning

-

- Args:

- nested_data: the nested data

- xml_file: the xml file path

- """

- xml_data = ""

- instructions = nested_data.pop('_instructions', None)

- # Create the processing instruction from the array

- if instructions:

- xml_data += etree.tostring(etree.ProcessingInstruction(

- 'grc', ' '.join(

- "{0}='{1}'".format(*item) for item in six.iteritems(instructions))

- ), xml_declaration=True, pretty_print=True, encoding='utf-8')

- xml_data += etree.tostring(_to_file(nested_data)[0],

- pretty_print=True, encoding='utf-8')

- with open(xml_file, 'wb') as fp:

- fp.write(xml_data)

-

-

-def _to_file(nested_data):

- """

- Recursively parse the nested data into xml tree format.

-

- Args:

- nested_data: the nested data

-

- Returns:

- the xml tree filled with child nodes

- """

- nodes = list()

- for key, values in six.iteritems(nested_data):

- # Listify the values if not a list

- if not isinstance(values, (list, set, tuple)):

- values = [values]

- for value in values:

- node = etree.Element(key)

- if isinstance(value, (str, six.text_type)):

- node.text = six.text_type(value)

- else:

- node.extend(_to_file(value))

- nodes.append(node)

- return nodes

- #if ParseXML.xml_failures:

- # Messages.send_xml_errors_if_any(ParseXML.xml_failures)

- # Actions.XML_PARSER_ERRORS_DISPLAY.set_enabled(True)

-

- ##################################################

- # Create heir block

- ##################################################

- # keeping track of coordinates for pasting later

- coords = flow_graph.selected_blocks()[0].coordinate

- x,y = coords

- x_min = x

- y_min = y

-

- pads = [];

- params = [];

-

- # Save the state of the leaf blocks

- for block in flow_graph.selected_blocks():

-

- # Check for string variables within the blocks

- for param in block.params.values():

- for variable in flow_graph.get_variables():

- # If a block parameter exists that is a variable, create a parameter for it

- if param.get_value() == variable.name:

- params.append(param.get_value())

- for flow_param in flow_graph.get_parameters():

- # If a block parameter exists that is a parameter, create a parameter for it

- if param.get_value() == flow_param.name:

- params.append(param.get_value())

-

-

- # keep track of x,y mins for pasting later

- (x,y) = block.coordinate

- if x < x_min:

- x_min = x

- if y < y_min:

- y_min = y

-

- for connection in block.connections:

-

- # Get id of connected blocks

- source_id = connection.source_block.name

- sink_id = connection.sink_block.name

-

- # If connected block is not in the list of selected blocks create a pad for it

- if flow_graph.get_block(source_id) not in flow_graph.selected_blocks():

- pads.append({'key': connection.sink_port.key, 'coord': connection.source_port.coordinate, 'block_id' : block.name, 'direction': 'source'})

-

- if flow_graph.get_block(sink_id) not in flow_graph.selected_blocks():

- pads.append({'key': connection.source_port.key, 'coord': connection.sink_port.coordinate, 'block_id' : block.name, 'direction': 'sink'})

-

-

- # Copy the selected blocks and paste them into a new page

- # then move the flowgraph to a reasonable position

- Actions.BLOCK_COPY()

- main.new_page()

- Actions.BLOCK_PASTE()

- coords = (x_min,y_min)

- flow_graph.move_selected(coords)

- # Set flow graph to heir block type

- top_block = flow_graph.get_block("top_block")

- top_block.params['generate_options'].set_value('hb')

- # this needs to be a unique name

- top_block.params['id'].set_value('new_heir')

- # Remove the default samp_rate variable block that is created

- remove_me = flow_graph.get_block("samp_rate")

- flow_graph.remove_element(remove_me)

- # Add the param blocks along the top of the window

- x_pos = 150

- for param in params:

- param_id = flow_graph.add_new_block('parameter',(x_pos,10))

- param_block = flow_graph.get_block(param_id)

- param_block.params['id'].set_value(param)

- x_pos = x_pos + 100

- for pad in pads:

- # Add the pad sources and sinks within the new heir block

- if pad['direction'] == 'sink':

- # Add new PAD_SINK block to the canvas

- pad_id = flow_graph.add_new_block('pad_sink', pad['coord'])

- # setup the references to the sink and source

- pad_block = flow_graph.get_block(pad_id)

- pad_sink = pad_block.sinks[0]

- source_block = flow_graph.get_block(pad['block_id'])

- source = source_block.get_source(pad['key'])

- # Ensure the port types match

- while pad_sink.dtype != source.dtype:

- # Special case for some blocks that have non-standard type names, e.g. uhd

- if pad_sink.dtype == 'complex' and source.dtype == 'fc32':

- break;

- pad_block.type_controller_modify(1)

- # Connect the pad to the proper sinks

- new_connection = flow_graph.connect(source,pad_sink)

- elif pad['direction'] == 'source':

- pad_id = flow_graph.add_new_block('pad_source', pad['coord'])

- # setup the references to the sink and source

- pad_block = flow_graph.get_block(pad_id)

- pad_source = pad_block.sources[0]

- sink_block = flow_graph.get_block(pad['block_id'])

- sink = sink_block.get_sink(pad['key'])

- # Ensure the port types match

- while sink.dtype != pad_source.dtype:

- # Special case for some blocks that have non-standard type names, e.g. uhd

- if pad_source.dtype == 'complex' and sink.dtype == 'fc32':

- break;

- pad_block.type_controller_modify(1)

- # Connect the pad to the proper sinks

- new_connection = flow_graph.connect(pad_source,sink)

- # update the new heir block flow graph

- flow_graph_update()

- # ParserErrorsDialog(ParseXML.xml_failures).run()

- main.tool_bar.refresh_submenus()

- #Actions.XML_PARSER_ERRORS_DISPLAY.set_enabled(bool(ParseXML.xml_failures))

- #Messages.send_xml_errors_if_any(ParseXML.xml_failures)