Returns an object that lazily looks up tables and groups.
438705
def load_module(self, fullname):
        
        mod = sys.modules.get(fullname)
        if mod is not None:
            return mod

        # We're creating an object rather than a module. It's a hack, but it's approved by Guido:
        # https://mail.python.org/pipermail/python-ideas/2012-May/014969.html

        mod = _from_core_node(self._store, self._root)
        sys.modules[fullname] = mod
        return mod
657593
def rowget(self,tables_dict,row_list,index):
    ""
    tmp=row_list
    for i in self.index_tuple(tables_dict,index,False): tmp=tmp[i]
    return tmp
569785
def find_tabs(self, custom_table_classes=None):
        """"""
        for module_name in get_all_modules(self.package_path):
            for name, _type in get_all_classes(module_name):
                # pylint: disable=W0640
                subclasses = [Table] + (custom_table_classes or list())
                iss_subclass = map(lambda c: issubclass(_type, c), subclasses)
                if isclass(_type) and any(iss_subclass):
                    self.tabs.update([[name, _type]])
119387
def selected_objects(self):
        """"""

        return [
            obj
            for obj in self.text_objects
            if contains_or_overlap(self.table_bbox, obj.bbox)
        ]
610880
private List<Row> getTable(String name)
   {
      List<Row> result = m_tables.get(name);
      if (result == null)
      {
         result = Collections.emptyList();
      }
      return result;
   }
445167
def getobject(bunchdt, key, name):
    """"""
    # TODO : throw exception if more than one object, or return more objects
    idfobjects = bunchdt[key]
    if idfobjects:
        # second item in list is a unique ID
        unique_id = idfobjects[0].objls[1]
    theobjs = [idfobj for idfobj in idfobjects if
               idfobj[unique_id].upper() == name.upper()]
    try:
        return theobjs[0]
    except IndexError:
        return None
34279
def get_tables_for_bind(self, bind=None):
        """"""
        result = []
        tables = Model.metadata.tables
        for key in tables:
            if tables[key].info.get("bind_key") == bind:
                result.append(tables[key])
        return result
685706
def _GetTable(self):
    
    result = []
    # Avoid the global lookup cost on each iteration.
    lstr = str
    for row in self._table:
      result.append(
          '%s\n' %
          self.separator.join(lstr(v) for v in row))

    return ''.join(result)
95199
public static List<String> getTables(DataSource ds, TableType... types) {
		return getTables(ds, null, null, types);
	}
1362155
def get_table(self, tablename):
        
        table, (_row, _col) = self.__tables[tablename]
        return table
303632
def db_group(self):
        '''
        '''
        if self._db_group is None:
            self._db_group = self.db_user
        return self._db_group
1181512
def read_properties(group):
    """"""
    if 'properties' not in group:
        raise IOError('no properties in group')

    data = group['properties'][...][0].replace(b'__NULL__', b'\x00')
    return pickle.loads(data)
354360
def getschemas(cls):
        
        members = getmembers(cls, lambda member: isinstance(member, Schema))

        result = OrderedDict()

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

        return result
1210391
def table(self):
        """"""
        if hasattr(self.data, 'table_on') and self.data.table_on:
            assert_index_sane(self.data.table, len(self.song.tables))
            return self.song.tables[self.data.table]
621744
def get_collections(self, pattern="*", libtype="*"):
        """"""

        sql = """SELECT collection.collection_id, collection.name, collection.doc,
                        collection.type, collection.path
                 FROM collection_table as collection
                 WHERE name like ?
                 AND type like ?
                 ORDER BY collection.name
              """

        cursor = self._execute(sql, (self._glob_to_sql(pattern),
                                     self._glob_to_sql(libtype)))
        sql_result = cursor.fetchall()

        return [{"collection_id": result[0],
                 "name": result[1],
                 "synopsis": result[2].split("\n")[0],
                 "type": result[3],
                 "path": result[4]
             } for result in sql_result]
1296894
def find_model_by_table_name(name):
    """"""

    for model in ModelBase._decl_class_registry.values():
        if hasattr(model, '__table__') and model.__table__.fullname == name:
            return model
    return None
735237
def filter(self, table, group_types, filter_string):
        """"""
        query = filter_string.lower()
        return [group_type for group_type in group_types
                if query in group_type.name.lower()]