Print out some properties of the network defined by the |Node| and
        |Element| objects currently handled by the |HydPy| object.
511266
def networkproperties(self):
        """"""
        print('Number of nodes: %d' % len(self.nodes))
        print('Number of elements: %d' % len(self.elements))
        print('Number of end nodes: %d' % len(self.endnodes))
        print('Number of distinct networks: %d' % len(self.numberofnetworks))
        print('Applied node variables: %s' % ', '.join(self.variables))
833849
def dump(cursor):
    

    def node_children(node):
        return list(node.get_children())

    def print_node(node):
        text = node.spelling or node.displayname
        kind = str(node.kind).split('.')[1]
        return '{} {}'.format(kind, text)

    return draw_tree(cursor, node_children, print_node)
250895
def print_node(node, detailed=False):
    """"""
    nodename = node['name']
    print(colors.yellow("\n" + nodename))
    # Roles
    if detailed:
        for role in get_roles_in_node(node):
            print_role(_get_role(role), detailed=False)
    else:
        print('  Roles: {0}'.format(", ".join(get_roles_in_node(node))))
    # Recipes
    if detailed:
        for recipe in get_recipes_in_node(node):
            print "  Recipe:", recipe
            print "    attributes: {0}".format(node.get(recipe, ""))
    else:
        print('  Recipes: {0}'.format(", ".join(get_recipes_in_node(node))))
    # Node attributes
    print "  Node attributes:"
    for attribute in node.keys():
        if attribute == "run_list" or attribute == "name":
            continue
        print "    {0}: {1}".format(attribute, node[attribute])
1333112
def info(docgraph):
    """"""
    print networkx.info(docgraph), '\n'
    node_statistics(docgraph)
    print
    edge_statistics(docgraph)
100750
def print(self):
        
        print("TOTALS -------------------------------------------")
        print(json.dumps(self.counts, indent=4, sort_keys=True))
        if self.sub_total:
            print("\nSUB TOTALS --- based on '%s' ---------" % self.sub_total)
            print(json.dumps(self.sub_counts, indent=4, sort_keys=True))
        if self.list_blank:
            print("\nMISSING nodes for '%s':" % self.list_blank,
                  len(self.blank))
1314260
def print_continuum(self):
        
        numpoints = len(self.runtime._keys)
        if numpoints:
            print('Numpoints in continuum: {}'.format(numpoints))
        else:
            print('Continuum empty')
        for p in self.get_points():
            point, node = p
            print('{} ({})'.format(node, point))
358603
def print_object_attributes( thing, heading=None, file=None ):
    '''
    
    '''
    if heading : print( '==', heading, '==', file=file )
    print( '\n'.join( object_attributes( thing ) ), file=file )
143596
function ObjectTypeIndexer(node, print) {
  if (node["static"]) this.push("static ");
  this.push("[");
  print.plain(node.id);
  this.push(":");
  this.space();
  print.plain(node.key);
  this.push("]");
  this.push(":");
  this.space();
  print.plain(node.value);
}
173005
def set_node_attributes(self):
        

        species = {}
        coords = {}
        properties = {}
        for node in self.graph.nodes():
            species[node] = self.molecule[node].specie.symbol
            coords[node] = self.molecule[node].coords
            properties[node] = self.molecule[node].properties

        nx.set_node_attributes(self.graph, species, "specie")
        nx.set_node_attributes(self.graph, coords, "coords")
        nx.set_node_attributes(self.graph, properties, "properties")
52378
def print_menuconfig_nodes(node, indent):
    
    while node:
        string = node_str(node)
        if string:
            indent_print(string, indent)

        if node.list:
            print_menuconfig_nodes(node.list, indent + 8)

        node = node.next
762209
def _node_info(conn):
    '''
    
    '''
    raw = conn.getInfo()
    info = {'cpucores': raw[6],
            'cpumhz': raw[3],
            'cpumodel': six.text_type(raw[0]),
            'cpus': raw[2],
            'cputhreads': raw[7],
            'numanodes': raw[4],
            'phymemory': raw[1],
            'sockets': raw[5]}
    return info
1274743
def process(self, object, h, n=0, nl=False):
        
        if object is None:
            return 'None'
        if isinstance(object, Object):
            if len(object) == 0:
                return '<empty>'
            else:
                return self.print_object(object, h, n+2, nl)
        if isinstance(object, dict):
            if len(object) == 0:
                return '<empty>'
            else:
                return self.print_dictionary(object, h, n+2, nl)
        if isinstance(object, (list, tuple)):
            if len(object) == 0:
                return '<empty>'
            else:
                return self.print_collection(object, h, n+2)
        if isinstance(object, basestring):
            return '"%s"' % tostr(object)
        return '%s' % tostr(object)
1358766
def properties_list(self, io_handler):
        
        # Get the framework
        framework = self._context.get_framework()

        # Head of the table
        headers = ("Property Name", "Value")

        # Lines
        lines = [item for item in framework.get_properties().items()]

        # Sort lines
        lines.sort()

        # Print the table
        io_handler.write(self._utils.make_table(headers, lines))
1316198
private void printNamespaces(NodeTypeData nodeTypeData, OutputStreamWriter out) throws RepositoryException,
      IOException
   {

      /**
       * Using set to store all prefixes found in node types to avoid
       * duplication
       */
      Set<String> namespaces = new HashSet<String>();
      /** Scanning nodeType definition for used namespaces */
      printNameNamespace(nodeTypeData.getName(), namespaces);
      printNameNamespace(nodeTypeData.getPrimaryItemName(), namespaces);
      if (nodeTypeData.getDeclaredSupertypeNames() != null)
      {
         for (InternalQName reqType : nodeTypeData.getDeclaredSupertypeNames())
         {
            printNameNamespace(reqType, namespaces);
         }
      }
      /** Scanning property definitions for used namespaces */
      if (nodeTypeData.getDeclaredPropertyDefinitions() != null)
      {
         for (PropertyDefinitionData property : nodeTypeData.getDeclaredPropertyDefinitions())
         {
            printNameNamespace(property.getName(), namespaces);
         }
      }
      /** Scanning child definitions for used namespaces */
      if (nodeTypeData.getDeclaredChildNodeDefinitions() != null)
      {
         for (NodeDefinitionData child : nodeTypeData.getDeclaredChildNodeDefinitions())
         {
            printNameNamespace(child.getName(), namespaces);
            printNameNamespace(child.getDefaultPrimaryType(), namespaces);
            if (child.getRequiredPrimaryTypes() != null)
            {
               for (InternalQName reqType : child.getRequiredPrimaryTypes())
               {
                  printNameNamespace(reqType, namespaces);
               }
            }
         }
      }
      for (String prefix : namespaces)
      {
         String uri = namespaceRegistry.getURI(prefix);
         out.write("<" + prefix + "='" + uri + "'>\r\n");
      }
   }
1242570
def get_nodes_positions(self):
        
        nodes = self.get_nodes()
        output = {}
        for node in nodes:
            output[node[0]] = (float(node[1][consts.Consts.x]), float(node[1][consts.Consts.y]))
        return output
1095934
def printNetwork(network):
  
  print "The network has",len(network.regions.values()),"regions"
  for p in range(network.getMaxPhase()):
    print "=== Phase",p
    for region in network.regions.values():
      if network.getPhases(region.name)[0] == p:
        print "   ",region.name
667305
def printAllElements(self):
        
        cnt = 1
        print("{id:<3s}: {name:<12s} {type:<10s} {classname:<10s}"
              .format(id='ID', name='Name', type='Type', classname='Class Name'))
        for e in self._lattice_eleobjlist:
            print("{cnt:>03d}: {name:<12s} {type:<10s} {classname:<10s}"
                  .format(cnt=cnt, name=e.name, type=e.typename, classname=e.__class__.__name__))
            cnt += 1