A Path for this name object joining field names from `self.get_path_pattern_list` with this object's name
516385
def path(self) -> Path:
        """"""
        args = list(self._iter_translated_field_names(self.get_path_pattern_list()))
        args.append(self.get_name())
        return Path(*args)
281545
def pathify(basenames, examples_dir="examples/"):  # pragma: no cover
    """"""
    example = examples_dir.replace("/", ".")
    return [example + basename for basename in basenames]
807248
def object_path(self, key):
    ''''''
    return os.path.join(self.root_path, self.relative_object_path(key))
1193383
def path_for(self, *args):
        """"""
        if args and args[0].startswith(os.path.sep):
            return os.path.join(*args)
        return os.path.join(self._root_path or os.getcwd(), *args)
1316088
def _get_socket_paths(self):
        
        socket_pattern = os.path.join(self.config['socket_path'],
                                      (self.config['socket_prefix'] +
                                       '*.' + self.config['socket_ext']))
        return glob.glob(socket_pattern)
860495
private ObjectName objectNameFromPath(Stack<String> pPathStack) throws MalformedObjectNameException {
        if (pPathStack.empty()) {
            return null;
        }
        Stack<String> path = (Stack<String>) pPathStack.clone();
        String domain = path.pop();
        if (path.empty()) {
            return new ObjectName(domain + ":*");
        }
        String props = path.pop();
        ObjectName mbean = new ObjectName(domain + ":" + props);
        if (mbean.isPattern()) {
            throw new IllegalArgumentException("Cannot use an MBean pattern as path (given MBean: " + mbean + ")");
        }
        return mbean;
    }
290659
def get_path_fields(cls, base=[]):
    
    pfs = []
    for pf in cls.TutelaryMeta.path_fields:
        if pf == 'pk':
            pfs.append(base + ['pk'])
        else:
            f = cls._meta.get_field(pf)
            if isinstance(f, models.ForeignKey):
                pfs += get_path_fields(f.target_field.model, base=base + [pf])
            else:
                pfs.append(base + [f.name])
    return pfs
7181
def extract_name_from_path(path):
    
    base_path, query_string = path.split('?')
    infos = base_path.strip('/').split('/')[2:]  # Removes api/version.
    if len(infos) > 1:  # This is an object.
        name = '{category} / {name}'.format(
            category=infos[0].title(),
            name=infos[1].replace('-', ' ').title()
        )
    else:  # This is a collection.
        name = '{category}'.format(category=infos[0].title())
    return safe_unicode(name)
1286479
def _getattr_path(obj, path):
    
    if not path:
        return None

    for attr in path.split('.'):
        obj = getattr(obj, attr, None)
    return obj
298795
def path(self):
        ""
        if self.parent:
            return '.'.join([self.parent.path, str(self.identifier)])
        else:
            return self.identifier if self.identifier else self.__class__.__name__
264273
def get_path(name, scheme=_get_default_scheme(), vars=None, expand=True):
    
    return get_paths(scheme, vars, expand)[name]
45817
def get_path(self, reference=None):
        
        return list(reversed([item.get_name()
                              for item in self.get_trace(reference)
                              if item.get_name() is not None]))
147556
def get_model_from_path_string(root_model, path):
    
    for path_section in path.split('__'):
        if path_section:
            try:
                field, model, direct, m2m = _get_field_by_name(root_model, path_section)
            except FieldDoesNotExist:
                return root_model
            if direct:
                if _get_remote_field(field):
                    try:
                        root_model = _get_remote_field(field).parent_model()
                    except AttributeError:
                        root_model = _get_remote_field(field).model
            else:
                if hasattr(field, 'related_model'):
                    root_model = field.related_model
                else:
                    root_model = field.model
    return root_model
237298
def full_path_str(self):
        ''''''
        with self._mutex:
            if self._parent:
                if self._parent._name == '/':
                    return self._parent.full_path_str + self._name
                else:
                    return self._parent.full_path_str + '/' + self._name
            else:
                return self._name
755637
def relation_path_for(from_name, to_name, identifier_type, identifier_key=None):
    
    return "/{}/<{}:{}>/{}".format(
        name_for(from_name),
        identifier_type,
        identifier_key or "{}_id".format(name_for(from_name)),
        name_for(to_name),
    )
376309
function extractNamedFields(fields, input) {
  var output = Object.create(null);
  fields.forEach(function(field) {
    var subObject = input;
    for (var i = 0; i < field.path.length; i += 1) {
      if (subObject == undefined) {
        throw new Error("Unreachable: matched input will always have fields");
      }
      subObject = subObject[field.path[i]];
    }
    switch (field.typeShortcut) {
      // type matcher:
      case 1:
        subObject = global[field.type](subObject);
      break;
      // literal matcher:
      case 3:
        subObject = field.object;
      break;
    }
    output[field.name] = subObject;
  });
  return output;
}
381748
def find(pattern: str, path: str) -> List[str]:
    
    result = []
    for root, dirs, files in os.walk(path):
        for name in files:
            if fnmatch.fnmatch(name, pattern):
                result.append(os.path.join(root, name))
    return result