Returns a node for a path.

        :param path: Tuple of :term:`hashable` s.
        :rtype: :class:`~cerberus.errors.ErrorTreeNode` or :obj:`None`
422101
def fetch_node_from(self, path):
        
        context = self
        for key in path:
            context = context[key]
            if context is None:
                break
        return context
798133
public static String getNodeFromPath(String path)
    {
        PathUtils.validatePath(path);
        int i = path.lastIndexOf(PATH_SEPARATOR);
        if ( i < 0 )
        {
            return path;
        }
        if ( (i + 1) >= path.length() )
        {
            return "";
        }
        return path.substring(i + 1);
    }
391215
def list(self, path):
        
        try:
            payload = {
                'list': True
            }
            return self._adapter.get('/v1/{0}'.format(path), params=payload).json()
        except exceptions.InvalidPath:
            return None
1306162
def path(self, path: str):
        

        path = path if path else ''
        self.pathName = os.path.join(path, self.name)
1059057
def tree(self, path):
        '''
        
        '''
        ret = {}
        try:
            items = self.read(path)
        except (etcd.EtcdKeyNotFound, ValueError):
            return None
        except etcd.EtcdConnectionFailed:
            log.error("etcd: failed to perform 'tree' operation on path %s due to connection error", path)
            return None

        for item in items.children:
            comps = six.text_type(item.key).split('/')
            if item.dir is True:
                if item.key == path:
                    continue
                ret[comps[-1]] = self.tree(item.key)
            else:
                ret[comps[-1]] = item.value
        return ret
891274
def _get_child_from_path(self, path):
        

        keys = path.split(".")

        this_child = self

        for key in keys:

            try:

                this_child = this_child._get_child(key)

            except KeyError:

                raise KeyError("Child %s not found" % path)

        return this_child
978429
def address_from_path(self, path=None):
        
        path = path if path else self._unique_hierarchical_string()
        return path, self.wallet.subkey_for_path(path).address()
1170371
def from_path(path):
  
  for item in ref:
    build = ref[item]
    valid_ = build['is_valid']
    if valid_(path) is True:
      return build['builder'](path)
  raise errors.InvalidProjectStructure()
1241991
def register_node_path(self, node):
        

        path = node.file if hasattr(node, "file") else node.path
        path = foundations.strings.to_string(path)
        if not foundations.common.path_exists(path):
            return False

        return self.register_file(path)
715425
def _read_tree(self, path):
    

    path = self._fixup_dot_relative(path)

    tree = self._trees.get(path)
    if tree:
      return tree
    tree = {}
    object_type, tree_data = self._read_object_from_repo(rev=self.rev, relpath=path)
    assert object_type == b'tree'
    # The tree data here is (mode ' ' filename \0 20-byte-sha)*
    # It's transformed to a list of byte chars to allow iteration.
    # See http://python-future.org/compatible_idioms.html#byte-string-literals.
    tree_data = [bytes([b]) for b in tree_data]
    i = 0
    while i < len(tree_data):
      start = i
      while tree_data[i] != b' ':
        i += 1
      mode = b''.join(tree_data[start:i])
      i += 1  # skip space
      start = i
      while tree_data[i] != NUL:
        i += 1
      name = b''.join(tree_data[start:i])
      sha = b''.join(tree_data[i + 1:i + 1 + GIT_HASH_LENGTH])
      sha_hex = binascii.hexlify(sha)
      i += 1 + GIT_HASH_LENGTH
      if mode == b'120000':
        tree[name] = self.Symlink(name, sha_hex)
      elif mode == b'40000':
        tree[name] = self.Dir(name, sha_hex)
      else:
        tree[name] = self.File(name, sha_hex)
    self._trees[path] = tree
    return tree
686655
def get_project_nodes(self, path):
        

        return [project_node for project_node in self.list_project_nodes() if project_node.path == path]
844248
@Override
    public Node get(ArchivePath path) {
        Validate.notNull(path, "No path was specified");
        Node node = content.get(path);
        if (node == null && contains(path)) {
            node = getNestedNode(path);
        }
        return node;
    }
805279
def _get_path(path):
    

    if isinstance(path, (six.string_types, bytes)):
        return path
    path_type = type(path)
    try:
        path_repr = path_type.__fspath__(path)
    except AttributeError:
        return
    if isinstance(path_repr, (six.string_types, bytes)):
        return path_repr
    return
580469
def chkpath(path):
    
    if os.path.exists(path):
        return path
    else:
        msg = "{0} does not exist.".format(path)
        raise argparse.ArgumentTypeError(msg)
432353
def get_node_for_path(user_path)
      case user_path
      when String
        user_path = user_path.split "/"
      when Array
      else
        raise ArgumentError, "Should be Array or String delimited with /"
      end
      $log.debug "TREE #{user_path} " if $log.debug? 
      root = @treemodel.root
      found = nil
      user_path.each { |e| 
        success = false
        root.children.each { |c| 
          if c.user_object == e
            found = c
            success = true
            root = c
            break
          end
        }
        return false unless success

      }
      return found
    end
199039
protected Node getContentNode(Session session, String path)
            throws RepositoryException {
        Node node = null;
        try {
            Item item = session.getItem(path);
            if (item.isNode()) {
                node = (Node) item;
            } else {
                node = item.getParent();
            }
            while (node != null
                    && !isTargetNode(node)
                    && (path = getTargetPath(node)) != null) {
                node = node.getParent();
            }
        } catch (PathNotFoundException ignore) {
            // probably removed... ignore
        }
        return path != null ? node : null;
    }
339798
def get(self, path):
        
        mountpoint, chunks = self.get_mountpoint(path)

        if mountpoint is None:
            return self._files.get(self._join_chunks(chunks))
        else:
            return mountpoint.get(chunks)