Return instance inspect information, used by Node#inspect.
768346
def sub_inspect
      s = ""
      if !@object.nil?
        s += format("%x ", @object.object_id)
      end
      s + "{" + keys.collect { |k| "#{k} => #{self[k].sub_inspect}" }.join(",") + "}"
    end
1118645
def peek(self):
        """"""
        info = self._registry.get(self)
        obj = info and info.weakref()
        if obj is not None:
            return (obj, info.func, info.args, info.kwargs or {})
1047309
def GetInstanceInfo(r, instance, static=None):
    

    if static is None:
        return r.request("get", "/2/instances/%s/info" % instance)
    else:
        return r.request("get", "/2/instances/%s/info" % instance,
                         query={"static": static})
892982
def inspect
      c = []
      children.each do |w|
        c << w.inspect
      end
      s = super + " #{self.class}=<window_class:#{window_class} pid:#{pid} thread_id:#{thread_id} title:\"#{title}\" children=<" + c.join("\n") + ">>"
    end
1322454
def inspect
      attribute_descriptions = attributes.sort.map { |key, value| "#{key}: #{value.inspect}" }.join(", ")
      separator = " " unless attribute_descriptions.empty?
      "#<#{self.class.name}#{separator}#{attribute_descriptions}>"
    end
802202
def inspect
      use_dimension
      a = [Utils.num_inspect(@factor), @dim.inspect]
      a << "@name="+@name.inspect if @name
      a << "@expr="+@expr.inspect if @expr
      a << "@offset="+@offset.inspect if @offset
      a << "@dimensionless=true" if @dimensionless
      if @dimension_value && @dimension_value!=1
        a << "@dimension_value="+@dimension_value.inspect
      end
      s = a.join(",")
      "#<#{self.class} #{s}>"
    end
568808
def inspect
      objects = collection
        .map { |id, _| cached(id) || klass.new(klass.schema.primary_key => id) }
        .map { |object| object.to_s }

      "#<#{self.class.name} [#{objects.join(', ')}]>"
    end
1299919
def debug_interactive_inspect_node(self):
        
        if (
            np.sum(
                np.abs(
                    np.asarray(self.msinds.shape) - np.asarray(self.segmentation.shape)
                )
            )
            == 0
        ):
            segmentation = self.segmentation
        else:
            segmentation = self.temp_msgc_resized_segmentation

        logger.info("Click to select one voxel of interest")
        import sed3

        ed = sed3.sed3(self.msinds, contour=segmentation == 0)
        ed.show()
        edseeds = ed.seeds
        node_msindex = get_node_msindex(self.msinds, edseeds)

        node_unariesalt, node_neighboor_edges_and_weights, node_neighboor_seeds = self.debug_inspect_node(
            node_msindex
        )
        import sed3

        ed = sed3.sed3(
            self.msinds, contour=segmentation == 0, seeds=node_neighboor_seeds
        )
        ed.show()

        return (
            node_unariesalt,
            node_neighboor_edges_and_weights,
            node_neighboor_seeds,
            node_msindex,
        )
113486
def inspect
      # NOTES:
      #
      # * Exceptions raised here result in `(Object doesn't support #inspect)`. No other details are available, be careful.
      # * We don't return value from here, we **print** it directly.

      nodes = @instance.nodes.select {|node| node.parent == @parent}

      # Empty group?
      if nodes.empty?
        ::Kernel.puts "No groups/hacks here"
        return nil
      end

      # Not empty group, list contents.

      nodes = nodes.sort_by do |node|
        [
          node.is_a?(Node::Group) ? 0 : 1,    # Groups first.
          node.name.to_s,
        ]
      end

      # Compute name alignment width.
      names = nodes.map {|node| Tools.format_node_name(node)}
      name_align = Tools.compute_name_align(names, @instance.conf.local_name_align)

      nodes.each do |node|
        brief_desc = node.brief_desc || @instance.conf.brief_desc_stub

        fmt = "%-#{name_align}s%s"

        ::Kernel.puts(fmt % [
          Tools.format_node_name(node),
          brief_desc ? " # #{brief_desc}" : "",
        ])
      end # nodes.each

      nil
    end
1359149
def show_instance(name, call=None):
    '''
    
    '''
    node = get_node(name)
    ret = query(command='my/machines/{0}'.format(node['id']),
                location=node['location'], method='GET')

    return ret
909457
def get_instance_variables(node, bound_name_classifier=BOUND_METHOD_ARGUMENT_NAME):
    
    node_attributes = [
        child
        for child in ast.walk(node)
        if isinstance(child, ast.Attribute) and
        get_attribute_name_id(child) == bound_name_classifier
    ]
    node_function_call_names = [
        get_object_name(child)
        for child in ast.walk(node)
        if isinstance(child, ast.Call)
    ]
    node_instance_variables = [
        attribute
        for attribute in node_attributes
        if get_object_name(attribute) not in node_function_call_names
    ]
    return node_instance_variables
1005477
public function inspect()
    {
        return get_called_class() . Objects::toString(Arrays::filter($this->attributes, Functions::notNull()));
    }
387799
def inspect_modules
      modules = []

      if constant.respond_to?(:ancestors)
        parent = inspect_superclass

        # Take all the modules included *directly* into the constant.
        modules = constant.ancestors.take_while do |ancestor|
          parent && ancestor != parent
        end

        # Get rid of non Module instances and modules that don't have a name.
        modules = modules.select do |mod|
          mod.instance_of?(Module) && mod.name
        end
      end

      return modules
    end
163703
def inspect_functions(self):
        
        if not self._inspect_functions:
            d = {}
            for m in self.inspect_members:
                if issubclass(m, AWSHelperFn):
                    d[m.__name__] = m

            TemplateGenerator._inspect_functions = d

        return self._inspect_functions
228491
async def inspect(self, *, node_id: str) -> Mapping[str, Any]:
        

        response = await self.docker._query_json(
            "nodes/{node_id}".format(node_id=node_id), method="GET"
        )
        return response
1220423
def inspect
      attributes = {
        input: input,
        output: output,
        prefix: prefix,
        active_color: active_color,
        error_color: error_color,
        enabled_color: enabled_color,
        help_color: help_color
      }
      "#<#{self.class}: #{attributes.each { |name, val| "@#{name}=#{val}" }}"
    end
578265
def do_inspect(self, arg):
        
        if arg in self.curframe.f_locals:
            obj = self.curframe.f_locals[arg]
        elif arg in self.curframe.f_globals:
            obj = self.curframe.f_globals[arg]
        else:
            obj = WebPdb.null
        if obj is not WebPdb.null:
            self.console.writeline(
                '{0} = {1}:\n'.format(arg, type(obj))
            )
            for name, value in inspect.getmembers(obj):
                if not (name.startswith('__') and (name.endswith('__'))):
                    self.console.writeline('    {0}: {1}\n'.format(
                        name, self._get_repr(value, pretty=True, indent=8)
                    ))
        else:
            self.console.writeline(
                'NameError: name "{0}" is not defined\n'.format(arg)
            )
        self.console.flush()