Return list with schemata in cache.

        :return: list of schemata
174236
def schemata(self) -> list:
        

        LOGGER.debug('SchemaCache.schemata >>>')

        LOGGER.debug('SchemaCache.schemata <<<')
        return [self._schema_key2schema[seq_no] for seq_no in self._schema_key2schema]
1208914
def items(self):
        
        return [
            (c.name, getattr(self, c.name, None))
            for c in self.__table__._columns
        ]
154979
def get_schema_specs_of_type(self, *schema_types: Type) -> Dict[str, Dict[str, Any]]:
        

        return {
            fq_name: schema
            for fq_name, schema in self._spec_cache.items()
            if Type.is_type_in(schema.get(ATTRIBUTE_TYPE, ''), list(schema_types))
        }
625766
def schemas(self):
        
        sql = """SELECT schema_name FROM information_schema.schemata
                 ORDER BY schema_name"""
        schemas = self.query(sql).fetchall()
        return [s[0] for s in schemas if s[0][:3] != "pg_"]
272902
def dump(schema):
    
    result = {}

    for name, _ in iteritems(schema.getschemas()):

        if hasattr(schema, name):
            val = getattr(schema, name)

            if isinstance(val, DynamicValue):
                val = val()

            if isinstance(val, Schema):
                val = dump(val)

            result[name] = val

    return result
928061
def get_assets(self):
        
        if self.retrieved:
            raise errors.IllegalState('List has already been retrieved.')
        self.retrieved = True
        return objects.AssetList(self._results, runtime=self._runtime)
1120553
def get_fields(self):
        
        if self.__cache_all_fields is None:
            self.__cache_all_fields = []
            for i in self.get_classes():
                for j in i.get_fields():
                    self.__cache_all_fields.append(j)
        return self.__cache_all_fields
182257
def items(self):
        
        temp = self.clone()
        return [(f, getattr(temp, f)) for f in iter(self)]
354360
def getschemas(cls):
        
        members = getmembers(cls, lambda member: isinstance(member, Schema))

        result = OrderedDict()

        for name, member in members:
            result[name] = member

        return result
1145029
def _elements(self):
        
        if not self.evaluated:
            setattr(self, '_elements_cached', list(self._select()))
        return self._elements_cached
1056372
def get_templates(self):
        
        use = getattr(self, 'use', '')
        if isinstance(use, list):
            return [n.strip() for n in use if n.strip()]

        return [n.strip() for n in use.split(',') if n.strip()]
760054
def list(node = "")
      cache "list_#{node.empty? ? 'default' : node}" do
        connection.send_data("list #{node}")
        if ( line = connection.read_line ) != "."
          line.split
        else
          connection.read_line.split
        end
      end
    end
532607
def get_all(self):
        
        self._lock.acquire()
        try:
            return list(self._cache.values())
        finally:
            self._lock.release()
586434
def _list(self):
        
        all = self.driver.instance.metadata.get(search=self.namespace)
        list = []
        for id in all:
            try:
                if not self._get(id['id']) in list:
                    list.append(self._get(id['id']))
            except Exception:
                pass

        return list
537333
def getOrder(self, schematas):
        
        schemata = self.context.schema['description'].schemata
        fields = schematas[schemata]
        fields.insert(fields.index('description') + 1,
                      'Identifiers')
        return schematas
263315
def getExperimentList():
  
  contents = sio.loadmat("./data/DataFolderList.mat",
                         variable_names=['DataFolderList'],
                         struct_as_record=False,
                         squeeze_me=True)

  return contents['DataFolderList']
602771
def list(self):
        
        data_list = self.db.get_data(self.list_path)
        data_list = data_list.get('Data') or {}
        platforms = (data_list.get('Platforms') or {}).get('Platform') or []
        return [self._build_item(**i) for i in platforms]