Gets the path to the focused statistics. Each step is a hash of
        statistics object.
964980
def get_path(self):
        
        path = deque()
        __, node = self.get_focus()
        while not node.is_root():
            stats = node.get_value()
            path.appendleft(hash(stats))
            node = node.get_parent()
        return path
602118
function getStep(step) {
        var template = grunt.file.read(templates.stepTemplate),
            stepTemplate;

        stepTemplate = grunt.template.process(template, {
            data: {
                status: step.result ? step.result.status : '',
                errorDetails: step.result ? toHtmlEntities(step.result.error_message) : '',
                duration: step.result.duration ? calculateDuration(step.result.duration) : 'no data',
                tableOutline: (step.arguments && step.arguments.length > 0) ? step.arguments[0].rows : step.rows,
                name: step.keyword + (step.name ? step.name : '')
            }
        });
        return stepTemplate;
    }
922052
def get_paths(self, key):
        ""
        result_list = []
        if key in self.keys():
            result_list.append(((key,), self[key]))
        for sub_key, v in self.items():
            if isinstance(v, self.__class__):
                sub_res_list = v.get_paths(key)
                for key_path, res in sub_res_list:
                    result_list.append(((sub_key,) + key_path, res))
            elif isinstance(v, dict):
                if key in v.keys():
                    result_list.append(((sub_key, key), v[key]))
        return result_list
1277772
def GetPathInfo(self, timestamp=None):
    
    path_info_timestamp = self._LastEntryTimestamp(self._path_infos, timestamp)
    try:
      result = self._path_infos[path_info_timestamp].Copy()
    except KeyError:
      result = rdf_objects.PathInfo(
          path_type=self._path_type, components=self._components)

    stat_entry_timestamp = self._LastEntryTimestamp(self._stat_entries,
                                                    timestamp)
    result.last_stat_entry_timestamp = stat_entry_timestamp
    result.stat_entry = self._stat_entries.get(stat_entry_timestamp)

    hash_entry_timestamp = self._LastEntryTimestamp(self._hash_entries,
                                                    timestamp)
    result.last_hash_entry_timestamp = hash_entry_timestamp
    result.hash_entry = self._hash_entries.get(hash_entry_timestamp)

    return result
194410
def get_top_paths(self):
        
        headers, data = self._requester.requestJsonAndCheck(
            "GET",
            self.url + "/traffic/popular/paths"
        )
        if isinstance(data, list):
            return [
                github.Path.Path(self._requester, headers, item, completed=True)
                for item in data
            ]
301326
def transition_stats
      if done?
        @transition_stats ||= (
          stats = {}
          hierarchy = @processor.children.dup
          i = 0
          while i < hierarchy.size
            child = hierarchy[i]
            if child.model.coupled?
              hierarchy.concat(child.children)
            else
              stats[child.model.name] = child.transition_stats
            end
            i+=1
          end
          total = Hash.new(0)
          stats.values.each { |h| h.each { |k, v| total[k] += v }}
          stats[:TOTAL] = total
          stats
        )
      end
    end
1239265
def path(self):
        
        raw_path = wsgi_decoding_dance(
            self.environ.get("PATH_INFO") or "", self.charset, self.encoding_errors
        )
        return "/" + raw_path.lstrip("/")
231888
def paths(self):
        '''
        
        '''
        paths = self._cfg.get('paths')
        if not paths:
            raise ValueError('Paths Object has no values, You need to define them in your swagger file')
        for path in paths:
            if not path.startswith('/'):
                raise ValueError('Path object {0} should start with /. Please fix it'.format(path))
        return six.iteritems(paths)
553768
def path(self):
        
        if not self.id:
            raise ValueError('Cannot determine path without a task id.')

        return self.path_helper(self.taskqueue.path, self.id)
997845
def path(self) -> Tuple[InstanceKey]:
        """"""
        res = []
        inst: InstanceNode = self
        while inst.parinst:
            res.insert(0, inst._key)
            inst = inst.parinst
        return tuple(res)
758228
def get_processed_path(self):
        
        location = self.get_storage().location
        return self.get_processed_key_name()[len(location):]
232323
def path(self):
        """"""
        # If root, return '/'
        if self.dataset is self:
            return ''
        else:  # Otherwise recurse
            return self.dataset.path + '/' + self.name
22572
def finding_path(cls, organization, source, finding):
        """"""
        return google.api_core.path_template.expand(
            "organizations/{organization}/sources/{source}/findings/{finding}",
            organization=organization,
            source=source,
            finding=finding,
        )
1011109
def get_path(self):
        
        if self.path == None:
            from matplotlib import path
            return path.Path(self.points[:, :2]) # z=0 projection!
        return self.path
383257
def get_summary(name)
      counts = {}
      @cassandra.get_range(:totals, {:start => '', :finish => '', :count => @max_classes}).each do |key_slice|
        # keyslice is a clunky thrift object, map into a ruby hash
        row = key_slice.columns.inject({}){|hsh, c| hsh[c.column.name] = c.column.value; hsh}
        counts[key_slice.key.to_sym] = row[name].to_f
      end
      counts
    end
947271
private List<List<UnitFactor>> getPaths(Unit from, Unit to, Set<Unit> seen) {
    List<List<UnitFactor>> result = new ArrayList<>();

    // See if there is a direct path and return it.
    UnitFactor factor = get(from, to);
    if (factor != null) {
      result.add(list(factor));
      return result;
    }

    // Prune the search space..
    seen.add(from);

    // Scan each base for the 'from' unit, trying to find a complete path
    // to the 'to' unit. Collect all of the paths.
    for (Unit base : getBases(from)) {
      if (seen.contains(base)) {
        continue;
      }

      // Create this link in the chain.
      factor = get(from, base);

      // Scan another level deeper, starting from 'base' unit.
      for (List<UnitFactor> factors : getPaths(base, to, seen)) {
        // If we found a complete path, add it..
        if (!factors.isEmpty()) {
          // Insert the current factor into the chain and add to the result set.
          factors.add(0, factor);
          result.add(factors);
        }
      }
    }
    return result;
  }
26658
def snapshot_path(cls, project, instance, cluster, snapshot):
        """"""
        return google.api_core.path_template.expand(
            "projects/{project}/instances/{instance}/clusters/{cluster}/snapshots/{snapshot}",
            project=project,
            instance=instance,
            cluster=cluster,
            snapshot=snapshot,
        )