Return the DynamoDB table

    :type table_name: str
    :param table_name: Name of the DynamoDB table
    :returns: str
352591
def get_table_status(table_name):
    
    try:
        desc = DYNAMODB_CONNECTION.describe_table(table_name)
    except JSONResponseError:
        raise

    return desc[u'Table'][u'TableStatus']
1313730
def table(self, name):
        
        qualified_name = self._qualify(name)
        return self.database.table(qualified_name, self.name)
628529
def _set_table(table_name):
    
    _State.connection()
    _State.reflect_metadata()
    _State.table = sqlalchemy.Table(table_name, _State.metadata,
                                    extend_existing=True)

    if list(_State.table.columns.keys()) == []:
        _State.table_pending = True
    else:
        _State.table_pending = False
72464
def get_table(self, name):
        
        if name is None:
            assert self.active_table, "Can't get table without name unless an active table is set"
            name = self.active_table.name

            if self.active_worksheet:
                table = self.active_worksheet.get_table(name)
                assert table is self.active_table, "Active table is not from the active sheet"
                return table, self.active_worksheet

            for ws in self.worksheets:
                try:
                    table = ws.get_table(name)
                    if table is self.active_table:
                        return table, ws
                except KeyError:
                    pass

            raise RuntimeError("Active table not found in any sheet")

        # if the tablename explicitly uses the sheetname find the right sheet
        if "!" in name:
            ws_name, table_name = map(lambda x: x.strip("'"), name.split("!", 1))
            for ws in self.worksheets:
                if ws.name == ws_name:
                    table = ws.get_table(table_name)
                    return table, ws
            raise KeyError(name)

        # otherwise look in the current table
        if self.active_worksheet:
            table = self.active_worksheet.get_table(name)
            return table, self.active_worksheet

        # or fallback to the first matching name in any table
        for ws in self.worksheets:
            try:
                table = ws.get_table(name)
                return table, ws
            except KeyError:
                pass

        raise KeyError(name)
1139412
def _GetTableNames(self, database):
    
    table_names = []
    for esedb_table in database.tables:
      table_names.append(esedb_table.name)

    return table_names
11164
def get_table(self, tablename):
        
        temp = filter(lambda x: x.name == tablename, self.tables)
        if temp == list():
            raise Exception("No such table")
        return temp[0]
1072225
def generate_dynamodb_tables():
    """"""
    logger.debug("[#] Setting up DynamoDB tables")
    client = boto3.client('dynamodb', region_name=PRIMARY_REGION)
    existing_tables = client.list_tables()['TableNames']

    responses = list()
    for label in DYNAMODB_TABLES:
        if label in existing_tables:
            logger.debug("[*] Table %s already exists" % (label))
            continue

        kwargs = {
            'TableName': label,
            'ProvisionedThroughput': {
                'ReadCapacityUnits': 5,
                'WriteCapacityUnits': 5
            }
        }
        kwargs.update(DYNAMODB_SCHEMAS[label])
        response = client.create_table(**kwargs)
        responses.append(response)
        logger.debug("[#] Successfully setup DynamoDB table %s" % (label))
    logger.info("[#] Successfully setup DynamoDB tables")

    return responses
576470
def table_type(table_name):
    
    table = get_raw_table(table_name)

    if isinstance(table, DataFrameWrapper):
        return 'dataframe'
    elif isinstance(table, TableFuncWrapper):
        return 'function'
347044
def tablename(self) -> str:
        
        if self._tablename:
            return self._tablename
        return self.table.name
580151
def getTablesByName(elem, name):
	
	name = StripTableName(name)
	return elem.getElements(lambda e: (e.tagName == ligolw.Table.tagName) and (e.Name == name))
709165
def get_tables(self):
        

        url = self.build_url(self._endpoints.get('get_tables'))
        response = self.session.get(url)

        if not response:
            return []

        data = response.json()

        return [self.table_constructor(parent=self, **{self._cloud_data_key: table})
                for table in data.get('value', [])]
573353
def get_table_name table
			if table.is_a? String
				return table
			elsif table.methods.include? :name
				return table.name
			end
			return table
		end
1322589
def get_table(self, id_or_name):
        
        url = self.build_url(self._endpoints.get('get_table').format(id=id_or_name))
        response = self.session.get(url)
        if not response:
            return None
        return self.table_constructor(parent=self, **{self._cloud_data_key: response.json()})
842347
def get_table(self, table):
        
        path = '/archive/{}/tables/{}'.format(self._instance, table)
        response = self._client.get_proto(path=path)
        message = archive_pb2.TableInfo()
        message.ParseFromString(response.content)
        return Table(message)
1148188
def full_dynamodb_stream_arn(table_name)
      return table_name if table_name.include?("arn:aws:dynamodb") # assume full stream arn

      begin
        resp = dynamodb.describe_table(table_name: table_name)
      rescue Aws::DynamoDB::Errors::ResourceNotFoundException => e
        puts e.message
        puts "ERROR: Was not able to find the DynamoDB table: #{table_name}.".color(:red)
        code_line = caller.grep(%r{/app/jobs}).first
        puts "Please check: #{code_line}"
        puts "Exiting"
        exit 1
      end
      stream_arn = resp.table.latest_stream_arn
      return stream_arn if stream_arn
    end
395314
def build_input_table(cls, name='inputTableName', input_name='input'):
        
        obj = cls(name)
        obj.exporter = 'get_input_table_name'
        obj.input_name = input_name
        return obj
1320578
def get_table(ports):
    
    table = PrettyTable(["Name", "Port", "Protocol", "Description"])
    table.align["Name"] = "l"
    table.align["Description"] = "l"
    table.padding_width = 1

    for port in ports:
        table.add_row(port)

    return table