meerschaum 2.4.5__py3-none-any.whl → 2.4.7__py3-none-any.whl

meerschaum/utils/dataframe.py

@@ -138,12 +138,14 @@ def filter_unseen_df(
     import functools
     import traceback
     from decimal import Decimal
+    from uuid import UUID
     from meerschaum.utils.warnings import warn
     from meerschaum.utils.packages import import_pandas, attempt_import
     from meerschaum.utils.dtypes import (
         to_pandas_dtype,
         are_dtypes_equal,
         attempt_cast_to_numeric,
+        attempt_cast_to_uuid,
         coerce_timezone,
     )
     pd = import_pandas(debug=debug)
@@ -299,6 +301,18 @@ def filter_unseen_df(
             lambda x: f'{x:f}' if isinstance(x, Decimal) else x
         )
 
+    old_uuid_cols = get_uuid_cols(old_df)
+    new_uuid_cols = get_uuid_cols(new_df)
+    uuid_cols = set(new_uuid_cols + old_uuid_cols)
+    for uuid_col in old_uuid_cols:
+        old_df[uuid_col] = old_df[uuid_col].apply(
+            lambda x: f'{x}' if isinstance(x, UUID) else x
+        )
+    for uuid_col in new_uuid_cols:
+        new_df[uuid_col] = new_df[uuid_col].apply(
+            lambda x: f'{x}' if isinstance(x, UUID) else x
+        )
+
     joined_df = merge(
         new_df.fillna(NA),
         old_df.fillna(NA),
@@ -326,6 +340,14 @@ def filter_unseen_df(
         except Exception:
             warn(f"Unable to parse numeric column '{numeric_col}':\n{traceback.format_exc()}")
 
+    for uuid_col in uuid_cols:
+        if uuid_col not in delta_df.columns:
+            continue
+        try:
+            delta_df[uuid_col] = delta_df[uuid_col].apply(attempt_cast_to_uuid)
+        except Exception:
+            warn(f"Unable to parse numeric column '{uuid_col}':\n{traceback.format_exc()}")
+
     return delta_df
 
 
@@ -575,7 +597,7 @@ def get_numeric_cols(df: 'pd.DataFrame') -> List[str]:
     is_dask = 'dask' in df.__module__
     if is_dask:
         df = get_first_valid_dask_partition(df)
-    
+
     if len(df) == 0:
         return []
 
@@ -594,6 +616,42 @@ def get_numeric_cols(df: 'pd.DataFrame') -> List[str]:
     ]
 
 
+def get_uuid_cols(df: 'pd.DataFrame') -> List[str]:
+    """
+    Get the columns which contain `decimal.Decimal` objects from a Pandas DataFrame.
+
+    Parameters
+    ----------
+    df: pd.DataFrame
+        The DataFrame which may contain decimal objects.
+
+    Returns
+    -------
+    A list of columns to treat as numerics.
+    """
+    from uuid import UUID
+    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
+            isinstance(df.loc[ix][col], UUID)
+        )
+    ]
+
+
 def enforce_dtypes(
     df: 'pd.DataFrame',
     dtypes: Dict[str, str],
@@ -640,11 +698,11 @@ def enforce_dtypes(
         to_pandas_dtype,
         is_dtype_numeric,
         attempt_cast_to_numeric,
+        attempt_cast_to_uuid,
     )
     if safe_copy:
         df = df.copy()
-    df_dtypes = {c: str(t) for c, t in df.dtypes.items()}
-    if len(df_dtypes) == 0:
+    if len(df.columns) == 0:
         if debug:
             dprint("Incoming DataFrame has no columns. Skipping enforcement...")
         return df
@@ -663,12 +721,17 @@ def enforce_dtypes(
         for col, typ in dtypes.items()
         if typ == 'numeric'
     ]
+    uuid_cols = [
+        col
+        for col, typ in dtypes.items()
+        if typ == 'uuid'
+    ]
     df_numeric_cols = get_numeric_cols(df)
     if debug:
         dprint("Desired data types:")
         pprint(dtypes)
         dprint("Data types for incoming DataFrame:")
-        pprint(df_dtypes)
+        pprint({_col: str(_typ) for _col, _typ in df.dtypes.items()})
 
     if json_cols and len(df) > 0:
         if debug:
@@ -700,9 +763,21 @@ def enforce_dtypes(
                     if debug:
                         dprint(f"Unable to parse column '{col}' as NUMERIC:\n{e}")
 
+    if uuid_cols:
+        if debug:
+            dprint(f"Checking for UUIDs: {uuid_cols}")
+        for col in uuid_cols:
+            if col in df.columns:
+                try:
+                    df[col] = df[col].apply(attempt_cast_to_uuid)
+                except Exception as e:
+                    if debug:
+                        dprint(f"Unable to parse column '{col}' as UUID:\n{e}")
+
+    df_dtypes = {c: str(t) for c, t in df.dtypes.items()}
     if are_dtypes_equal(df_dtypes, pipe_pandas_dtypes):
         if debug:
-            dprint(f"Data types match. Exiting enforcement...")
+            dprint("Data types match. Exiting enforcement...")
         return df
 
     common_dtypes = {}
@@ -714,7 +789,7 @@ def enforce_dtypes(
                 common_diff_dtypes[col] = df_dtypes[col]
 
     if debug:
-        dprint(f"Common columns with different dtypes:")
+        dprint("Common columns with different dtypes:")
         pprint(common_diff_dtypes)
 
     detected_dt_cols = {}
@@ -726,7 +801,7 @@ def enforce_dtypes(
         del common_diff_dtypes[col]
 
     if debug:
-        dprint(f"Common columns with different dtypes (after dates):")
+        dprint("Common columns with different dtypes (after dates):")
         pprint(common_diff_dtypes)
 
     if are_dtypes_equal(df_dtypes, pipe_pandas_dtypes):
@@ -1231,5 +1306,49 @@ def query_df(
 
     _process_select_columns(result_df)
     _process_omit_columns(result_df)
-    
+
     return result_df
+
+
+def to_json(
+    df: 'pd.DataFrame',
+    safe_copy: bool = True,
+    orient: str = 'records',
+    date_format: str = 'iso',
+    date_unit: str = 'us',
+    **kwargs: Any
+) -> str:
+    """
+    Serialize the given dataframe as a JSON string.
+
+    Parameters
+    ----------
+    df: pd.DataFrame
+        The DataFrame to be serialized.
+
+    safe_copy: bool, default True
+        If `False`, modify the DataFrame inplace.
+
+    date_format: str, default 'iso'
+        The default format for timestamps.
+
+    date_unit: str, default 'us'
+        The precision of the timestamps.
+
+    Returns
+    -------
+    A JSON string.
+    """
+    from meerschaum.utils.packages import import_pandas
+    pd = import_pandas()
+    uuid_cols = get_uuid_cols(df)
+    if uuid_cols and safe_copy:
+        df = df.copy()
+    for col in uuid_cols:
+        df[col] = df[col].astype(str)
+    return df.fillna(pd.NA).to_json(
+        date_format=date_format,
+        date_unit=date_unit,
+        orient=orient,
+        **kwargs
+    )

meerschaum/utils/dtypes/__init__.py

@@ -7,6 +7,7 @@ Utility functions for working with data types.
 """
 
 import traceback
+import uuid
 from datetime import timezone
 from decimal import Decimal, Context, InvalidOperation
 
@@ -17,6 +18,7 @@ from meerschaum.utils.warnings import warn
 MRSM_PD_DTYPES: Dict[str, str] = {
     'json': 'object',
     'numeric': 'object',
+    'uuid': 'object',
     'datetime': 'datetime64[ns]',
     'bool': 'bool[pyarrow]',
     'int': 'Int64',
@@ -51,8 +53,8 @@ def to_pandas_dtype(dtype: str) -> str:
         warn(
             f"Invalid dtype '{dtype}', will use 'object' instead:\n"
             + f"{traceback.format_exc()}",
-            stack = False,
-        ) 
+            stack=False,
+        )
     return 'object'
 
 
@@ -109,8 +111,12 @@ def are_dtypes_equal(
     if ldtype in numeric_dtypes and rdtype in numeric_dtypes:
         return True
 
-    ldtype_clean = ldtype.split('[')[0]
-    rdtype_clean = rdtype.split('[')[0]
+    uuid_dtypes = ('uuid', 'object')
+    if ldtype in uuid_dtypes and rdtype in uuid_dtypes:
+        return True
+
+    ldtype_clean = ldtype.split('[', maxsplit=1)[0]
+    rdtype_clean = rdtype.split('[', maxsplit=1)[0]
 
     if ldtype_clean.lower() == rdtype_clean.lower():
         return True
@@ -183,6 +189,22 @@ def attempt_cast_to_numeric(value: Any) -> Any:
         return value
 
 
+def attempt_cast_to_uuid(value: Any) -> Any:
+    """
+    Given a value, attempt to coerce it into a UUID (`uuid4`).
+    """
+    if isinstance(value, uuid.UUID):
+        return value
+    try:
+        return (
+            uuid.UUID(str(value))
+            if not value_is_null(value)
+            else None
+        )
+    except Exception as e:
+        return value
+
+
 def value_is_null(value: Any) -> bool:
     """
     Determine if a value is a null-like string.

meerschaum/utils/dtypes/sql.py

@@ -55,6 +55,7 @@ DB_FLAVORS_CAST_DTYPES = {
         'NVARCHAR COLLATE "SQL_Latin1_General_CP1_CI_AS"': 'NVARCHAR(MAX)',
         'VARCHAR COLLATE "SQL Latin1 General CP1 CI AS"': 'NVARCHAR(MAX)',
         'VARCHAR COLLATE "SQL_Latin1_General_CP1_CI_AS"': 'NVARCHAR(MAX)',
+        'NVARCHAR': 'NVARCHAR(MAX)',
     },
 }
 for _flavor, (_precision, _scale) in NUMERIC_PRECISION_FLAVORS.items():
@@ -92,6 +93,8 @@ DB_TO_PD_DTYPES: Dict[str, Union[str, Dict[str, str]]] = {
     'BIT(1)': 'bool[pyarrow]',
     'JSON': 'json',
     'JSONB': 'json',
+    'UUID': 'uuid',
+    'UNIQUEIDENTIFIER': 'uuid',
     'substrings': {
         'CHAR': 'string[pyarrow]',
         'TIMESTAMP': 'datetime64[ns]',
@@ -239,6 +242,20 @@ PD_TO_DB_DTYPES_FLAVORS: Dict[str, Dict[str, str]] = {
         'cockroachdb': 'NUMERIC',
         'default': 'NUMERIC',
     },
+    'uuid': {
+        'timescaledb': 'UUID',
+        'postgresql': 'UUID',
+        'mariadb': 'CHAR(32)',
+        'mysql': 'CHAR(32)',
+        'mssql': 'UNIQUEIDENTIFIER',
+        ### I know this is too much space, but erring on the side of caution.
+        'oracle': 'NVARCHAR(2000)',
+        'sqlite': 'TEXT',
+        'duckdb': 'UUID',
+        'citus': 'UUID',
+        'cockroachdb': 'UUID',
+        'default': 'TEXT',
+    },
 }
 PD_TO_SQLALCHEMY_DTYPES_FLAVORS: Dict[str, Dict[str, str]] = {
     'int': {
@@ -358,6 +375,19 @@ PD_TO_SQLALCHEMY_DTYPES_FLAVORS: Dict[str, Dict[str, str]] = {
         'cockroachdb': 'Numeric',
         'default': 'Numeric',
     },
+    'uuid': {
+        'timescaledb': 'Uuid',
+        'postgresql': 'Uuid',
+        'mariadb': 'Uuid',
+        'mysql': 'Uuid',
+        'mssql': 'Uuid',
+        'oracle': 'UnicodeText',
+        'sqlite': 'Uuid',
+        'duckdb': 'Uuid',
+        'citus': 'Uuid',
+        'cockroachdb': 'Uuid',
+        'default': 'Uuid',
+    },
 }
 
 

meerschaum/utils/misc.py

@@ -959,7 +959,7 @@ def get_connector_labels(
 def json_serialize_datetime(dt: datetime) -> Union[str, None]:
     """
     Serialize a datetime object into JSON (ISO format string).
-    
+
     Examples
     --------
     >>> import json

meerschaum/utils/sql.py

@@ -107,6 +107,16 @@ update_queries = {
             UPDATE
             {sets_subquery_none};
     """,
+    'mssql-upsert': """
+        MERGE {target_table_name} f
+            USING (SELECT DISTINCT {patch_cols_str} FROM {patch_table_name}) p
+            ON {and_subquery_f}
+            AND {date_bounds_subquery}
+        {when_matched_update_sets_subquery_none}
+        WHEN NOT MATCHED THEN
+            INSERT ({patch_cols_str})
+            VALUES ({patch_cols_prefixed_str});
+    """,
     'oracle': """
         MERGE INTO {target_table_name} f
             USING (SELECT DISTINCT {patch_cols_str} FROM {patch_table_name}) p
@@ -172,8 +182,9 @@ columns_types_queries = {
             TABLE_NAME AS [table],
             COLUMN_NAME AS [column],
             DATA_TYPE AS [type]
-        FROM INFORMATION_SCHEMA.COLUMNS 
-        WHERE TABLE_NAME IN ('{table}', '{table_trunc}')
+        FROM {db_prefix}INFORMATION_SCHEMA.COLUMNS
+        WHERE TABLE_NAME LIKE '{table}%'
+            OR TABLE_NAME LIKE '{table_trunc}%'
     """,
     'mysql': """
         SELECT
@@ -182,7 +193,7 @@ columns_types_queries = {
             TABLE_NAME `table`,
             COLUMN_NAME `column`,
             DATA_TYPE `type`
-        FROM INFORMATION_SCHEMA.COLUMNS 
+        FROM INFORMATION_SCHEMA.COLUMNS
         WHERE TABLE_NAME IN ('{table}', '{table_trunc}')
     """,
     'mariadb': """
@@ -192,7 +203,7 @@ columns_types_queries = {
             TABLE_NAME `table`,
             COLUMN_NAME `column`,
             DATA_TYPE `type`
-        FROM INFORMATION_SCHEMA.COLUMNS 
+        FROM INFORMATION_SCHEMA.COLUMNS
         WHERE TABLE_NAME IN ('{table}', '{table_trunc}')
     """,
     'oracle': """
@@ -273,11 +284,11 @@ def clean(substring: str) -> str:
 
 
 def dateadd_str(
-        flavor: str = 'postgresql',
-        datepart: str = 'day',
-        number: Union[int, float] = 0,
-        begin: Union[str, datetime, int] = 'now'
-    ) -> str:
+    flavor: str = 'postgresql',
+    datepart: str = 'day',
+    number: Union[int, float] = 0,
+    begin: Union[str, datetime, int] = 'now'
+) -> str:
     """
     Generate a `DATEADD` clause depending on database flavor.
 
@@ -843,17 +854,17 @@ def get_sqlalchemy_table(
 
 
 def get_table_cols_types(
-        table: str,
-        connectable: Union[
-            'mrsm.connectors.sql.SQLConnector',
-            'sqlalchemy.orm.session.Session',
-            'sqlalchemy.engine.base.Engine'
-        ],
-        flavor: Optional[str] = None,
-        schema: Optional[str] = None,
-        database: Optional[str] = None,
-        debug: bool = False,
-    ) -> Dict[str, str]:
+    table: str,
+    connectable: Union[
+        'mrsm.connectors.sql.SQLConnector',
+        'sqlalchemy.orm.session.Session',
+        'sqlalchemy.engine.base.Engine'
+    ],
+    flavor: Optional[str] = None,
+    schema: Optional[str] = None,
+    database: Optional[str] = None,
+    debug: bool = False,
+) -> Dict[str, str]:
     """
     Return a dictionary mapping a table's columns to data types.
     This is useful for inspecting tables creating during a not-yet-committed session.
@@ -889,13 +900,12 @@ def get_table_cols_types(
     A dictionary mapping column names to data types.
     """
     from meerschaum.connectors import SQLConnector
-    from meerschaum.utils.misc import filter_keywords
     sqlalchemy = mrsm.attempt_import('sqlalchemy')
     flavor = flavor or getattr(connectable, 'flavor', None)
     if not flavor:
-        raise ValueError(f"Please provide a database flavor.")
+        raise ValueError("Please provide a database flavor.")
     if flavor == 'duckdb' and not isinstance(connectable, SQLConnector):
-        raise ValueError(f"You must provide a SQLConnector when using DuckDB.")
+        raise ValueError("You must provide a SQLConnector when using DuckDB.")
     if flavor in NO_SCHEMA_FLAVORS:
         schema = None
     if schema is None:
@@ -907,18 +917,24 @@ def get_table_cols_types(
     table_upper = table.upper()
     table_lower_trunc = truncate_item_name(table_lower, flavor=flavor)
     table_upper_trunc = truncate_item_name(table_upper, flavor=flavor)
+    db_prefix = (
+        "tempdb."
+        if flavor == 'mssql' and table.startswith('#')
+        else ""
+    )
 
     cols_types_query = sqlalchemy.text(
         columns_types_queries.get(
             flavor,
             columns_types_queries['default']
         ).format(
-            table = table,
-            table_trunc = table_trunc,
-            table_lower = table_lower,
-            table_lower_trunc = table_lower_trunc,
-            table_upper = table_upper,
-            table_upper_trunc = table_upper_trunc,
+            table=table,
+            table_trunc=table_trunc,
+            table_lower=table_lower,
+            table_lower_trunc=table_lower_trunc,
+            table_upper=table_upper,
+            table_upper_trunc=table_upper_trunc,
+            db_prefix=db_prefix,
         )
     )
 
@@ -987,20 +1003,20 @@ def get_table_cols_types(
 
 
 def get_update_queries(
-        target: str,
-        patch: str,
-        connectable: Union[
-            mrsm.connectors.sql.SQLConnector,
-            'sqlalchemy.orm.session.Session'
-        ],
-        join_cols: Iterable[str],
-        flavor: Optional[str] = None,
-        upsert: bool = False,
-        datetime_col: Optional[str] = None,
-        schema: Optional[str] = None,
-        patch_schema: Optional[str] = None,
-        debug: bool = False,
-    ) -> List[str]:
+    target: str,
+    patch: str,
+    connectable: Union[
+        mrsm.connectors.sql.SQLConnector,
+        'sqlalchemy.orm.session.Session'
+    ],
+    join_cols: Iterable[str],
+    flavor: Optional[str] = None,
+    upsert: bool = False,
+    datetime_col: Optional[str] = None,
+    schema: Optional[str] = None,
+    patch_schema: Optional[str] = None,
+    debug: bool = False,
+) -> List[str]:
     """
     Build a list of `MERGE`, `UPDATE`, `DELETE`/`INSERT` queries to apply a patch to target table.
 
@@ -1067,16 +1083,16 @@ def get_update_queries(
     target_table_columns = get_table_cols_types(
         target,
         connectable,
-        flavor = flavor,
-        schema = schema,
-        debug = debug,
+        flavor=flavor,
+        schema=schema,
+        debug=debug,
     )
     patch_table_columns = get_table_cols_types(
         patch,
         connectable,
-        flavor = flavor,
-        schema = patch_schema,
-        debug = debug,
+        flavor=flavor,
+        schema=patch_schema,
+        debug=debug,
     )
 
     patch_cols_str = ', '.join(
@@ -1085,6 +1101,13 @@ def get_update_queries(
             for col in patch_table_columns
         ]
     )
+    patch_cols_prefixed_str = ', '.join(
+        [
+            'p.' + sql_item_name(col, flavor)
+            for col in patch_table_columns
+        ]
+    )
+
     join_cols_str = ', '.join(
         [
             sql_item_name(col, flavor)
@@ -1095,7 +1118,7 @@ def get_update_queries(
     value_cols = []
     join_cols_types = []
     if debug:
-        dprint(f"target_table_columns:")
+        dprint("target_table_columns:")
         mrsm.pprint(target_table_columns)
     for c_name, c_type in target_table_columns.items():
         if c_name not in patch_table_columns:
@@ -1156,7 +1179,7 @@ def get_update_queries(
                 + ' = '
                 + "COALESCE("
                 + r_prefix
-                + sql_item_name(c_name, flavor, None) 
+                + sql_item_name(c_name, flavor, None)
                 + ", "
                 + get_null_replacement(c_type, flavor)
                 + ")"
@@ -1175,20 +1198,28 @@ def get_update_queries(
         else "1 = 1"
     )
 
+    ### NOTE: MSSQL upserts must exclude the update portion if only upserting indices.
+    when_matched_update_sets_subquery_none = "" if not value_cols else (
+        "WHEN MATCHED THEN"
+        f"     UPDATE {sets_subquery('', 'p.')}"
+    )
+
     return [
         base_query.format(
-            sets_subquery_none = sets_subquery('', 'p.'),
-            sets_subquery_none_excluded = sets_subquery('', 'EXCLUDED.'),
-            sets_subquery_f = sets_subquery('f.', 'p.'),
-            and_subquery_f = and_subquery('p.', 'f.'),
-            and_subquery_t = and_subquery('p.', 't.'),
-            target_table_name = target_table_name,
-            patch_table_name = patch_table_name,
-            patch_cols_str = patch_cols_str,
-            date_bounds_subquery = date_bounds_subquery,
-            join_cols_str = join_cols_str,
-            coalesce_join_cols_str = coalesce_join_cols_str,
-            update_or_nothing = update_or_nothing,
+            sets_subquery_none=sets_subquery('', 'p.'),
+            sets_subquery_none_excluded=sets_subquery('', 'EXCLUDED.'),
+            sets_subquery_f=sets_subquery('f.', 'p.'),
+            and_subquery_f=and_subquery('p.', 'f.'),
+            and_subquery_t=and_subquery('p.', 't.'),
+            target_table_name=target_table_name,
+            patch_table_name=patch_table_name,
+            patch_cols_str=patch_cols_str,
+            patch_cols_prefixed_str=patch_cols_prefixed_str,
+            date_bounds_subquery=date_bounds_subquery,
+            join_cols_str=join_cols_str,
+            coalesce_join_cols_str=coalesce_join_cols_str,
+            update_or_nothing=update_or_nothing,
+            when_matched_update_sets_subquery_none=when_matched_update_sets_subquery_none,
         )
         for base_query in base_queries
     ]
@@ -1232,6 +1263,11 @@ def get_null_replacement(typ: str, flavor: str) -> str:
         return dateadd_str(flavor=flavor, begin='1900-01-01')
     if 'float' in typ.lower() or 'double' in typ.lower() or typ.lower() in ('decimal',):
         return '-987654321.0'
+    if typ.lower() in ('uniqueidentifier', 'guid', 'uuid'):
+        magic_val = 'DEADBEEF-ABBA-BABE-CAFE-DECAFC0FFEE5'
+        if flavor == 'mssql':
+            return f"CAST('{magic_val}' AS UNIQUEIDENTIFIER)"
+        return f"'{magic_val}'"
     return ('n' if flavor == 'oracle' else '') + "'-987654321'"
 
 
@@ -1443,7 +1479,7 @@ def session_execute(
     successes, msgs, results = [], [], []
     for query in queries:
         query_text = sqlalchemy.text(query)
-        fail_msg = f"Failed to execute queries."
+        fail_msg = "Failed to execute queries."
         try:
             result = session.execute(query_text)
             query_success = result is not None

meerschaum/utils/yaml.py

@@ -61,7 +61,6 @@ class yaml:
             _yaml.add_representer(str, _string_presenter)
             _yaml.representer.SafeRepresenter.add_representer(str, _string_presenter)
 
-
     @staticmethod
     def safe_load(*args, **kw):
         """
@@ -71,7 +70,6 @@ class yaml:
             return _yaml.load(*args, **filter_keywords(_yaml.load, **kw))
         return _yaml.safe_load(*args, **filter_keywords(_yaml.safe_load, **kw))
 
-
     @staticmethod
     def load(*args, **kw):
         """
@@ -80,15 +78,14 @@ class yaml:
         (added `yaml.Loader` as a positional argument).
         """
         packaging_version = attempt_import('packaging.version')
-        _args = list(args)
         if (
             _import_name == 'yaml'
             and packaging_version.parse(_yaml.__version__) >= packaging_version.parse('6.0')
+            and 'Loader' not in kw
         ):
-            _args += [_yaml.Loader]
-        
-        return _yaml.load(*_args, **filter_keywords(_yaml.load, **kw))
+            kw['Loader'] = _yaml.Loader
 
+        return _yaml.load(*args, **filter_keywords(_yaml.load, **kw))
 
     @staticmethod
     def dump(data, stream=None, **kw):

{meerschaum-2.4.5.dist-info → meerschaum-2.4.7.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: meerschaum
-Version: 2.4.5
+Version: 2.4.7
 Summary: Sync Time-Series Pipes with Meerschaum
 Home-page: https://meerschaum.io
 Author: Bennett Meares