1 files changed, 128 insertions, 79 deletions
diff --git a/grc/model/Port.py b/grc/model/Port.py
index 7197f75d31..ede77353c7 100644
--- a/grc/model/Port.py
+++ b/grc/model/Port.py
@@ -28,9 +28,11 @@ def _get_source_from_virtual_sink_port(vsp):
     Resolve the source port that is connected to the given virtual sink port.
     Use the get source from virtual source to recursively resolve subsequent ports.
     """
-    try: return _get_source_from_virtual_source_port(
-        vsp.get_enabled_connections()[0].get_source())
-    except: raise Exception, 'Could not resolve source for virtual sink port %s'%vsp
+    try:
+        return _get_source_from_virtual_source_port(
+            vsp.get_enabled_connections()[0].get_source())
+    except:
+        raise Exception('Could not resolve source for virtual sink port {}'.format(vsp))
 
 
 def _get_source_from_virtual_source_port(vsp, traversed=[]):
@@ -38,20 +40,24 @@ def _get_source_from_virtual_source_port(vsp, traversed=[]):
     Recursively resolve source ports over the virtual connections.
     Keep track of traversed sources to avoid recursive loops.
     """
-    if not vsp.get_parent().is_virtual_source(): return vsp
-    if vsp in traversed: raise Exception, 'Loop found when resolving virtual source %s'%vsp
-    try: return _get_source_from_virtual_source_port(
-        _get_source_from_virtual_sink_port(
-            filter(#get all virtual sinks with a matching stream id
-                lambda vs: vs.get_param('stream_id').get_value() == vsp.get_parent().get_param('stream_id').get_value(),
-                filter(#get all enabled blocks that are also virtual sinks
-                    lambda b: b.is_virtual_sink(),
-                    vsp.get_parent().get_parent().get_enabled_blocks(),
-                ),
-            )[0].get_sinks()[0]
-        ), traversed + [vsp],
-    )
-    except: raise Exception, 'Could not resolve source for virtual source port %s'%vsp
+    if not vsp.get_parent().is_virtual_source():
+        return vsp
+    if vsp in traversed:
+        raise Exception('Loop found when resolving virtual source {}'.format(vsp))
+    try:
+        return _get_source_from_virtual_source_port(
+            _get_source_from_virtual_sink_port(
+                filter(  # Get all virtual sinks with a matching stream id
+                    lambda vs: vs.get_param('stream_id').get_value() == vsp.get_parent().get_param('stream_id').get_value(),
+                    filter(  # Get all enabled blocks that are also virtual sinks
+                        lambda b: b.is_virtual_sink(),
+                        vsp.get_parent().get_parent().get_enabled_blocks(),
+                    ),
+                )[0].get_sinks()[0]
+            ), traversed + [vsp],
+        )
+    except:
+        raise Exception('Could not resolve source for virtual source port {}'.format(vsp))
 
 
 def _get_sink_from_virtual_source_port(vsp):
@@ -59,9 +65,12 @@ def _get_sink_from_virtual_source_port(vsp):
     Resolve the sink port that is connected to the given virtual source port.
     Use the get sink from virtual sink to recursively resolve subsequent ports.
     """
-    try: return _get_sink_from_virtual_sink_port(
-        vsp.get_enabled_connections()[0].get_sink())    # Could have many connections, but use first
-    except: raise Exception, 'Could not resolve source for virtual source port %s'%vsp
+    try:
+        # Could have many connections, but use first
+        return _get_sink_from_virtual_sink_port(
+            vsp.get_enabled_connections()[0].get_sink())
+    except:
+        raise Exception('Could not resolve source for virtual source port {}'.format(vsp))
 
 
 def _get_sink_from_virtual_sink_port(vsp, traversed=[]):
@@ -69,20 +78,24 @@ def _get_sink_from_virtual_sink_port(vsp, traversed=[]):
     Recursively resolve sink ports over the virtual connections.
     Keep track of traversed sinks to avoid recursive loops.
     """
-    if not vsp.get_parent().is_virtual_sink(): return vsp
-    if vsp in traversed: raise Exception, 'Loop found when resolving virtual sink %s'%vsp
-    try: return _get_sink_from_virtual_sink_port(
-        _get_sink_from_virtual_source_port(
-            filter(#get all virtual source with a matching stream id
-                lambda vs: vs.get_param('stream_id').get_value() == vsp.get_parent().get_param('stream_id').get_value(),
-                filter(#get all enabled blocks that are also virtual sinks
-                    lambda b: b.is_virtual_source(),
-                    vsp.get_parent().get_parent().get_enabled_blocks(),
-                ),
-            )[0].get_sources()[0]
-        ), traversed + [vsp],
-    )
-    except: raise Exception, 'Could not resolve source for virtual sink port %s'%vsp
+    if not vsp.get_parent().is_virtual_sink():
+        return vsp
+    if vsp in traversed:
+        raise Exception('Loop found when resolving virtual sink {}'.format(vsp))
+    try:
+        return _get_sink_from_virtual_sink_port(
+            _get_sink_from_virtual_source_port(
+                filter(  # Get all virtual source with a matching stream id
+                    lambda vs: vs.get_param('stream_id').get_value() == vsp.get_parent().get_param('stream_id').get_value(),
+                    filter(  # Get all enabled blocks that are also virtual sinks
+                        lambda b: b.is_virtual_source(),
+                        vsp.get_parent().get_parent().get_enabled_blocks(),
+                    ),
+                )[0].get_sources()[0]
+            ), traversed + [vsp],
+        )
+    except:
+        raise Exception('Could not resolve source for virtual sink port {}'.format(vsp))
 
 
 class Port(Element):
@@ -103,49 +116,50 @@ class Port(Element):
             n['domain'] = DEFAULT_DOMAIN
         elif n['domain'] == GR_MESSAGE_DOMAIN:
             n['key'] = n['name']
-            n['type'] = 'message'  # for port color
+            n['type'] = 'message'  # For port color
         if n['type'] == 'msg':
             n['key'] = 'msg'
         if not n.find('key'):
             n['key'] = str(next(block.port_counters[dir == 'source']))
 
-        #build the port
+        # Build the port
         Element.__init__(self, block)
-        #grab the data
+        # Grab the data
         self._name = n['name']
         self._key = n['key']
         self._type = n['type']
         self._domain = n['domain']
         self._hide = n.find('hide') or ''
         self._dir = dir
-        self._hide_evaluated = False  # updated on rewrite()
+        self._hide_evaluated = False  # Updated on rewrite()
 
         self._nports = n.find('nports') or ''
         self._vlen = n.find('vlen') or ''
         self._optional = bool(n.find('optional'))
-        self._clones = []  # references to cloned ports (for nports > 1)
+        self._clones = []  # References to cloned ports (for nports > 1)
 
     def __str__(self):
         if self.is_source():
-            return 'Source - %s(%s)'%(self.get_name(), self.get_key())
+            return 'Source - {}({})'.format(self.get_name(), self.get_key())
         if self.is_sink():
-            return 'Sink - %s(%s)'%(self.get_name(), self.get_key())
+            return 'Sink - {}({})'.format(self.get_name(), self.get_key())
 
+    def get_types(self):
+        return Constants.TYPE_TO_SIZEOF.keys()
 
-    def get_types(self): return Constants.TYPE_TO_SIZEOF.keys()
-
-    def is_type_empty(self): return not self._n['type']
+    def is_type_empty(self):
+        return not self._n['type']
 
     def validate(self):
         Element.validate(self)
         if self.get_type() not in self.get_types():
-            self.add_error_message('Type "%s" is not a possible type.' % self.get_type())
+            self.add_error_message('Type "{}" is not a possible type.'.format(self.get_type()))
         platform = self.get_parent().get_parent().get_parent()
         if self.get_domain() not in platform.get_domains():
-            self.add_error_message('Domain key "%s" is not registered.' % self.get_domain())
+            self.add_error_message('Domain key "{}" is not registered.'.format(self.get_domain()))
         if not self.get_enabled_connections() and not self.get_optional():
             self.add_error_message('Port is not connected.')
-        #message port logic
+        # Message port logic
         if self.get_type() == 'msg':
             if self.get_nports():
                 self.add_error_message('A port of type "msg" cannot have "nports" set.')
@@ -157,44 +171,54 @@ class Port(Element):
         Handle the port cloning for virtual blocks.
         """
         if self.is_type_empty():
-            try: #clone type and vlen
+            try:
+                # Clone type and vlen
                 source = self.resolve_empty_type()
                 self._type = str(source.get_type())
                 self._vlen = str(source.get_vlen())
-            except: #reset type and vlen
+            except:
+                # Reset type and vlen
                 self._type = ''
                 self._vlen = ''
         Element.rewrite(self)
         hide = self.get_parent().resolve_dependencies(self._hide).strip().lower()
         self._hide_evaluated = False if hide in ('false', 'off', '0') else bool(hide)
-        # update domain if was deduced from (dynamic) port type
+        # Update domain if was deduced from (dynamic) port type
         type_ = self.get_type()
         if self._domain == GR_STREAM_DOMAIN and type_ == "message":
             self._domain = GR_MESSAGE_DOMAIN
             self._key = self._name
         if self._domain == GR_MESSAGE_DOMAIN and type_ != "message":
             self._domain = GR_STREAM_DOMAIN
-            self._key = '0'  # is rectified in rewrite()
+            self._key = '0'  # Is rectified in rewrite()
 
     def resolve_virtual_source(self):
-        if self.get_parent().is_virtual_sink(): return _get_source_from_virtual_sink_port(self)
-        if self.get_parent().is_virtual_source(): return _get_source_from_virtual_source_port(self)
+        if self.get_parent().is_virtual_sink():
+            return _get_source_from_virtual_sink_port(self)
+        if self.get_parent().is_virtual_source():
+            return _get_source_from_virtual_source_port(self)
 
     def resolve_empty_type(self):
         if self.is_sink():
             try:
                 src = _get_source_from_virtual_sink_port(self)
-                if not src.is_type_empty(): return src
-            except: pass
+                if not src.is_type_empty():
+                    return src
+            except:
+                pass
             sink = _get_sink_from_virtual_sink_port(self)
-            if not sink.is_type_empty(): return sink
+            if not sink.is_type_empty():
+                return sink
         if self.is_source():
             try:
                 src = _get_source_from_virtual_source_port(self)
-                if not src.is_type_empty(): return src
-            except: pass
+                if not src.is_type_empty():
+                    return src
+            except:
+                pass
             sink = _get_sink_from_virtual_source_port(self)
-            if not sink.is_type_empty(): return sink
+            if not sink.is_type_empty():
+                return sink
 
     def get_vlen(self):
         """
@@ -205,8 +229,10 @@ class Port(Element):
             the vector length or 1
         """
         vlen = self.get_parent().resolve_dependencies(self._vlen)
-        try: return int(self.get_parent().get_parent().evaluate(vlen))
-        except: return 1
+        try:
+            return int(self.get_parent().get_parent().evaluate(vlen))
+        except:
+            return 1
 
     def get_nports(self):
         """
@@ -217,7 +243,8 @@ class Port(Element):
         Returns:
             the number of ports or 1
         """
-        if self._nports == '': return ''
+        if self._nports == '':
+            return ''
 
         nports = self.get_parent().resolve_dependencies(self._nports)
         try:
@@ -225,7 +252,8 @@ class Port(Element):
         except:
             return 1
 
-    def get_optional(self): return bool(self._optional)
+    def get_optional(self):
+        return bool(self._optional)
 
     def get_color(self):
         """
@@ -238,7 +266,8 @@ class Port(Element):
         try:
             color = Constants.TYPE_TO_COLOR[self.get_type()]
             vlen = self.get_vlen()
-            if vlen == 1: return color
+            if vlen == 1:
+                return color
             color_val = int(color[1:], 16)
             r = (color_val >> 16) & 0xff
             g = (color_val >> 8) & 0xff
@@ -247,7 +276,8 @@ class Port(Element):
             r = max(r-dark, 0)
             g = max(g-dark, 0)
             b = max(b-dark, 0)
-            return '#%.2x%.2x%.2x'%(r, g, b)
+            # TODO: Change this to .format()
+            return '#%.2x%.2x%.2x' % (r, g, b)
         except:
             return '#FFFFFF'
 
@@ -270,19 +300,24 @@ class Port(Element):
         Returns:
             the cloned port
         """
-        # add index to master port name if there are no clones yet
+        # Add index to master port name if there are no clones yet
         if not self._clones:
             self._name = self._n['name'] + '0'
-            if not self._key.isdigit():  # also update key for none stream ports
+            # Also update key for none stream ports
+            if not self._key.isdigit():
                 self._key = self._name
 
         # Prepare a copy of the odict for the clone
         n = self._n.copy()
-        if 'nports' in n: n.pop('nports')  # remove nports from the key so the copy cannot be a duplicator
+        # Remove nports from the key so the copy cannot be a duplicator
+        if 'nports' in n:
+            n.pop('nports')
         n['name'] = self._n['name'] + str(len(self._clones) + 1)
-        n['key'] = '99999' if self._key.isdigit() else n['name']  # dummy value 99999 will be fixed later
+        # Dummy value 99999 will be fixed later
+        n['key'] = '99999' if self._key.isdigit() else n['name']
 
-        port = self.__class__(self.get_parent(), n, self._dir)  # clone
+        # Clone
+        port = self.__class__(self.get_parent(), n, self._dir)
         self._clones.append(port)
         return port
 
@@ -292,10 +327,11 @@ class Port(Element):
         Remove the index 0 of the master port name (and key9 if there are no more clones left
         """
         self._clones.remove(port)
-        # remove index from master port name if there are no more clones
+        # Remove index from master port name if there are no more clones
         if not self._clones:
             self._name = self._n['name']
-            if not self._key.isdigit():  # also update key for none stream ports
+            # Also update key for none stream ports
+            if not self._key.isdigit():
                 self._key = self._name
 
     def get_name(self):
@@ -305,13 +341,26 @@ class Port(Element):
             number = str(busses.index(self)) + '#' + str(len(self.get_associated_ports()))
         return self._name + number
 
-    def get_key(self): return self._key
-    def is_sink(self): return self._dir == 'sink'
-    def is_source(self): return self._dir == 'source'
-    def is_port(self): return True
-    def get_type(self): return self.get_parent().resolve_dependencies(self._type)
-    def get_domain(self): return self._domain
-    def get_hide(self): return self._hide_evaluated
+    def get_key(self):
+        return self._key
+
+    def is_sink(self):
+        return self._dir == 'sink'
+
+    def is_source(self):
+        return self._dir == 'source'
+
+    def is_port(self):
+        return True
+
+    def get_type(self):
+        return self.get_parent().resolve_dependencies(self._type)
+
+    def get_domain(self):
+        return self._domain
+
+    def get_hide(self):
+        return self._hide_evaluated
 
     def get_connections(self):
         """