Parameters:
     - db_name
     - tbl_name
     - part_vals
     - max_parts
174916
def get_partition_names_ps(self, db_name, tbl_name, part_vals, max_parts):
    
    self.send_get_partition_names_ps(db_name, tbl_name, part_vals, max_parts)
    return self.recv_get_partition_names_ps()
885507
def _get_max_size(parts, size=1):
    
    max_group_size = 0
    for part in parts:
        if isinstance(part, list):
            group_size = 0
            for input_group in part:
                group_size += 1

            if group_size > max_group_size:
                max_group_size = group_size

    magic_size = _get_magic_size(parts)
    return max_group_size * magic_size
1215988
def drop_partition_by_name(self, db_name, tbl_name, part_name, deleteData):
    
    self.send_drop_partition_by_name(db_name, tbl_name, part_name, deleteData)
    return self.recv_drop_partition_by_name()
961703
def isPartitionMarkedForEvent(self, db_name, tbl_name, part_vals, eventType):
    
    self.send_isPartitionMarkedForEvent(db_name, tbl_name, part_vals, eventType)
    return self.recv_isPartitionMarkedForEvent()
1266331
def alter_partitions(self, db_name, tbl_name, new_parts):
    
    self.send_alter_partitions(db_name, tbl_name, new_parts)
    self.recv_alter_partitions()
1294964
def get_partitions_pspec(self, db_name, tbl_name, max_parts):
    
    self.send_get_partitions_pspec(db_name, tbl_name, max_parts)
    return self.recv_get_partitions_pspec()
420864
def max(self):
        """"""
        if "max" not in self.attrs.keys():

            def f(dataset, s):
                return np.nanmax(dataset[s])

            self.attrs["max"] = np.nanmax(list(self.chunkwise(f).values()))
        return self.attrs["max"]
873452
private int getMaxPartCount()
	{
		int max = 0;
		for (Object k : super.fWords.keySet())
		{
			String key = k.toString();
			int count = key.split("\\s+?").length;
			if (count > max)
			{
				max = count;
			}
		}
		return max;
	}
1061493
def max_value_length(cls):
        
        if not hasattr(cls, '__max_value_length_'):
            cls.__max_value_length_ = max([len(c.value) for c in list(cls)])
        return cls.__max_value_length_
1367426
def get_table_names_by_filter(self, dbname, filter, max_tables):
    
    self.send_get_table_names_by_filter(dbname, filter, max_tables)
    return self.recv_get_table_names_by_filter()
924318
def max_sequence_length(self, dataset_split):
    
    return {
        problem.DatasetSplit.TRAIN: 64,
        problem.DatasetSplit.EVAL: 128,
        problem.DatasetSplit.TEST: 128
    }[dataset_split]
595282
def get_part_specs_by_filter(self, db_name, tbl_name, filter, max_parts):
    
    self.send_get_part_specs_by_filter(db_name, tbl_name, filter, max_parts)
    return self.recv_get_part_specs_by_filter()
1114041
def max_repetition_level(self, path):
        """"""
        max_level = 0
        for part in path:
            element = self.schema_element(part)
            if element.repetition_type == parquet_thrift.FieldRepetitionType.REQUIRED:
                max_level += 1
        return max_level
423097
def atlasdb_get_zonefiles_by_name(name, max_index=None, con=None, path=None):
    
    ret = []
    with AtlasDBOpen(con=con, path=path) as dbcon:

        sql = 'SELECT * FROM zonefiles WHERE name = ? ORDER BY inv_index'
        args = (name,)

        if max_index:
            sql += ' AND inv_index <= ?'
            args += (max_index,)

        sql += ';'

        cur = dbcon.cursor()
        res = atlasdb_query_execute(cur, sql, args)

        for zfinfo in res:
            row = {}
            row.update(zfinfo)
            ret.append(row)

    return ret
895255
def get_partitions_with_auth(self, db_name, tbl_name, max_parts, user_name, group_names):
    
    self.send_get_partitions_with_auth(db_name, tbl_name, max_parts, user_name, group_names)
    return self.recv_get_partitions_with_auth()
365369
def get_last(self, n=1):
        
        rows = []
        # Get values from the partial db first
        if self.tracker.dbcon_part and check_table_exists(self.tracker.dbcon_part, self.name):
            rows.extend(get_last_row(self.tracker.dbcon_part, self.name, n))
        # Then add rows from the master if required
        if len(rows) < n and check_table_exists(self.tracker.dbcon_master, self.name):
            rows.extend(get_last_row(self.tracker.dbcon_master, self.name, n))
        return rows[-n:]
979048
def get_indexes(self, db_name, tbl_name, max_indexes):
    
    self.send_get_indexes(db_name, tbl_name, max_indexes)
    return self.recv_get_indexes()