Returns all symbols in the library

        Parameters
        ----------
        partial: None or str
            if not none, use this string to do a partial match on symbol names

        Returns
        -------
        list of str
979410
def list_symbols(self, partial_match=None):
        
        symbols = self._symbols.distinct(SYMBOL)
        if partial_match is None:
            return symbols
        return [x for x in symbols if partial_match in x]
1224059
def Partial(func, **kwargs):
    
    if isinstance(func, str):
        func = resolve_dotted_name(func)
    partial_func = partial(func, **kwargs)
    update_wrapper(partial_func, func)
    return partial_func
385423
def get_core_source_partial():
    
    global _core_source_partial

    if _core_source_partial is None:
        _core_source_lock.acquire()
        try:
            if _core_source_partial is None:
                _core_source_partial = PartialZlib(
                    _get_core_source().encode('utf-8')
                )
        finally:
            _core_source_lock.release()

    return _core_source_partial
560224
def _search_for_import_symbols(self, matches):
        '''  '''

        # Sanity check
        if not hasattr(self.pefile_handle, 'DIRECTORY_ENTRY_IMPORT'):
            return []

        # Find symbols that match
        pattern = '|'.join(re.escape(match) for match in matches)
        exp = re.compile(pattern)
        symbol_list = []
        for module in self.pefile_handle.DIRECTORY_ENTRY_IMPORT:
            for symbol in module.imports:
                if (symbol.name):
                    symbol_list.append(symbol.name.lower())
        symbol_matches = []
        for symbol in symbol_list:
            if exp.search(symbol):
                symbol_matches.append(symbol)
        return symbol_matches
277354
def types(self):
        
        return [x for x in self[self.current_scope].values() if isinstance(x, symbols.TYPE)]
330329
def get_symbols_list(self):
        ''''''
        slist = []
        rc, nSymb, nElem = gdxcc.gdxSystemInfo(self.gdx_handle)
        assert rc, 'Unable to retrieve "%s" info' % self.filename
        self.number_symbols = nSymb
        self.number_elements = nElem
        slist = [None]*(nSymb+1)
        for j in range(0,nSymb+1):
            sinfo = self.get_sid_info(j)
            if j==0:
                sinfo['name'] = 'universal_set'
            slist[j] = GdxSymb(self,sinfo)
        return slist
551270
def indices_from_symbol(self, symbol: str) -> tuple:
        
        return tuple((i for i, specie in enumerate(self.species)
                      if specie.symbol == symbol))
235228
def _get_regular_expression_of_symbols(self):
        

        regular_expression = None
        for symbol in self.symbols:
            formated_symbol = self._get_formated_symbol(symbol['symbol'])
            if regular_expression is None:
                regular_expression = '(' + formated_symbol + ')'
            else:
                regular_expression = (
                    regular_expression +
                    '|(' +
                    formated_symbol +
                    ')'
                )
        return regular_expression
1310116
def get_symbols(self):
        
        return [s if isinstance(s, Symbol) else s.args[0] for s in self.get_literals()]
1366754
def site_symbols(self):
        
        syms = [site.specie.symbol for site in self.structures[0]]
        return [a[0] for a in itertools.groupby(syms)]
1114130
def partial(filename)
      filename = partial_path(filename)
      raise "unable to find partial file: #{filename}" unless File.exists?(filename)
      contents = File.open(filename, "rb") {|f| f.read}
      # TODO: detect template EOL and match it to the partial's EOL
      # force unix eol
      contents.gsub!(/\r\n/, "\n") if contents.match("\r\n")
      contents
    end
271652
def nn_symbols():
    ""
    value = ctypes.c_int()
    name_value_pairs = []
    i = 0
    while True:
        name = _nn_symbol(i, ctypes.byref(value))
        if name is None:
            break
        i += 1
        name_value_pairs.append((name.decode('ascii'), value.value))
    return name_value_pairs
949434
def iterate_symbols():
    
    for prefix in search_prefixes():
        package = importlib.import_module(prefix)
        for importer, modname, ispkg in pkgutil.walk_packages(path=package.__path__, onerror=lambda x: None):
            network = network_for_netcode(modname)
            if network:
                yield network.symbol.upper()
1351872
def do_symbols_matching(self):
        
        self._clear_decorations()
        current_block = self.editor.textCursor().block()
        data = get_block_symbol_data(self.editor, current_block)
        pos = self.editor.textCursor().block().position()
        for symbol in [PAREN, SQUARE, BRACE]:
            self._match(symbol, data, pos)
988298
def list(self, parts: Any) -> str:
        
        _ = self.translate
        if len(parts) == 0:
            return ""
        if len(parts) == 1:
            return parts[0]
        comma = u" \u0648 " if self.code.startswith("fa") else u", "
        return _("%(commas)s and %(last)s") % {
            "commas": comma.join(parts[:-1]),
            "last": parts[len(parts) - 1],
        }
835536
def alignment_to_partials(alignment, missing_data=None):
    
    partials_dict = {}
    for (name, sequence) in alignment.get_sequences():
        datatype = 'dna' if alignment.is_dna() else 'protein'
        partials_dict[name] = seq_to_partials(sequence, datatype)

    if missing_data is not None:
        l = len(alignment)
        for name in missing_data:
            if name not in partials_dict:
                partials_dict[name] = seq_to_partials('-'*l, datatype)
    return partials_dict
128075
def getAvailableGlyphnames(self):
        
        glyphNames = {}
        for locationName, (source, loc) in self.sources.items():
            for glyph in source:
                glyphNames[glyph.name] = 1
        names = sorted(glyphNames.keys())
        return names