meerschaum 2.9.0.dev1__py3-none-any.whl → 2.9.0rc2__py3-none-any.whl

meerschaum/config/_default.py

@@ -70,6 +70,7 @@ default_system_config = {
         'sql': {
             'bulk_insert': {
                 'postgresql': True,
+                'postgis': True,
                 'citus': True,
                 'timescaledb': True,
                 'mssql': True,

meerschaum/config/_version.py

@@ -2,4 +2,4 @@
 Specify the Meerschaum release version.
 """
 
-__version__ = "2.9.0.dev1"
+__version__ = "2.9.0rc2"

meerschaum/connectors/sql/_SQLConnector.py

@@ -151,6 +151,9 @@ class SQLConnector(Connector):
             if uri.startswith('timescaledb://'):
                 uri = uri.replace('timescaledb://', 'postgresql+psycopg://', 1)
                 flavor = 'timescaledb'
+            if uri.startswith('postgis://'):
+                uri = uri.replace('postgis://', 'postgresql+psycopg://', 1)
+                flavor = 'postgis'
             kw['uri'] = uri
             from_uri_params = self.from_uri(kw['uri'], as_dict=True)
             label = label or from_uri_params.get('label', None)

meerschaum/connectors/sql/_cli.py

@@ -15,6 +15,7 @@ from meerschaum.utils.typing import SuccessTuple
 
 flavor_clis = {
     'postgresql'  : 'pgcli',
+    'postgis'  : 'pgcli',
     'timescaledb' : 'pgcli',
     'cockroachdb' : 'pgcli',
     'citus'       : 'pgcli',

meerschaum/connectors/sql/_create_engine.py

@@ -7,6 +7,7 @@ This module contains the logic that builds the sqlalchemy engine string.
 """
 
 import traceback
+import meerschaum as mrsm
 from meerschaum.utils.debug import dprint
 
 ### determine driver and requirements from flavor
@@ -47,6 +48,16 @@ flavor_configs = {
             'port': 5432,
         },
     },
+    'postgis': {
+        'engine': 'postgresql+psycopg',
+        'create_engine': default_create_engine_args,
+        'omit_create_engine': {'method',},
+        'to_sql': {},
+        'requirements': default_requirements,
+        'defaults': {
+            'port': 5432,
+        },
+    },
     'citus': {
         'engine': 'postgresql+psycopg',
         'create_engine': default_create_engine_args,
@@ -162,6 +173,7 @@ install_flavor_drivers = {
     'mariadb': ['pymysql'],
     'timescaledb': ['psycopg'],
     'postgresql': ['psycopg'],
+    'postgis': ['psycopg', 'geoalchemy'],
     'citus': ['psycopg'],
     'cockroachdb': ['psycopg', 'sqlalchemy_cockroachdb', 'sqlalchemy_cockroachdb.psycopg'],
     'mssql': ['pyodbc'],
@@ -198,8 +210,7 @@ def create_engine(
             warn=False,
         )
         if self.flavor == 'mssql':
-            pyodbc = attempt_import('pyodbc', debug=debug, lazy=False, warn=False)
-            pyodbc.pooling = False
+            _init_mssql_sqlalchemy()
     if self.flavor in require_patching_flavors:
         from meerschaum.utils.packages import determine_version, _monkey_patch_get_distribution
         import pathlib
@@ -257,8 +268,8 @@ def create_engine(
 
         ### Sometimes the timescaledb:// flavor can slip in.
         if _uri and self.flavor in _uri:
-            if self.flavor == 'timescaledb':
-                engine_str = engine_str.replace(f'{self.flavor}', 'postgresql', 1)
+            if self.flavor in ('timescaledb', 'postgis'):
+                engine_str = engine_str.replace(self.flavor, 'postgresql', 1)
             elif _uri.startswith('postgresql://'):
                 engine_str = engine_str.replace('postgresql://', 'postgresql+psycopg2://')
 
@@ -313,3 +324,39 @@ def create_engine(
     if include_uri:
         return engine, engine_str
     return engine
+
+
+def _init_mssql_sqlalchemy():
+    """
+    When first instantiating a SQLAlchemy connection to MSSQL,
+    monkey-patch `pyodbc` handling in SQLAlchemy.
+    """
+    pyodbc, sqlalchemy_dialects_mssql_pyodbc = mrsm.attempt_import(
+        'pyodbc',
+        'sqlalchemy.dialects.mssql.pyodbc',
+        lazy=False,
+        warn=False,
+    )
+    pyodbc.pooling = False
+
+    MSDialect_pyodbc = sqlalchemy_dialects_mssql_pyodbc.MSDialect_pyodbc
+
+    def _handle_geometry(val):
+        from binascii import hexlify
+        hex_str = f"0x{hexlify(val).decode().upper()}"
+        return hex_str
+
+    def custom_on_connect(self):
+        super_ = super(MSDialect_pyodbc, self).on_connect()
+
+        def _on_connect(conn):
+            if super_ is not None:
+                super_(conn)
+
+            self._setup_timestampoffset_type(conn)
+            conn.add_output_converter(-151, _handle_geometry)
+
+        return _on_connect
+
+    ### TODO: Parse proprietary MSSQL geometry bytes into WKB.
+    #  MSDialect_pyodbc.on_connect = custom_on_connect

meerschaum/connectors/sql/_pipes.py

@@ -731,7 +731,7 @@ def get_create_index_queries(
                         ) + f"{primary_key_name})"
                     ),
                 ])
-            elif self.flavor in ('citus', 'postgresql', 'duckdb'):
+            elif self.flavor in ('citus', 'postgresql', 'duckdb', 'postgis'):
                 primary_queries.extend([
                     (
                         f"ALTER TABLE {_pipe_name}\n"
@@ -1052,6 +1052,7 @@ def get_pipe_data(
         attempt_cast_to_numeric,
         attempt_cast_to_uuid,
         attempt_cast_to_bytes,
+        attempt_cast_to_geometry,
         are_dtypes_equal,
     )
     from meerschaum.utils.dtypes.sql import get_pd_type_from_db_type
@@ -1138,6 +1139,11 @@ def get_pipe_data(
         for col, typ in pipe.dtypes.items()
         if typ == 'bytes' and col in dtypes
     ]
+    geometry_columns = [
+        col
+        for col, typ in pipe.dtypes.items()
+        if typ.startswith('geometry') and col in dtypes
+    ]
 
     kw['coerce_float'] = kw.get('coerce_float', (len(numeric_columns) == 0))
 
@@ -1162,6 +1168,11 @@ def get_pipe_data(
             continue
         df[col] = df[col].apply(attempt_cast_to_bytes)
 
+    for col in geometry_columns:
+        if col not in df.columns:
+            continue
+        df[col] = df[col].apply(attempt_cast_to_geometry)
+
     if self.flavor == 'sqlite':
         ignore_dt_cols = [
             col
@@ -1511,7 +1522,7 @@ def get_pipe_attributes(
             if isinstance(parameters, str) and parameters[0] == '{':
                 parameters = json.loads(parameters)
             attributes['parameters'] = parameters
-        except Exception as e:
+        except Exception:
             attributes['parameters'] = {}
 
     return attributes

meerschaum/connectors/sql/_sql.py

@@ -17,7 +17,7 @@ from meerschaum.utils.debug import dprint
 from meerschaum.utils.warnings import warn
 
 ### database flavors that can use bulk insert
-_bulk_flavors = {'postgresql', 'timescaledb', 'citus', 'mssql'}
+_bulk_flavors = {'postgresql', 'postgis', 'timescaledb', 'citus', 'mssql'}
 ### flavors that do not support chunks
 _disallow_chunks_flavors = ['duckdb']
 _max_chunks_flavors = {'sqlite': 1000}
@@ -798,6 +798,7 @@ def to_sql(
         get_numeric_cols,
         get_uuid_cols,
         get_bytes_cols,
+        get_geometry_cols,
     )
     from meerschaum.utils.dtypes import (
         are_dtypes_equal,
@@ -805,7 +806,9 @@ def to_sql(
         encode_bytes_for_bytea,
         serialize_bytes,
         serialize_decimal,
+        serialize_geometry,
         json_serialize_value,
+        get_geometry_type_srid,
     )
     from meerschaum.utils.dtypes.sql import (
         PD_TO_SQLALCHEMY_DTYPES_FLAVORS,
@@ -822,6 +825,7 @@ def to_sql(
 
     bytes_cols = get_bytes_cols(df)
     numeric_cols = get_numeric_cols(df)
+    geometry_cols = get_geometry_cols(df)
     ### NOTE: This excludes non-numeric serialized Decimals (e.g. SQLite).
     numeric_cols_dtypes = {
         col: typ
@@ -830,7 +834,6 @@ def to_sql(
             col in df.columns
             and 'numeric' in str(typ).lower()
         )
-        
     }
     numeric_cols.extend([col for col in numeric_cols_dtypes if col not in numeric_cols])
     numeric_cols_precisions_scales = {
@@ -841,6 +844,22 @@ def to_sql(
         )
         for col, typ in numeric_cols_dtypes.items()
     }
+    geometry_cols_dtypes = {
+        col: typ
+        for col, typ in kw.get('dtype', {}).items()
+        if (
+            col in df.columns
+            and 'geometry' in str(typ).lower() or 'geography' in str(typ).lower()
+        )
+    }
+    geometry_cols.extend([col for col in geometry_cols_dtypes if col not in geometry_cols])
+    geometry_cols_types_srids = {
+        col: (typ.geometry_type, typ.srid)
+        if hasattr(typ, 'srid')
+        else get_geometry_type_srid()
+        for col, typ in geometry_cols_dtypes.items()
+    }
+
     cols_pd_types = {
         col: get_pd_type_from_db_type(str(typ))
         for col, typ in kw.get('dtype', {}).items()
@@ -856,8 +875,9 @@ def to_sql(
     }
 
     enable_bulk_insert = mrsm.get_config(
-        'system', 'connectors', 'sql', 'bulk_insert'
-    ).get(self.flavor, False)
+        'system', 'connectors', 'sql', 'bulk_insert', self.flavor,
+        warn=False,
+    ) or False
     stats = {'target': name}
     ### resort to defaults if None
     copied = False
@@ -901,6 +921,17 @@ def to_sql(
             )
         )
 
+    for col in geometry_cols:
+        geometry_type, srid = geometry_cols_types_srids.get(col, get_geometry_type_srid())
+        with warnings.catch_warnings():
+            warnings.simplefilter("ignore")
+            df[col] = df[col].apply(
+                functools.partial(
+                    serialize_geometry,
+                    as_wkt=(self.flavor == 'mssql')
+                )
+            )
+
     stats['method'] = method.__name__ if hasattr(method, '__name__') else str(method)
 
     default_chunksize = self._sys_config.get('chunksize', None)

meerschaum/utils/dataframe.py

@@ -153,6 +153,7 @@ def filter_unseen_df(
         attempt_cast_to_numeric,
         attempt_cast_to_uuid,
         attempt_cast_to_bytes,
+        attempt_cast_to_geometry,
         coerce_timezone,
         serialize_decimal,
     )
@@ -350,6 +351,10 @@ def filter_unseen_df(
     new_bytes_cols = get_bytes_cols(new_df)
     bytes_cols = set(new_bytes_cols + old_bytes_cols)
 
+    old_geometry_cols = get_geometry_cols(old_df)
+    new_geometry_cols = get_geometry_cols(new_df)
+    geometry_cols = set(new_geometry_cols + old_geometry_cols)
+
     joined_df = merge(
         new_df.infer_objects(copy=False).fillna(NA),
         old_df.infer_objects(copy=False).fillna(NA),
@@ -400,6 +405,14 @@ def filter_unseen_df(
         except Exception:
             warn(f"Unable to parse bytes column '{bytes_col}':\n{traceback.format_exc()}")
 
+    for geometry_col in geometry_cols:
+        if geometry_col not in delta_df.columns:
+            continue
+        try:
+            delta_df[geometry_col] = delta_df[geometry_col].apply(attempt_cast_to_geometry)
+        except Exception:
+            warn(f"Unable to parse bytes column '{bytes_col}':\n{traceback.format_exc()}")
+
     return delta_df
 
 
@@ -858,6 +871,44 @@ def get_bytes_cols(df: 'pd.DataFrame') -> List[str]:
     ]
 
 
+def get_geometry_cols(df: 'pd.DataFrame') -> List[str]:
+    """
+    Get the columns which contain shapely objects from a Pandas DataFrame.
+
+    Parameters
+    ----------
+    df: pd.DataFrame
+        The DataFrame which may contain bytes strings.
+
+    Returns
+    -------
+    A list of columns to treat as `geometry`.
+    """
+    if df is None:
+        return []
+
+    is_dask = 'dask' in df.__module__
+    if is_dask:
+        df = get_first_valid_dask_partition(df)
+
+    if len(df) == 0:
+        return []
+
+    cols_indices = {
+        col: df[col].first_valid_index()
+        for col in df.columns
+    }
+    return [
+        col
+        for col, ix in cols_indices.items()
+        if (
+            ix is not None
+            and
+            'shapely' in str(type(df.loc[ix][col]))
+        )
+    ]
+
+
 def enforce_dtypes(
     df: 'pd.DataFrame',
     dtypes: Dict[str, str],
@@ -911,6 +962,7 @@ def enforce_dtypes(
         attempt_cast_to_numeric,
         attempt_cast_to_uuid,
         attempt_cast_to_bytes,
+        attempt_cast_to_geometry,
         coerce_timezone as _coerce_timezone,
     )
     from meerschaum.utils.dtypes.sql import get_numeric_precision_scale
@@ -937,6 +989,11 @@ def enforce_dtypes(
         for col, typ in dtypes.items()
         if typ.startswith('numeric')
     ]
+    geometry_cols = [
+        col
+        for col, typ in dtypes.items()
+        if typ.startswith('geometry') or typ.startswith('geography')
+    ]
     uuid_cols = [
         col
         for col, typ in dtypes.items()
@@ -1026,6 +1083,28 @@ def enforce_dtypes(
             if col in df.columns:
                 df[col] = _coerce_timezone(df[col], strip_utc=strip_timezone)
 
+    if geometry_cols:
+        geopandas = mrsm.attempt_import('geopandas')
+        if debug:
+            dprint(f"Checking for geometry: {geometry_cols}")
+        parsed_geom_cols = []
+        for col in geometry_cols:
+            try:
+                df[col] = df[col].apply(attempt_cast_to_geometry)
+                parsed_geom_cols.append(col)
+            except Exception as e:
+                if debug:
+                    dprint(f"Unable to parse column '{col}' as geometry:\n{e}")
+
+        if parsed_geom_cols:
+            if debug:
+                dprint(f"Converting to GeoDataFrame (geometry column: '{parsed_geom_cols[0]}')...")
+            df = geopandas.GeoDataFrame(df, geometry=parsed_geom_cols[0])
+            try:
+                df.rename_geometry(parsed_geom_cols[0], inplace=True)
+            except ValueError:
+                pass
+
     df_dtypes = {c: str(t) for c, t in df.dtypes.items()}
     if are_dtypes_equal(df_dtypes, pipe_pandas_dtypes):
         if debug:
@@ -1602,13 +1681,19 @@ def to_json(
     -------
     A JSON string.
     """
+    import warnings
     from meerschaum.utils.packages import import_pandas
-    from meerschaum.utils.dtypes import serialize_bytes, serialize_decimal
+    from meerschaum.utils.dtypes import (
+        serialize_bytes,
+        serialize_decimal,
+        serialize_geometry,
+    )
     pd = import_pandas()
     uuid_cols = get_uuid_cols(df)
     bytes_cols = get_bytes_cols(df)
     numeric_cols = get_numeric_cols(df)
-    if safe_copy and bool(uuid_cols or bytes_cols):
+    geometry_cols = get_geometry_cols(df)
+    if safe_copy and bool(uuid_cols or bytes_cols or geometry_cols or numeric_cols):
         df = df.copy()
     for col in uuid_cols:
         df[col] = df[col].astype(str)
@@ -1616,6 +1701,10 @@ def to_json(
         df[col] = df[col].apply(serialize_bytes)
     for col in numeric_cols:
         df[col] = df[col].apply(serialize_decimal)
+    with warnings.catch_warnings():
+        warnings.simplefilter("ignore")
+        for col in geometry_cols:
+            df[col] = df[col].apply(serialize_geometry)
     return df.infer_objects(copy=False).fillna(pd.NA).to_json(
         date_format=date_format,
         date_unit=date_unit,

meerschaum/utils/dtypes/__init__.py

@@ -12,7 +12,7 @@ from datetime import timezone, datetime
 from decimal import Decimal, Context, InvalidOperation, ROUND_HALF_UP
 
 import meerschaum as mrsm
-from meerschaum.utils.typing import Dict, Union, Any, Optional
+from meerschaum.utils.typing import Dict, Union, Any, Optional, Tuple
 from meerschaum.utils.warnings import warn
 
 MRSM_ALIAS_DTYPES: Dict[str, str] = {
@@ -27,10 +27,13 @@ MRSM_ALIAS_DTYPES: Dict[str, str] = {
     'bytea': 'bytes',
     'guid': 'uuid',
     'UUID': 'uuid',
+    'geom': 'geometry',
 }
 MRSM_PD_DTYPES: Dict[Union[str, None], str] = {
     'json': 'object',
     'numeric': 'object',
+    'geometry': 'object',
+    'geography': 'object',
     'uuid': 'object',
     'datetime': 'datetime64[ns, UTC]',
     'bool': 'bool[pyarrow]',
@@ -60,6 +63,12 @@ def to_pandas_dtype(dtype: str) -> str:
     if dtype.startswith('numeric'):
         return MRSM_PD_DTYPES['numeric']
 
+    if dtype.startswith('geometry'):
+        return MRSM_PD_DTYPES['geometry']
+
+    if dtype.startswith('geography'):
+        return MRSM_PD_DTYPES['geography']
+
     ### NOTE: Kind of a hack, but if the first word of the given dtype is in all caps,
     ### treat it as a SQL db type.
     if dtype.split(' ')[0].isupper():
@@ -147,6 +156,10 @@ def are_dtypes_equal(
     if ldtype in bytes_dtypes and rdtype in bytes_dtypes:
         return True
 
+    geometry_dtypes = ('geometry', 'object', 'geography')
+    if ldtype in geometry_dtypes and rdtype in geometry_dtypes:
+        return True
+
     if ldtype.lower() == rdtype.lower():
         return True
 
@@ -277,6 +290,56 @@ def attempt_cast_to_bytes(value: Any) -> Any:
         return value
 
 
+def attempt_cast_to_geometry(value: Any) -> Any:
+    """
+    Given a value, attempt to coerce it into a `shapely` (`geometry`) object.
+    """
+    shapely_wkt, shapely_wkb = mrsm.attempt_import('shapely.wkt', 'shapely.wkb', lazy=False)
+    if 'shapely' in str(type(value)):
+        return value
+
+    value_is_wkt = geometry_is_wkt(value)
+    if value_is_wkt is None:
+        return value
+
+    try:
+        return (
+            shapely_wkt.loads(value)
+            if value_is_wkt
+            else shapely_wkb.loads(value)
+        )
+    except Exception:
+        return value
+
+
+def geometry_is_wkt(value: Union[str, bytes]) -> Union[bool, None]:
+    """
+    Determine whether an input value should be treated as WKT or WKB geometry data.
+
+    Parameters
+    ----------
+    value: Union[str, bytes]
+        The input data to be parsed into geometry data.
+
+    Returns
+    -------
+    A `bool` (`True` if `value` is WKT and `False` if it should be treated as WKB).
+    Return `None` if `value` should be parsed as neither.
+    """
+    import re
+    if isinstance(value, bytes):
+        return False
+    
+    wkt_pattern = r'^\s*(POINT|LINESTRING|POLYGON|MULTIPOINT|MULTILINESTRING|MULTIPOLYGON|GEOMETRYCOLLECTION)\s*\(.*\)\s*$'
+    if re.match(wkt_pattern, value, re.IGNORECASE):
+        return True
+    
+    if all(c in '0123456789ABCDEFabcdef' for c in value) and len(value) % 2 == 0:
+        return False
+    
+    return None
+
+
 def value_is_null(value: Any) -> bool:
     """
     Determine if a value is a null-like string.
@@ -458,6 +521,37 @@ def serialize_bytes(data: bytes) -> str:
     return base64.b64encode(data).decode('utf-8')
 
 
+def serialize_geometry(geom: Any, as_wkt: bool = False) -> str:
+    """
+    Serialize geometry data as a hex-encoded well-known-binary string. 
+
+    Parameters
+    ----------
+    geom: Any
+        The potential geometry data to be serialized.
+
+    as_wkt, bool, default False
+        If `True`, serialize geometry data as well-known text (WKT)
+        instead of well-known binary (WKB).
+
+    Returns
+    -------
+    A string containing the geometry data.
+    """
+    if hasattr(geom, 'wkb_hex'):
+        return geom.wkb_hex if not as_wkt else geom.wkt
+
+    return str(geom)
+
+
+def deserialize_geometry(geom_wkb: Union[str, bytes]):
+    """
+    Deserialize a WKB string into a shapely geometry object.
+    """
+    shapely = mrsm.attempt_import(lazy=False)
+    return shapely.wkb.loads(geom_wkb)
+
+
 def deserialize_bytes_string(data: str | None, force_hex: bool = False) -> bytes | None:
     """
     Given a serialized ASCII string of bytes data, return the original bytes.
@@ -559,7 +653,94 @@ def json_serialize_value(x: Any, default_to_str: bool = True) -> str:
     if isinstance(x, Decimal):
         return serialize_decimal(x)
 
+    if 'shapely' in str(type(x)):
+        return serialize_geometry(x)
+
     if value_is_null(x):
         return None
 
     return str(x) if default_to_str else x
+
+
+def get_geometry_type_srid(
+    dtype: str = 'geometry',
+    default_type: str = 'geometry',
+    default_srid: int = 4326,
+) -> Union[Tuple[str, int], Tuple[str, None]]:
+    """
+    Given the specified geometry `dtype`, return a tuple in the form (type, SRID).
+
+    Parameters
+    ----------
+    dtype: Optional[str], default None
+        Optionally provide a specific `geometry` syntax (e.g. `geometry[MultiLineString, 4326]`).
+        You may specify a supported `shapely` geometry type and an SRID in the dtype modifier:
+
+        - `Point`
+        - `LineString`
+        - `LinearRing`
+        - `Polygon`
+        - `MultiPoint`
+        - `MultiLineString`
+        - `MultiPolygon`
+        - `GeometryCollection`
+
+    Returns
+    -------
+    A tuple in the form (type, SRID).
+    Defaults to `(default_type, default_srid)`.
+
+    Examples
+    --------
+    >>> from meerschaum.utils.dtypes import get_geometry_type_srid
+    >>> get_geometry_type_srid()
+    ('geometry', 4326)
+    >>> get_geometry_type_srid('geometry[]')
+    ('geometry', 4326)
+    >>> get_geometry_type_srid('geometry[Point, 0]')
+    ('Point', 0)
+    >>> get_geometry_type_srid('geometry[0, Point]')
+    ('Point', 0)
+    >>> get_geometry_type_srid('geometry[0]')
+    ('geometry', 0)
+    >>> get_geometry_type_srid('geometry[MULTILINESTRING, 4326]')
+    ('MultiLineString', 4326)
+    >>> get_geometry_type_srid('geography')
+    ('geometry', 4326)
+    >>> get_geometry_type_srid('geography[POINT]')
+    ('Point', 4376)
+    """
+    from meerschaum.utils.misc import is_int
+    bare_dtype = dtype.split('[', maxsplit=1)[0]
+    modifier = dtype.split(bare_dtype, maxsplit=1)[-1].lstrip('[').rstrip(']')
+    if not modifier:
+        return default_type, default_srid
+
+    shapely_geometry_base = mrsm.attempt_import('shapely.geometry.base')
+    geometry_types = {
+        typ.lower(): typ
+        for typ in shapely_geometry_base.GEOMETRY_TYPES
+    }
+
+    parts = [part.lower().replace('srid=', '').replace('type=', '').strip() for part in modifier.split(',')]
+    parts_casted = [
+        (
+            int(part)
+            if is_int(part)
+            else part
+        ) for part in parts]
+
+    srid = default_srid
+    geometry_type = default_type
+
+    for part in parts_casted:
+        if isinstance(part, int):
+            srid = part
+            break
+
+    for part in parts:
+        if part.lower() in geometry_types:
+            geometry_type = geometry_types.get(part)
+            break
+
+    return geometry_type, srid

meerschaum/utils/dtypes/sql.py

@@ -128,6 +128,7 @@ PD_TO_DB_DTYPES_FLAVORS: Dict[str, Dict[str, str]] = {
     'int': {
         'timescaledb': 'BIGINT',
         'postgresql': 'BIGINT',
+        'postgis': 'BIGINT',
         'mariadb': 'BIGINT',
         'mysql': 'BIGINT',
         'mssql': 'BIGINT',
@@ -141,6 +142,7 @@ PD_TO_DB_DTYPES_FLAVORS: Dict[str, Dict[str, str]] = {
     'float': {
         'timescaledb': 'DOUBLE PRECISION',
         'postgresql': 'DOUBLE PRECISION',
+        'postgis': 'DOUBLE PRECISION',
         'mariadb': 'DOUBLE PRECISION',
         'mysql': 'DOUBLE PRECISION',
         'mssql': 'FLOAT',
@@ -154,6 +156,7 @@ PD_TO_DB_DTYPES_FLAVORS: Dict[str, Dict[str, str]] = {
     'double': {
         'timescaledb': 'DOUBLE PRECISION',
         'postgresql': 'DOUBLE PRECISION',
+        'postgis': 'DOUBLE PRECISION',
         'mariadb': 'DOUBLE PRECISION',
         'mysql': 'DOUBLE PRECISION',
         'mssql': 'FLOAT',
@@ -167,6 +170,7 @@ PD_TO_DB_DTYPES_FLAVORS: Dict[str, Dict[str, str]] = {
     'datetime64[ns]': {
         'timescaledb': 'TIMESTAMP',
         'postgresql': 'TIMESTAMP',
+        'postgis': 'TIMESTAMP',
         'mariadb': 'DATETIME',
         'mysql': 'DATETIME',
         'mssql': 'DATETIME2',
@@ -180,6 +184,7 @@ PD_TO_DB_DTYPES_FLAVORS: Dict[str, Dict[str, str]] = {
     'datetime64[ns, UTC]': {
         'timescaledb': 'TIMESTAMPTZ',
         'postgresql': 'TIMESTAMPTZ',
+        'postgis': 'TIMESTAMPTZ',
         'mariadb': 'DATETIME',
         'mysql': 'DATETIME',
         'mssql': 'DATETIMEOFFSET',
@@ -193,6 +198,7 @@ PD_TO_DB_DTYPES_FLAVORS: Dict[str, Dict[str, str]] = {
     'datetime': {
         'timescaledb': 'TIMESTAMPTZ',
         'postgresql': 'TIMESTAMPTZ',
+        'postgis': 'TIMESTAMPTZ',
         'mariadb': 'DATETIME',
         'mysql': 'DATETIME',
         'mssql': 'DATETIMEOFFSET',
@@ -206,6 +212,7 @@ PD_TO_DB_DTYPES_FLAVORS: Dict[str, Dict[str, str]] = {
     'datetimetz': {
         'timescaledb': 'TIMESTAMPTZ',
         'postgresql': 'TIMESTAMPTZ',
+        'postgis': 'TIMESTAMPTZ',
         'mariadb': 'DATETIME',
         'mysql': 'DATETIME',
         'mssql': 'DATETIMEOFFSET',
@@ -219,6 +226,7 @@ PD_TO_DB_DTYPES_FLAVORS: Dict[str, Dict[str, str]] = {
     'bool': {
         'timescaledb': 'BOOLEAN',
         'postgresql': 'BOOLEAN',
+        'postgis': 'BOOLEAN',
         'mariadb': 'BOOLEAN',
         'mysql': 'BOOLEAN',
         'mssql': 'BIT',
@@ -232,6 +240,7 @@ PD_TO_DB_DTYPES_FLAVORS: Dict[str, Dict[str, str]] = {
     'object': {
         'timescaledb': 'TEXT',
         'postgresql': 'TEXT',
+        'postgis': 'TEXT',
         'mariadb': 'TEXT',
         'mysql': 'TEXT',
         'mssql': 'NVARCHAR(MAX)',
@@ -245,6 +254,7 @@ PD_TO_DB_DTYPES_FLAVORS: Dict[str, Dict[str, str]] = {
     'string': {
         'timescaledb': 'TEXT',
         'postgresql': 'TEXT',
+        'postgis': 'TEXT',
         'mariadb': 'TEXT',
         'mysql': 'TEXT',
         'mssql': 'NVARCHAR(MAX)',
@@ -258,6 +268,7 @@ PD_TO_DB_DTYPES_FLAVORS: Dict[str, Dict[str, str]] = {
     'unicode': {
         'timescaledb': 'TEXT',
         'postgresql': 'TEXT',
+        'postgis': 'TEXT',
         'mariadb': 'TEXT',
         'mysql': 'TEXT',
         'mssql': 'NVARCHAR(MAX)',
@@ -271,6 +282,7 @@ PD_TO_DB_DTYPES_FLAVORS: Dict[str, Dict[str, str]] = {
     'json': {
         'timescaledb': 'JSONB',
         'postgresql': 'JSONB',
+        'postgis': 'JSONB',
         'mariadb': 'TEXT',
         'mysql': 'TEXT',
         'mssql': 'NVARCHAR(MAX)',
@@ -284,6 +296,7 @@ PD_TO_DB_DTYPES_FLAVORS: Dict[str, Dict[str, str]] = {
     'numeric': {
         'timescaledb': 'NUMERIC',
         'postgresql': 'NUMERIC',
+        'postgis': 'NUMERIC',
         'mariadb': f'DECIMAL{NUMERIC_PRECISION_FLAVORS["mariadb"]}',
         'mysql': f'DECIMAL{NUMERIC_PRECISION_FLAVORS["mysql"]}',
         'mssql': f'NUMERIC{NUMERIC_PRECISION_FLAVORS["mssql"]}',
@@ -297,6 +310,7 @@ PD_TO_DB_DTYPES_FLAVORS: Dict[str, Dict[str, str]] = {
     'uuid': {
         'timescaledb': 'UUID',
         'postgresql': 'UUID',
+        'postgis': 'UUID',
         'mariadb': 'CHAR(36)',
         'mysql': 'CHAR(36)',
         'mssql': 'UNIQUEIDENTIFIER',
@@ -311,6 +325,7 @@ PD_TO_DB_DTYPES_FLAVORS: Dict[str, Dict[str, str]] = {
     'bytes': {
         'timescaledb': 'BYTEA',
         'postgresql': 'BYTEA',
+        'postgis': 'BYTEA',
         'mariadb': 'BLOB',
         'mysql': 'BLOB',
         'mssql': 'VARBINARY(MAX)',
@@ -321,11 +336,40 @@ PD_TO_DB_DTYPES_FLAVORS: Dict[str, Dict[str, str]] = {
         'cockroachdb': 'BYTEA',
         'default': 'BLOB',
     },
+    'geometry': {
+        'timescaledb': 'TEXT',
+        'postgresql': 'TEXT',
+        'postgis': 'GEOMETRY',
+        'mariadb': 'TEXT',
+        'mysql': 'TEXT',
+        'mssql': 'NVARCHAR(MAX)',
+        'oracle': 'NVARCHAR2(2000)',
+        'sqlite': 'TEXT',
+        'duckdb': 'TEXT',
+        'citus': 'TEXT',
+        'cockroachdb': 'TEXT',
+        'default': 'TEXT',
+    },
+    'geography': {
+        'timescaledb': 'TEXT',
+        'postgresql': 'TEXT',
+        'postgis': 'GEOGRAPHY',
+        'mariadb': 'TEXT',
+        'mysql': 'TEXT',
+        'mssql': 'NVARCHAR(MAX)',
+        'oracle': 'NVARCHAR2(2000)',
+        'sqlite': 'TEXT',
+        'duckdb': 'TEXT',
+        'citus': 'TEXT',
+        'cockroachdb': 'TEXT',
+        'default': 'TEXT',
+    },
 }
 PD_TO_SQLALCHEMY_DTYPES_FLAVORS: Dict[str, Dict[str, str]] = {
     'int': {
         'timescaledb': 'BigInteger',
         'postgresql': 'BigInteger',
+        'postgis': 'BigInteger',
         'mariadb': 'BigInteger',
         'mysql': 'BigInteger',
         'mssql': 'BigInteger',
@@ -339,6 +383,7 @@ PD_TO_SQLALCHEMY_DTYPES_FLAVORS: Dict[str, Dict[str, str]] = {
     'float': {
         'timescaledb': 'Float',
         'postgresql': 'Float',
+        'postgis': 'Float',
         'mariadb': 'Float',
         'mysql': 'Float',
         'mssql': 'Float',
@@ -352,6 +397,7 @@ PD_TO_SQLALCHEMY_DTYPES_FLAVORS: Dict[str, Dict[str, str]] = {
     'datetime': {
         'timescaledb': 'DateTime(timezone=True)',
         'postgresql': 'DateTime(timezone=True)',
+        'postgis': 'DateTime(timezone=True)',
         'mariadb': 'DateTime(timezone=True)',
         'mysql': 'DateTime(timezone=True)',
         'mssql': 'sqlalchemy.dialects.mssql.DATETIMEOFFSET',
@@ -365,6 +411,7 @@ PD_TO_SQLALCHEMY_DTYPES_FLAVORS: Dict[str, Dict[str, str]] = {
     'datetime64[ns]': {
         'timescaledb': 'DateTime',
         'postgresql': 'DateTime',
+        'postgis': 'DateTime',
         'mariadb': 'DateTime',
         'mysql': 'DateTime',
         'mssql': 'sqlalchemy.dialects.mssql.DATETIME2',
@@ -378,6 +425,7 @@ PD_TO_SQLALCHEMY_DTYPES_FLAVORS: Dict[str, Dict[str, str]] = {
     'datetime64[ns, UTC]': {
         'timescaledb': 'DateTime(timezone=True)',
         'postgresql': 'DateTime(timezone=True)',
+        'postgis': 'DateTime(timezone=True)',
         'mariadb': 'DateTime(timezone=True)',
         'mysql': 'DateTime(timezone=True)',
         'mssql': 'sqlalchemy.dialects.mssql.DATETIMEOFFSET',
@@ -391,6 +439,7 @@ PD_TO_SQLALCHEMY_DTYPES_FLAVORS: Dict[str, Dict[str, str]] = {
     'bool': {
         'timescaledb': 'Boolean',
         'postgresql': 'Boolean',
+        'postgis': 'Boolean',
         'mariadb': 'Integer',
         'mysql': 'Integer',
         'mssql': 'sqlalchemy.dialects.mssql.BIT',
@@ -404,6 +453,7 @@ PD_TO_SQLALCHEMY_DTYPES_FLAVORS: Dict[str, Dict[str, str]] = {
     'object': {
         'timescaledb': 'UnicodeText',
         'postgresql': 'UnicodeText',
+        'postgis': 'UnicodeText',
         'mariadb': 'UnicodeText',
         'mysql': 'UnicodeText',
         'mssql': 'UnicodeText',
@@ -417,6 +467,7 @@ PD_TO_SQLALCHEMY_DTYPES_FLAVORS: Dict[str, Dict[str, str]] = {
     'string': {
         'timescaledb': 'UnicodeText',
         'postgresql': 'UnicodeText',
+        'postgis': 'UnicodeText',
         'mariadb': 'UnicodeText',
         'mysql': 'UnicodeText',
         'mssql': 'UnicodeText',
@@ -430,6 +481,7 @@ PD_TO_SQLALCHEMY_DTYPES_FLAVORS: Dict[str, Dict[str, str]] = {
     'json': {
         'timescaledb': 'sqlalchemy.dialects.postgresql.JSONB',
         'postgresql': 'sqlalchemy.dialects.postgresql.JSONB',
+        'postgis': 'sqlalchemy.dialects.postgresql.JSONB',
         'mariadb': 'UnicodeText',
         'mysql': 'UnicodeText',
         'mssql': 'UnicodeText',
@@ -443,6 +495,7 @@ PD_TO_SQLALCHEMY_DTYPES_FLAVORS: Dict[str, Dict[str, str]] = {
     'numeric': {
         'timescaledb': 'Numeric',
         'postgresql': 'Numeric',
+        'postgis': 'Numeric',
         'mariadb': 'Numeric',
         'mysql': 'Numeric',
         'mssql': 'Numeric',
@@ -456,6 +509,7 @@ PD_TO_SQLALCHEMY_DTYPES_FLAVORS: Dict[str, Dict[str, str]] = {
     'uuid': {
         'timescaledb': 'Uuid',
         'postgresql': 'Uuid',
+        'postgis': 'Uuid',
         'mariadb': 'sqlalchemy.dialects.mysql.CHAR(36)',
         'mysql': 'sqlalchemy.dialects.mysql.CHAR(36)',
         'mssql': 'Uuid',
@@ -469,6 +523,7 @@ PD_TO_SQLALCHEMY_DTYPES_FLAVORS: Dict[str, Dict[str, str]] = {
     'bytes': {
         'timescaledb': 'LargeBinary',
         'postgresql': 'LargeBinary',
+        'postgis': 'LargeBinary',
         'mariadb': 'LargeBinary',
         'mysql': 'LargeBinary',
         'mssql': 'LargeBinary',
@@ -479,11 +534,40 @@ PD_TO_SQLALCHEMY_DTYPES_FLAVORS: Dict[str, Dict[str, str]] = {
         'cockroachdb': 'LargeBinary',
         'default': 'LargeBinary',
     },
+    'geometry': {
+        'timescaledb': 'UnicodeText',
+        'postgresql': 'UnicodeText',
+        'postgis': 'geoalchemy2.Geometry',
+        'mariadb': 'UnicodeText',
+        'mysql': 'UnicodeText',
+        'mssql': 'UnicodeText',
+        'oracle': 'UnicodeText',
+        'sqlite': 'UnicodeText',
+        'duckdb': 'UnicodeText',
+        'citus': 'UnicodeText',
+        'cockroachdb': 'UnicodeText',
+        'default': 'UnicodeText',
+    },
+    'geography': {
+        'timescaledb': 'UnicodeText',
+        'postgresql': 'UnicodeText',
+        'postgis': 'geoalchemy2.Geography',
+        'mariadb': 'UnicodeText',
+        'mysql': 'UnicodeText',
+        'mssql': 'UnicodeText',
+        'oracle': 'UnicodeText',
+        'sqlite': 'UnicodeText',
+        'duckdb': 'UnicodeText',
+        'citus': 'UnicodeText',
+        'cockroachdb': 'UnicodeText',
+        'default': 'UnicodeText',
+    },
 }
 
 AUTO_INCREMENT_COLUMN_FLAVORS: Dict[str, str] = {
     'timescaledb': 'GENERATED BY DEFAULT AS IDENTITY',
     'postgresql': 'GENERATED BY DEFAULT AS IDENTITY',
+    'postgis': 'GENERATED BY DEFAULT AS IDENTITY',
     'mariadb': 'AUTO_INCREMENT',
     'mysql': 'AUTO_INCREMENT',
     'mssql': 'IDENTITY(1,1)',
@@ -565,7 +649,7 @@ def get_db_type_from_pd_type(
     """
     from meerschaum.utils.warnings import warn
     from meerschaum.utils.packages import attempt_import
-    from meerschaum.utils.dtypes import are_dtypes_equal, MRSM_ALIAS_DTYPES
+    from meerschaum.utils.dtypes import are_dtypes_equal, MRSM_ALIAS_DTYPES, get_geometry_type_srid
     from meerschaum.utils.misc import parse_arguments_str
     sqlalchemy_types = attempt_import('sqlalchemy.types', lazy=False)
 
@@ -576,18 +660,30 @@ def get_db_type_from_pd_type(
     )
 
     precision, scale = None, None
+    geometry_type, geometry_srid = None, None
     og_pd_type = pd_type
     if pd_type in MRSM_ALIAS_DTYPES:
         pd_type = MRSM_ALIAS_DTYPES[pd_type]
 
     ### Check whether we are able to match this type (e.g. pyarrow support).
     found_db_type = False
-    if pd_type not in types_registry and not pd_type.startswith('numeric['):
+    if (
+        pd_type not in types_registry
+        and not any(
+            pd_type.startswith(f'{typ}[')
+            for typ in ('numeric', 'geometry', 'geography')
+        )
+    ):
         for mapped_pd_type in types_registry:
             if are_dtypes_equal(mapped_pd_type, pd_type):
                 pd_type = mapped_pd_type
                 found_db_type = True
                 break
+    elif (pd_type.startswith('geometry[') or pd_type.startswith('geography[')):
+        og_pd_type = pd_type
+        pd_type = 'geometry' if 'geometry' in pd_type else 'geography'
+        geometry_type, geometry_srid = get_geometry_type_srid(og_pd_type)
+        found_db_type = True
     elif pd_type.startswith('numeric['):
         og_pd_type = pd_type
         pd_type = 'numeric'
@@ -628,6 +724,11 @@ def get_db_type_from_pd_type(
         if precision is not None and scale is not None:
             db_type_bare = db_type.split('(', maxsplit=1)[0]
             return f"{db_type_bare}({precision},{scale})"
+        if geometry_type is not None and geometry_srid is not None:
+            if 'geometry' not in db_type.lower() and 'geography' not in db_type.lower():
+                return db_type
+            db_type_bare = db_type.split('(', maxsplit=1)[0]
+            return f"{db_type_bare}({geometry_type.upper()}, {geometry_srid})"
         return db_type
 
     if db_type.startswith('sqlalchemy.dialects'):
@@ -643,6 +744,17 @@ def get_db_type_from_pd_type(
             return cls
         return cls(*cls_args, **cls_kwargs)
 
+    if 'geometry' in db_type.lower() or 'geography' in db_type.lower():
+        geoalchemy2 = attempt_import('geoalchemy2', lazy=False)
+        geometry_class = (
+            geoalchemy2.Geometry
+            if 'geometry' in db_type.lower()
+            else geoalchemy2.Geography
+        )
+        if geometry_type is None or geometry_srid is None:
+            return geometry_class
+        return geometry_class(geometry_type=geometry_type, srid=geometry_srid)
+
     if 'numeric' in db_type.lower():
         if precision is None or scale is None:
             return sqlalchemy_types.Numeric

meerschaum/utils/packages/_packages.py

@@ -136,12 +136,14 @@ packages['sql'] = {
     'numpy'                          : 'numpy>=1.18.5',
     'pandas'                         : 'pandas[parquet]>=2.0.1',
     'geopandas'                      : 'geopandas>=1.0.1', 
+    'shapely'                        : 'shapely>=2.0.7',
     'pyarrow'                        : 'pyarrow>=16.1.0',
     'dask'                           : 'dask[complete]>=2024.12.1',
     'partd'                          : 'partd>=1.4.2',
     'pytz'                           : 'pytz',
     'joblib'                         : 'joblib>=0.17.0',
     'sqlalchemy'                     : 'SQLAlchemy>=2.0.5',
+    'geoalchemy'                     : 'GeoAlchemy2>=0.17.1',
     'databases'                      : 'databases>=0.4.0',
     'aiosqlite'                      : 'aiosqlite>=0.16.0',
     'asyncpg'                        : 'asyncpg>=0.21.0',

meerschaum/utils/sql.py

@@ -41,13 +41,13 @@ version_queries = {
 }
 SKIP_IF_EXISTS_FLAVORS = {'mssql', 'oracle'}
 DROP_IF_EXISTS_FLAVORS = {
-    'timescaledb', 'postgresql', 'citus', 'mssql', 'mysql', 'mariadb', 'sqlite',
+    'timescaledb', 'postgresql', 'postgis', 'citus', 'mssql', 'mysql', 'mariadb', 'sqlite',
 }
 DROP_INDEX_IF_EXISTS_FLAVORS = {
-    'mssql', 'timescaledb', 'postgresql', 'sqlite', 'citus',
+    'mssql', 'timescaledb', 'postgresql', 'postgis', 'sqlite', 'citus',
 }
 SKIP_AUTO_INCREMENT_FLAVORS = {'citus', 'duckdb'}
-COALESCE_UNIQUE_INDEX_FLAVORS = {'timescaledb', 'postgresql', 'citus'}
+COALESCE_UNIQUE_INDEX_FLAVORS = {'timescaledb', 'postgresql', 'postgis', 'citus'}
 UPDATE_QUERIES = {
     'default': """
         UPDATE {target_table_name} AS f
@@ -73,6 +73,12 @@ UPDATE_QUERIES = {
         FROM {patch_table_name}
         ON CONFLICT ({join_cols_str}) DO {update_or_nothing} {sets_subquery_none_excluded}
     """,
+    'postgis-upsert': """
+        INSERT INTO {target_table_name} ({patch_cols_str})
+        SELECT {patch_cols_str}
+        FROM {patch_table_name}
+        ON CONFLICT ({join_cols_str}) DO {update_or_nothing} {sets_subquery_none_excluded}
+    """,
     'citus-upsert': """
         INSERT INTO {target_table_name} ({patch_cols_str})
         SELECT {patch_cols_str}
@@ -482,6 +488,7 @@ table_wrappers = {
     'citus'      : ('"', '"'),
     'duckdb'     : ('"', '"'),
     'postgresql' : ('"', '"'),
+    'postgis'    : ('"', '"'),
     'sqlite'     : ('"', '"'),
     'mysql'      : ('`', '`'),
     'mariadb'    : ('`', '`'),
@@ -494,6 +501,7 @@ max_name_lens = {
     'mssql'      : 128,
     'oracle'     : 30,
     'postgresql' : 64,
+    'postgis'    : 64,
     'timescaledb': 64,
     'citus'      : 64,
     'cockroachdb': 64,
@@ -501,10 +509,11 @@ max_name_lens = {
     'mysql'      : 64,
     'mariadb'    : 64,
 }
-json_flavors = {'postgresql', 'timescaledb', 'citus', 'cockroachdb'}
+json_flavors = {'postgresql', 'postgis', 'timescaledb', 'citus', 'cockroachdb'}
 NO_SCHEMA_FLAVORS = {'oracle', 'sqlite', 'mysql', 'mariadb', 'duckdb'}
 DEFAULT_SCHEMA_FLAVORS = {
     'postgresql': 'public',
+    'postgis': 'public',
     'timescaledb': 'public',
     'citus': 'public',
     'cockroachdb': 'public',
@@ -549,6 +558,7 @@ def dateadd_str(
         Currently supported flavors:
 
         - `'postgresql'`
+        - `'postgis'`
         - `'timescaledb'`
         - `'citus'`
         - `'cockroachdb'`
@@ -653,7 +663,7 @@ def dateadd_str(
     )
 
     da = ""
-    if flavor in ('postgresql', 'timescaledb', 'cockroachdb', 'citus'):
+    if flavor in ('postgresql', 'postgis', 'timescaledb', 'cockroachdb', 'citus'):
         begin = (
             f"CAST({begin} AS {db_type})" if begin != 'now'
             else f"CAST(NOW() AT TIME ZONE 'utc' AS {db_type})"
@@ -1809,6 +1819,8 @@ def get_null_replacement(typ: str, flavor: str) -> str:
     """
     from meerschaum.utils.dtypes import are_dtypes_equal
     from meerschaum.utils.dtypes.sql import DB_FLAVORS_CAST_DTYPES
+    if 'geometry' in typ.lower():
+        return '010100000000008058346FCDC100008058346FCDC1'
     if 'int' in typ.lower() or typ.lower() in ('numeric', 'number'):
         return '-987654321'
     if 'bool' in typ.lower() or typ.lower() == 'bit':

{meerschaum-2.9.0.dev1.dist-info → meerschaum-2.9.0rc2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: meerschaum
-Version: 2.9.0.dev1
+Version: 2.9.0rc2
 Summary: Sync Time-Series Pipes with Meerschaum
 Home-page: https://meerschaum.io
 Author: Bennett Meares
@@ -127,12 +127,14 @@ Provides-Extra: sql
 Requires-Dist: numpy>=1.18.5; extra == "sql"
 Requires-Dist: pandas[parquet]>=2.0.1; extra == "sql"
 Requires-Dist: geopandas>=1.0.1; extra == "sql"
+Requires-Dist: shapely>=2.0.7; extra == "sql"
 Requires-Dist: pyarrow>=16.1.0; extra == "sql"
 Requires-Dist: dask[complete]>=2024.12.1; extra == "sql"
 Requires-Dist: partd>=1.4.2; extra == "sql"
 Requires-Dist: pytz; extra == "sql"
 Requires-Dist: joblib>=0.17.0; extra == "sql"
 Requires-Dist: SQLAlchemy>=2.0.5; extra == "sql"
+Requires-Dist: GeoAlchemy2>=0.17.1; extra == "sql"
 Requires-Dist: databases>=0.4.0; extra == "sql"
 Requires-Dist: aiosqlite>=0.16.0; extra == "sql"
 Requires-Dist: asyncpg>=0.21.0; extra == "sql"
@@ -188,12 +190,14 @@ Requires-Dist: valkey>=6.0.0; extra == "api"
 Requires-Dist: numpy>=1.18.5; extra == "api"
 Requires-Dist: pandas[parquet]>=2.0.1; extra == "api"
 Requires-Dist: geopandas>=1.0.1; extra == "api"
+Requires-Dist: shapely>=2.0.7; extra == "api"
 Requires-Dist: pyarrow>=16.1.0; extra == "api"
 Requires-Dist: dask[complete]>=2024.12.1; extra == "api"
 Requires-Dist: partd>=1.4.2; extra == "api"
 Requires-Dist: pytz; extra == "api"
 Requires-Dist: joblib>=0.17.0; extra == "api"
 Requires-Dist: SQLAlchemy>=2.0.5; extra == "api"
+Requires-Dist: GeoAlchemy2>=0.17.1; extra == "api"
 Requires-Dist: databases>=0.4.0; extra == "api"
 Requires-Dist: aiosqlite>=0.16.0; extra == "api"
 Requires-Dist: asyncpg>=0.21.0; extra == "api"
@@ -294,12 +298,14 @@ Requires-Dist: pycparser>=2.21.0; extra == "full"
 Requires-Dist: numpy>=1.18.5; extra == "full"
 Requires-Dist: pandas[parquet]>=2.0.1; extra == "full"
 Requires-Dist: geopandas>=1.0.1; extra == "full"
+Requires-Dist: shapely>=2.0.7; extra == "full"
 Requires-Dist: pyarrow>=16.1.0; extra == "full"
 Requires-Dist: dask[complete]>=2024.12.1; extra == "full"
 Requires-Dist: partd>=1.4.2; extra == "full"
 Requires-Dist: pytz; extra == "full"
 Requires-Dist: joblib>=0.17.0; extra == "full"
 Requires-Dist: SQLAlchemy>=2.0.5; extra == "full"
+Requires-Dist: GeoAlchemy2>=0.17.1; extra == "full"
 Requires-Dist: databases>=0.4.0; extra == "full"
 Requires-Dist: aiosqlite>=0.16.0; extra == "full"
 Requires-Dist: asyncpg>=0.21.0; extra == "full"

{meerschaum-2.9.0.dev1.dist-info → meerschaum-2.9.0rc2.dist-info}/RECORD

@@ -135,7 +135,7 @@ meerschaum/api/routes/_webterm.py,sha256=S7RXV8vvaTFbmVeehh4UhyXb4NCgcsyOQzoAG7j
 meerschaum/api/tables/__init__.py,sha256=e2aNC0CdlWICTUMx1i9RauF8Pm426J0RZJbsJWv4SWo,482
 meerschaum/config/__init__.py,sha256=5ZBq71P9t3nb74r5CGvMfNuauPscfegBX-nkaAUi5C4,11541
 meerschaum/config/_dash.py,sha256=BJHl4xMrQB-YHUEU7ldEW8q_nOPoIRSOqLrfGElc6Dw,187
-meerschaum/config/_default.py,sha256=8Jd-zvL159MtyOVvzMr7v2najvC-IqiCqBB4iOTs9v4,6549
+meerschaum/config/_default.py,sha256=41onvi-NJK_agSkBnsZJwDz09accGLkH8AhkeCuIYZk,6582
 meerschaum/config/_edit.py,sha256=M9yX_SDD24gV5kWITZpy7p9AWTizJsIAGWAs3WZx-Ws,9087
 meerschaum/config/_environment.py,sha256=Vv4DLDfc2vKLbCLsMvkQDj77K4kEvHKEBmUBo-wCrgo,4419
 meerschaum/config/_formatting.py,sha256=OMuqS1EWOsj_34wSs2tOqGIWci3bTMIZ5l-uelZgsIM,6672
@@ -146,7 +146,7 @@ meerschaum/config/_preprocess.py,sha256=-AEA8m_--KivZwTQ1sWN6LTn5sio_fUr2XZ51BO6
 meerschaum/config/_read_config.py,sha256=RLC3HHi_1ndj7ITVDKLD9_uULY3caGRwSz3ATYE-ixA,15014
 meerschaum/config/_shell.py,sha256=46_m49Txc5q1rGfCgO49ca48BODx45DQJi8D0zz1R18,4245
 meerschaum/config/_sync.py,sha256=jHcWRkxd82_BgX8Xo8agsWvf7BSbv3qHLWmYl6ehp_0,4242
-meerschaum/config/_version.py,sha256=sy5oF3pXniu3CK-n6ajL2bnNRMZ4Js9kCqgkZH_UoTI,76
+meerschaum/config/_version.py,sha256=qSHUj8MxnJ9gRyXkAhkZxz2mL83tODyagATrnfHLw2c,74
 meerschaum/config/paths.py,sha256=JjibeGN3YAdSNceRwsd42aNmeUrIgM6ndzC8qZAmNI0,621
 meerschaum/config/resources/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 meerschaum/config/stack/__init__.py,sha256=2UukC0Lmk-aVL1o1qXzumqmuIrw3vu9fD7iCuz4XD4I,10544
@@ -173,15 +173,15 @@ meerschaum/connectors/api/_uri.py,sha256=HWxqGx4R1cHZ3ywy9Ro9ePbFxxusw4RLaC3hpGt
 meerschaum/connectors/api/_users.py,sha256=kzb7ENgXwQ19OJYKOuuWzx2rwVuUZCly9dTnyvVuT2Q,5275
 meerschaum/connectors/plugin/PluginConnector.py,sha256=aQ1QaB7MordCFimZqoGLb0R12PfDUN_nWks2J5mzeAs,2084
 meerschaum/connectors/plugin/__init__.py,sha256=pwF7TGY4WNz2_HaVdmK4rPQ9ZwTOEuPHgzOqsGcoXJw,198
-meerschaum/connectors/sql/_SQLConnector.py,sha256=JVTK2LdUAtgK_fg0zgHOxgJHw7X7s0SHOunBZ9b-ai8,12084
+meerschaum/connectors/sql/_SQLConnector.py,sha256=FmosRX4PKR7AAW-PgX69R_32AsA7E7preQXJf4xc3WI,12240
 meerschaum/connectors/sql/__init__.py,sha256=3cqYiDkVasn7zWdtOTAZbT4bo95AuvGOmDD2TkaAxtw,205
-meerschaum/connectors/sql/_cli.py,sha256=3wXRfPSr5mXlM6Wt8UqrBYfWvkLVZ4jTzKRUd04enCo,5116
-meerschaum/connectors/sql/_create_engine.py,sha256=h7c1nwdDWi33PBkRioPomHRT8h1DLc08EQ7INWyC_1Q,10717
+meerschaum/connectors/sql/_cli.py,sha256=smwMBxq-euAeefbdZSXGTr83cm04GVGT1WIFEftMLa4,5142
+meerschaum/connectors/sql/_create_engine.py,sha256=RRiTNNVNwE_sabeTRWrlZZoFB6jFXDfcEcXkENuo8Rc,12035
 meerschaum/connectors/sql/_fetch.py,sha256=mVe5zQo7SM9PSUU3Vjhacg4Bq1-Vttb7KkXL4p5YQdQ,12818
 meerschaum/connectors/sql/_instance.py,sha256=xCc8M0xWMzF5Tu_1uWIFivAoHey5N1ccFhN_Z7u04zk,6304
-meerschaum/connectors/sql/_pipes.py,sha256=8pp10lOYX8oVEqKHB9907Jny4nkT9fTgF8PrvhsdohI,128855
+meerschaum/connectors/sql/_pipes.py,sha256=RAE3ACk7U0-Z2jnXBFJt_laKIqA4EABxPuDApPHkTc8,129185
 meerschaum/connectors/sql/_plugins.py,sha256=OVEdZ_UHTi-x5sF-5lu2TmR9ONxddp6SwDOmFo5TpU8,8051
-meerschaum/connectors/sql/_sql.py,sha256=3hrANOId2DAoXsl8nvePnxvoXo5rtB5UfQsJK_fCY9s,42696
+meerschaum/connectors/sql/_sql.py,sha256=EziDFp9mLU-VPvFczG94ZUtGy-JmKxXB4wbLtCfkykk,43786
 meerschaum/connectors/sql/_uri.py,sha256=BFzu5pjlbL3kxLH13vHWlpKGYTPfg8wuA2j58O9NsCM,3440
 meerschaum/connectors/sql/_users.py,sha256=mRyjsUCfPV52nfTQUbpu9gMXfV_DHXNqEhw4N-lSS4Q,9954
 meerschaum/connectors/sql/tools.py,sha256=jz8huOaRCwGlYdtGfAqAh7SoK8uydYBrasKQba9FT38,187
@@ -223,7 +223,7 @@ meerschaum/plugins/__init__.py,sha256=Tl5B0Q4rIfgkPpgknJH3UKKB3fS_cAWI9TspKosvBP
 meerschaum/plugins/bootstrap.py,sha256=VwjpZAuYdqPJW0YoVgAoM_taHkdQHqP902-8T7OWWCI,11339
 meerschaum/utils/__init__.py,sha256=QrK1K9hIbPCRCM5k2nZGFqGnrqhA0Eh-iSmCU7FG6Cs,612
 meerschaum/utils/_get_pipes.py,sha256=tu4xKPoDn79Dz2kWM13cXTP4DSCkn-3G9M8KiLftopw,11073
-meerschaum/utils/dataframe.py,sha256=f9h3fmG_ePHHls2NQmGHNqUurUEZBBvpS1UR7tQgwjI,49341
+meerschaum/utils/dataframe.py,sha256=SfwFGqBTGVcA5ulWEXOV2GZ1633JPcRXxF_l6oQ7L5o,52020
 meerschaum/utils/debug.py,sha256=GyIzJmunkoPnOcZNYVQdT4Sgd-aOb5MI2VbIgATOjIQ,3695
 meerschaum/utils/interactive.py,sha256=t-6jWozXSqL7lYGDHuwiOjTgr-UKhdcg61q_eR5mikI,3196
 meerschaum/utils/misc.py,sha256=8TOQQlFyF_aYnc8tnx98lccXr9tFrdlS-ngXeOQjHHY,47407
@@ -232,7 +232,7 @@ meerschaum/utils/pool.py,sha256=vkE42af4fjrTEJTxf6Ek3xGucm1MtEkpsSEiaVzNKHs,2655
 meerschaum/utils/process.py,sha256=as0-CjG4mqFP0TydVvmAmgki6er4thS5BqUopeiq98Q,8216
 meerschaum/utils/prompt.py,sha256=qj1As1tuiL0GZTku_YOC6I5DmOU6L5otDR7DW7LA5fM,19397
 meerschaum/utils/schedule.py,sha256=Vrcd2Qs-UPVn6xBayNUIgludf0Mlb6Wrgq6ATdyhV8c,11451
-meerschaum/utils/sql.py,sha256=2p8pa3kBCE5lM6tDle5HV4AamZCgOpnKmCB6mdkiLUA,80287
+meerschaum/utils/sql.py,sha256=wOm_9bA2HRn-TGYqyiqwU3ILk3JBOH08X8e5k0TEDes,80786
 meerschaum/utils/threading.py,sha256=awjbVL_QR6G-o_9Qk85utac9cSdqkiC8tQSdERCdrG8,2814
 meerschaum/utils/typing.py,sha256=U3MC347sh1umpa3Xr1k71eADyDmk4LB6TnVCpq8dVzI,2830
 meerschaum/utils/warnings.py,sha256=n-phr3BftNNgyPnvnXC_VMSjtCvjiCZ-ewmVfcROhkc,6611
@@ -243,23 +243,23 @@ meerschaum/utils/daemon/RotatingFile.py,sha256=8_bXegBjjzNRlNEjFZ_EHU4pSaDfjXZTw
 meerschaum/utils/daemon/StdinFile.py,sha256=qdZ8E_RSOkURypwnS50mWeyWyRig1bAY9tKWMTVKajc,3307
 meerschaum/utils/daemon/__init__.py,sha256=ziRPyu_IM3l7Xd58y3Uvt0fZLoirJ9nuboFIxxult6c,8741
 meerschaum/utils/daemon/_names.py,sha256=d2ZwTxBoTAqXZkCfZ5LuX2XrkQmLNUq1OTlUqfoH5dA,4515
-meerschaum/utils/dtypes/__init__.py,sha256=O4EfRcv53NwvHYZpyP0kfJjS-I-9dUFdXUd78hoy0ZU,15492
-meerschaum/utils/dtypes/sql.py,sha256=c-3ib_NMklCAJBabGFa712o97VQnAyEyj8NRACKMo6s,22230
+meerschaum/utils/dtypes/__init__.py,sha256=nFlslv8aL_UFscWNJOwY19F5KFvXsXAR0_UX0rjF6D8,20669
+meerschaum/utils/dtypes/sql.py,sha256=MhuFT3wY8cx_o556a-oa3sKVKmAus0_O8ETbIIRlXik,26074
 meerschaum/utils/formatting/__init__.py,sha256=bA8qwBeTNIVHVQOBK682bJsKSKik1yS6xYJAoi0RErk,15528
 meerschaum/utils/formatting/_jobs.py,sha256=izsqPJhTtUkXUUtWnbXtReYsUYwulXtci3pBj72Ne64,6637
 meerschaum/utils/formatting/_pipes.py,sha256=gwl8-xCN5GYqBZJ7SkY20BebcofY0nU5X8Y4Emf5dz8,19570
 meerschaum/utils/formatting/_pprint.py,sha256=wyTmjHFnsHbxfyuytjTWzH-D42Z65GuIisQ_W6UnRPg,3096
 meerschaum/utils/formatting/_shell.py,sha256=2bFvtwNXapjl9jdlc0fg79PRWHbYVcllKiVcG5g36qI,3678
 meerschaum/utils/packages/__init__.py,sha256=TdKaj2tmN4bFwzusOfMv24P5ET7Zv73vyoOf9GOIr5E,64427
-meerschaum/utils/packages/_packages.py,sha256=_ygc4zH7z80TuxRz7ThIm8TuMtklpPWa4Yv8WoDjiSk,8928
+meerschaum/utils/packages/_packages.py,sha256=BWBJRlwWqZD4SPcM-SbVxEJ2pwclUhioSeP1ldSiYWE,9047
 meerschaum/utils/packages/lazy_loader.py,sha256=VHnph3VozH29R4JnSSBfwtA5WKZYZQFT_GeQSShCnuc,2540
 meerschaum/utils/venv/_Venv.py,sha256=gc1TCeAj-kTZbQFAT9xl1bi4HXFV5ApT0dPOJfxwr78,3748
 meerschaum/utils/venv/__init__.py,sha256=6FDfOSBsGgw2RIXvBuFEwlF5740RIHs4Qum0ekati9I,27249
-meerschaum-2.9.0.dev1.dist-info/LICENSE,sha256=jG2zQEdRNt88EgHUWPpXVWmOrOduUQRx7MnYV9YIPaw,11359
-meerschaum-2.9.0.dev1.dist-info/METADATA,sha256=xo2G8mHGjiEnAk4r3W5sfOxPGxT2TPg58zhpE7MPRPA,24639
-meerschaum-2.9.0.dev1.dist-info/NOTICE,sha256=OTA9Fcthjf5BRvWDDIcBC_xfLpeDV-RPZh3M-HQBRtQ,114
-meerschaum-2.9.0.dev1.dist-info/WHEEL,sha256=52BFRY2Up02UkjOa29eZOS2VxUrpPORXg1pkohGGUS8,91
-meerschaum-2.9.0.dev1.dist-info/entry_points.txt,sha256=5YBVzibw-0rNA_1VjB16z5GABsOGf-CDhW4yqH8C7Gc,88
-meerschaum-2.9.0.dev1.dist-info/top_level.txt,sha256=bNoSiDj0El6buocix-FRoAtJOeq1qOF5rRm2u9i7Q6A,11
-meerschaum-2.9.0.dev1.dist-info/zip-safe,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
-meerschaum-2.9.0.dev1.dist-info/RECORD,,
+meerschaum-2.9.0rc2.dist-info/LICENSE,sha256=jG2zQEdRNt88EgHUWPpXVWmOrOduUQRx7MnYV9YIPaw,11359
+meerschaum-2.9.0rc2.dist-info/METADATA,sha256=18-lm3TfFldZ0KZdp6YkgF5HDpzfPii7thoQ7ibqMuA,24930
+meerschaum-2.9.0rc2.dist-info/NOTICE,sha256=OTA9Fcthjf5BRvWDDIcBC_xfLpeDV-RPZh3M-HQBRtQ,114
+meerschaum-2.9.0rc2.dist-info/WHEEL,sha256=52BFRY2Up02UkjOa29eZOS2VxUrpPORXg1pkohGGUS8,91
+meerschaum-2.9.0rc2.dist-info/entry_points.txt,sha256=5YBVzibw-0rNA_1VjB16z5GABsOGf-CDhW4yqH8C7Gc,88
+meerschaum-2.9.0rc2.dist-info/top_level.txt,sha256=bNoSiDj0El6buocix-FRoAtJOeq1qOF5rRm2u9i7Q6A,11
+meerschaum-2.9.0rc2.dist-info/zip-safe,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+meerschaum-2.9.0rc2.dist-info/RECORD,,