Skip to content

Table reference

Represents a data table available on the Beacon Node.

Source code in beacon_api/table.py 
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
class DataTable:
    """Represents a data table available on the Beacon Node."""

    # Constructor for DataTable
    def __init__(self, http_session: BaseBeaconSession, table_name: str):
        self.http_session = http_session
        self.table_name = table_name

        if self.http_session.version_at_least(1,7,0):
            self.table_type = None
            self.description = None

            response = self.http_session.get("/api/table-schema", params={"table_name": table_name})
            if response.status_code != 200:
                raise Exception(f"Failed to initialize DataTable: {response.text}")
        else:
            response = self.http_session.get("/api/table-config", params={"table_name": table_name})
            if response.status_code != 200:
                raise Exception(f"Failed to get table config: {response.text}")
            table_config = response.json()
            self.table_type = table_config.get("table_type", "unknown")
            self.description = table_config.get("description", None)

    def get_table_description(self) -> str:
        """Get the description of the table"""
        return self.description if self.description else "No description available"    

    def get_table_schema(self) -> dict[str, type]:
        """Get the schema of the table"""
        pa_schema = self.get_table_schema_arrow()
        if pa_schema:
            schema_dict = pa_schema
            return schema_dict
        else:
            raise Exception("Failed to retrieve table schema")

    def get_table_schema_arrow(self) -> pa.Schema:
        """Get the schema of the table in Arrow format"""
        response = self.http_session.get("/api/table-schema", params={"table_name": self.table_name})

        if response.status_code != 200:
            raise Exception(f"Failed to get table schema: {response.text}")

        schema_data = response.json()
        fields = [
            _resolve_arrow_field(field['name'], field['data_type'])
            for field in schema_data['fields']
        ]

        return pa.schema(fields)

    def get_table_type(self) -> Union[dict, str] | None:
        """Get the type of the table"""
        return self.table_type


    def subset(self, longitude_column: str, latitude_column: str, time_column: str, depth_column: str, columns: list[str],
                         bbox: Optional[tuple[float, float, float, float]] = None,
                         depth_range: Optional[tuple[float, float]] = None,
                         time_range: Optional[tuple[datetime.datetime, datetime.datetime]] = None) -> JSONQuery:
        """
        Create a query to subset the table based on the provided parameters.

        Args:
            longitude_column: Name of the column containing longitude values.
            latitude_column: Name of the column containing latitude values.
            time_column: Name of the column containing time values.
            depth_column: Name of the column containing depth values.
            columns: List of additional columns to include in the query.
            bbox: Optional bounding box defined as (min_longitude, min_latitude, max_longitude, max_latitude).
            depth_range: Optional range for depth defined as (min_depth, max_depth).
            time_range: Optional range for time defined as (start_time, end_time).
        Returns
            A Query object that can be executed to retrieve the subset of data.
        """
        query = self.query()
        query.add_select_column(longitude_column)
        query.add_select_column(latitude_column)
        query.add_select_column(time_column)
        query.add_select_column(depth_column)
        for column in columns:
            query.add_select_column(column)
        if bbox:
            query.add_filter(AndFilter([
                RangeFilter(longitude_column, bbox[0], bbox[2]),
                RangeFilter(latitude_column, bbox[1], bbox[3])
            ]))
        if depth_range:
            query.add_filter(RangeFilter(depth_column, depth_range[0], depth_range[1]))
        if time_range:
            query.add_filter(RangeFilter(time_column, time_range[0].strftime("%Y-%m-%dT%H:%M:%S"), time_range[1].strftime("%Y-%m-%dT%H:%M:%S")))
        return query

    def query(self) -> JSONQuery:
        """Create a new query for the selected table.
        The query can then be built using the Query methods.
        Returns:
            JSONQuery: A new query object.
        """
        return JSONQuery(self.http_session, _from=FromTable(self.table_name))

get_table_description()

Get the description of the table

Source code in beacon_api/table.py 
160
161
162
def get_table_description(self) -> str:
    """Get the description of the table"""
    return self.description if self.description else "No description available"

get_table_schema()

Get the schema of the table

Source code in beacon_api/table.py 
164
165
166
167
168
169
170
171
def get_table_schema(self) -> dict[str, type]:
    """Get the schema of the table"""
    pa_schema = self.get_table_schema_arrow()
    if pa_schema:
        schema_dict = pa_schema
        return schema_dict
    else:
        raise Exception("Failed to retrieve table schema")

get_table_schema_arrow()

Get the schema of the table in Arrow format

Source code in beacon_api/table.py 
173
174
175
176
177
178
179
180
181
182
183
184
185
186
def get_table_schema_arrow(self) -> pa.Schema:
    """Get the schema of the table in Arrow format"""
    response = self.http_session.get("/api/table-schema", params={"table_name": self.table_name})

    if response.status_code != 200:
        raise Exception(f"Failed to get table schema: {response.text}")

    schema_data = response.json()
    fields = [
        _resolve_arrow_field(field['name'], field['data_type'])
        for field in schema_data['fields']
    ]

    return pa.schema(fields)

get_table_type()

Get the type of the table

Source code in beacon_api/table.py 
188
189
190
def get_table_type(self) -> Union[dict, str] | None:
    """Get the type of the table"""
    return self.table_type

query()

Create a new query for the selected table. The query can then be built using the Query methods. Returns: JSONQuery: A new query object.

Source code in beacon_api/table.py 
230
231
232
233
234
235
236
def query(self) -> JSONQuery:
    """Create a new query for the selected table.
    The query can then be built using the Query methods.
    Returns:
        JSONQuery: A new query object.
    """
    return JSONQuery(self.http_session, _from=FromTable(self.table_name))

subset(longitude_column, latitude_column, time_column, depth_column, columns, bbox=None, depth_range=None, time_range=None)

Create a query to subset the table based on the provided parameters.

Args: longitude_column: Name of the column containing longitude values. latitude_column: Name of the column containing latitude values. time_column: Name of the column containing time values. depth_column: Name of the column containing depth values. columns: List of additional columns to include in the query. bbox: Optional bounding box defined as (min_longitude, min_latitude, max_longitude, max_latitude). depth_range: Optional range for depth defined as (min_depth, max_depth). time_range: Optional range for time defined as (start_time, end_time). Returns A Query object that can be executed to retrieve the subset of data.

Source code in beacon_api/table.py 
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
def subset(self, longitude_column: str, latitude_column: str, time_column: str, depth_column: str, columns: list[str],
                     bbox: Optional[tuple[float, float, float, float]] = None,
                     depth_range: Optional[tuple[float, float]] = None,
                     time_range: Optional[tuple[datetime.datetime, datetime.datetime]] = None) -> JSONQuery:
    """
    Create a query to subset the table based on the provided parameters.

    Args:
        longitude_column: Name of the column containing longitude values.
        latitude_column: Name of the column containing latitude values.
        time_column: Name of the column containing time values.
        depth_column: Name of the column containing depth values.
        columns: List of additional columns to include in the query.
        bbox: Optional bounding box defined as (min_longitude, min_latitude, max_longitude, max_latitude).
        depth_range: Optional range for depth defined as (min_depth, max_depth).
        time_range: Optional range for time defined as (start_time, end_time).
    Returns
        A Query object that can be executed to retrieve the subset of data.
    """
    query = self.query()
    query.add_select_column(longitude_column)
    query.add_select_column(latitude_column)
    query.add_select_column(time_column)
    query.add_select_column(depth_column)
    for column in columns:
        query.add_select_column(column)
    if bbox:
        query.add_filter(AndFilter([
            RangeFilter(longitude_column, bbox[0], bbox[2]),
            RangeFilter(latitude_column, bbox[1], bbox[3])
        ]))
    if depth_range:
        query.add_filter(RangeFilter(depth_column, depth_range[0], depth_range[1]))
    if time_range:
        query.add_filter(RangeFilter(time_column, time_range[0].strftime("%Y-%m-%dT%H:%M:%S"), time_range[1].strftime("%Y-%m-%dT%H:%M:%S")))
    return query