This function returns the path (in terms of phrase types) from one term the root
        @type termid: string
        @param termid: one term id
        @rtype: list
        @return: the path, list of phrase types
428314
def get_path_for_termid(self,termid):
        
        terminal_id = self.terminal_for_term.get(termid)
        paths = self.paths_for_terminal[terminal_id]
        labels = [self.label_for_nonter[nonter] for nonter in paths[0]]
        return labels
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
756422
def path(self, *paths, **kwargs):
        
        return self.__class__(self.__root__, *paths, **kwargs)
460719
def uri(self):
        """"""
        uristring = self.path
        if self.query:
            uristring += "?{}".format(self.query)
        if self.fragment:
            uristring += "#{}".format(self.fragment)

        return uristring
1359703
def path(self, which=None):
        
        if which:
            return '{0}/{1}'.format(
                super(Template, self).path(which='base'), which)
        return super(Template, self).path(which)
407497
public void rmLittleSinglePath() {
		int maxTo = -1;
		Term temp = null;
		for (int i = 0; i < terms.length; i++) {
			if (terms[i] == null) {
				continue;
			}
			maxTo = terms[i].toValue();
			if (maxTo - i == 1 || i + 1 == terms.length) {
				continue;
			}
			for (int j = i; j < maxTo; j++) {
				temp = terms[j];
				if (temp != null && temp.toValue() <= maxTo && temp.getName().length() == 1) {
					terms[j] = null;
				}
			}
		}
	}
853730
public static Phrase from(View v, @StringRes int patternResourceId) {
    return from(v.getResources(), patternResourceId);
  }
935305
def match(self, passageId):
        
        if not isinstance(passageId, CtsReference):
            passageId = CtsReference(passageId)

        if self.is_root():
            return self[passageId.depth-1]
        return self.root.match(passageId)
384558
protected String getRelativePath(String dataId)
   {
      StringBuilder buffer = new StringBuilder(256);
      List<String> ancestors = getAncestors(dataId);
      for (int i = 0, length = ancestors.size(); i < length; i++)
      {
         buffer.append(ancestors.get(i));
         if (i != length - 1)
         {
            buffer.append('/');
         }
      }
      return buffer.toString();
   }
714534
public static String getFilePath(int docId, String extention) {
        int[] split = getSplit(docId);
        return split[0] + "/" + split[1] + "/" + split[2] + "." + extention;
    }
407486
def path(self) -> str:
        
        path: str = ELIBConfig.config_sep_str.join(self._raw_path)
        if ELIBConfig.root_path:
            prefix = ELIBConfig.config_sep_str.join(ELIBConfig.root_path)
            path = ELIBConfig.config_sep_str.join((prefix, path))
        return path
87657
public String getNameForID(String id) {
        if (!terms.containsKey(id))
            return null;
        return terms.get(id).getName();
    }
1250582
def path(self):
        ""
        prefix = ()
        if self.parent:
            prefix = self.parent.path

        if self.id_or_name:
            return prefix + (self.kind, self.id_or_name)

        return prefix + (self.kind,)
205585
public List<Concept> getPathFromRoot() {
        LinkedList<Concept> path = new LinkedList<>();

        Concept node = this;
        while (node != null) {
            path.addFirst(node);
            node = node.parent;
        }

        return path;
    }
512544
public static String parentRelativePathFromResourceId(String id) {
        if (id == null) {
            return null;
        }

        ResourceId parent = ResourceId.fromString(id).parent();
        if (parent != null) {
            return parent.resourceType() + "/" + parent.name();
        }

        return "";
    }
1156816
function getRoot(term, opts) {
  var parts = term.split(path.sep);
  var root = parts.shift() || path.sep; // Windows support, I hope?

  // Last section treated as term if not suffixed by path separator.
  for(var i = 0; i < parts.length - 1; i++) {
    var tryPath = path.join(root, parts[i]);
    try {
      var stat = fs.statSync(tryPath);
      if(!stat.isDirectory()) {
        break;
      }
    } catch (e) {
      if(e.code === 'ENOENT') {
        break;
      }
      throw e;
    }
    root = tryPath;
  }
  root = util.normalizePath(root);
  return root;
}
100402
def get_dict_tokens_for_termid(self, term_id):
        
        if self.dict_tokens_for_tid is None:
            self.dict_tokens_for_tid = {}
            for term in self.get_terms():
                self.dict_tokens_for_tid[term.get_id()] = term.get_span().get_span_ids()

        return self.dict_tokens_for_tid.get(term_id,[])