meerschaum 2.9.5__py3-none-any.whl → 3.0.0rc1__py3-none-any.whl

meerschaum/utils/misc.py

@@ -7,6 +7,7 @@ Miscellaneous functions go here
 
 from __future__ import annotations
 import sys
+import functools
 from datetime import timedelta, datetime, timezone
 from meerschaum.utils.typing import (
     Union,
@@ -46,11 +47,11 @@ __pdoc__: Dict[str, bool] = {
 
 
 def add_method_to_class(
-        func: Callable[[Any], Any],
-        class_def: 'Class',
-        method_name: Optional[str] = None,
-        keep_self: Optional[bool] = None,
-    ) -> Callable[[Any], Any]:
+    func: Callable[[Any], Any],
+    class_def: 'Class',
+    method_name: Optional[str] = None,
+    keep_self: Optional[bool] = None,
+) -> Callable[[Any], Any]:
     """
     Add function `func` to class `class_def`.
 
@@ -122,16 +123,33 @@ def is_int(s: str) -> bool:
 
     """
     try:
-        float(s)
+        return float(s).is_integer()
     except Exception:
         return False
-    
-    return float(s).is_integer()
 
 
-def string_to_dict(
-    params_string: str
-) -> Dict[str, Any]:
+def is_uuid(s: str) -> bool:
+    """
+    Check if a string is a valid UUID.
+
+    Parameters
+    ----------
+    s: str
+        The string to be checked.
+
+    Returns
+    -------
+    A bool indicating whether the string is a valid UUID.
+    """
+    import uuid
+    try:
+        uuid.UUID(str(s))
+        return True
+    except Exception:
+        return False
+
+
+def string_to_dict(params_string: str) -> Dict[str, Any]:
     """
     Parse a string into a dictionary.
     
@@ -154,7 +172,7 @@ def string_to_dict(
     {'a': 1, 'b': 2}
 
     """
-    if params_string == "":
+    if not params_string:
         return {}
 
     import json
@@ -169,13 +187,60 @@ def string_to_dict(
         and params_string[-2] == "}"
     ):
         return json.loads(params_string[1:-1])
+
     if str(params_string).startswith('{'):
         return json.loads(params_string)
 
     import ast
     params_dict = {}
-    for param in params_string.split(","):
+    
+    items = []
+    bracket_level = 0
+    brace_level = 0
+    current_item = ''
+    in_quotes = False
+    quote_char = ''
+    
+    i = 0
+    while i < len(params_string):
+        char = params_string[i]
+        
+        if in_quotes:
+            if char == quote_char and (i == 0 or params_string[i-1] != '\\'):
+                in_quotes = False
+        else:
+            if char in ('"', "'"):
+                in_quotes = True
+                quote_char = char
+            elif char == '[':
+                bracket_level += 1
+            elif char == ']':
+                bracket_level -= 1
+            elif char == '{':
+                brace_level += 1
+            elif char == '}':
+                brace_level -= 1
+            elif char == ',' and bracket_level == 0 and brace_level == 0:
+                items.append(current_item)
+                current_item = ''
+                i += 1
+                continue
+        
+        current_item += char
+        i += 1
+        
+    if current_item:
+        items.append(current_item)
+
+    for param in items:
+        param = param.strip()
+        if not param:
+            continue
+
         _keys = param.split(":", maxsplit=1)
+        if len(_keys) != 2:
+            continue
+
         keys = _keys[:-1]
         try:
             val = ast.literal_eval(_keys[-1])
@@ -197,12 +262,35 @@ def string_to_dict(
     return params_dict
 
 
+def to_simple_dict(doc: Dict[str, Any]) -> str:
+    """
+    Serialize a document dictionary in simple-dict format.
+    """
+    import json
+    import ast
+    from meerschaum.utils.dtypes import json_serialize_value
+
+    def serialize_value(value):
+        if isinstance(value, str):
+            try:
+                evaluated = ast.literal_eval(value)
+                if not isinstance(evaluated, str):
+                    return json.dumps(value, separators=(',', ':'), default=json_serialize_value)
+                return value
+            except (ValueError, SyntaxError, TypeError, MemoryError):
+                return value
+        
+        return json.dumps(value, separators=(',', ':'), default=json_serialize_value)
+
+    return ','.join(f"{key}:{serialize_value(val)}" for key, val in doc.items())
+
+
 def parse_config_substitution(
     value: str,
     leading_key: str = 'MRSM',
     begin_key: str = '{',
     end_key: str = '}',
-    delimeter: str = ':'
+    delimeter: str = ':',
 ) -> List[Any]:
     """
     Parse Meerschaum substitution syntax
@@ -311,7 +399,7 @@ def get_cols_lines(default_cols: int = 100, default_lines: int = 120) -> Tuple[i
     try:
         size = os.get_terminal_size()
         _cols, _lines = size.columns, size.lines
-    except Exception as e:
+    except Exception:
         _cols, _lines = (
             int(os.environ.get('COLUMNS', str(default_cols))),
             int(os.environ.get('LINES', str(default_lines))),
@@ -367,7 +455,7 @@ def sorted_dict(d: Dict[Any, Any]) -> Dict[Any, Any]:
     """
     try:
         return {key: value for key, value in sorted(d.items(), key=lambda item: item[1])}
-    except Exception as e:
+    except Exception:
         return d
 
 def flatten_pipes_dict(pipes_dict: PipesDict) -> List[Pipe]:
@@ -460,12 +548,12 @@ def round_time(
 
 
 def timed_input(
-        seconds: int = 10,
-        timeout_message: str = "",
-        prompt: str = "",
-        icon: bool = False,
-        **kw
-    ) -> Union[str, None]:
+    seconds: int = 10,
+    timeout_message: str = "",
+    prompt: str = "",
+    icon: bool = False,
+    **kw
+) -> Union[str, None]:
     """
     Accept user input only for a brief period of time.
 
@@ -515,52 +603,6 @@ def timed_input(
         signal.alarm(0) # cancel alarm
 
 
-
-
-
-def replace_pipes_in_dict(
-        pipes : Optional[PipesDict] = None,
-        func: 'function' = str,
-        debug: bool = False,
-        **kw
-    ) -> PipesDict:
-    """
-    Replace the Pipes in a Pipes dict with the result of another function.
-
-    Parameters
-    ----------
-    pipes: Optional[PipesDict], default None
-        The pipes dict to be processed.
-
-    func: Callable[[Any], Any], default str
-        The function to be applied to every pipe.
-        Defaults to the string constructor.
-
-    debug: bool, default False
-        Verbosity toggle.
-    
-
-    Returns
-    -------
-    A dictionary where every pipe is replaced with the output of a function.
-
-    """
-    import copy
-    def change_dict(d : Dict[Any, Any], func : 'function') -> None:
-        for k, v in d.items():
-            if isinstance(v, dict):
-                change_dict(v, func)
-            else:
-                d[k] = func(v)
-
-    if pipes is None:
-        from meerschaum import get_pipes
-        pipes = get_pipes(debug=debug, **kw)
-
-    result = copy.deepcopy(pipes)
-    change_dict(result, func)
-    return result
-
 def enforce_gevent_monkey_patch():
     """
     Check if gevent monkey patching is enabled, and if not, then apply patching.
@@ -634,10 +676,10 @@ def string_width(string: str, widest: bool = True) -> int:
     return _widest()
 
 def _pyinstaller_traverse_dir(
-        directory: str,
-        ignore_patterns: Iterable[str] = ('.pyc', 'dist', 'build', '.git', '.log'),
-        include_dotfiles: bool = False
-    ) -> list:
+    directory: str,
+    ignore_patterns: Iterable[str] = ('.pyc', 'dist', 'build', '.git', '.log'),
+    include_dotfiles: bool = False
+) -> list:
     """
     Recursively traverse a directory and return a list of its contents.
     """
@@ -677,6 +719,43 @@ def _pyinstaller_traverse_dir(
     return paths
 
 
+def get_val_from_dict_path(d: Dict[Any, Any], path: Tuple[Any, ...]) -> Any:
+    """
+    Get a value from a dictionary with a tuple of keys.
+
+    Parameters
+    ----------
+    d: Dict[Any, Any]
+        The dictionary to search.
+
+    path: Tuple[Any, ...]
+        The path of keys to traverse.
+
+    Returns
+    -------
+    The value from the end of the path.
+    """
+    return functools.reduce(lambda di, key: di[key], path, d)
+
+
+def set_val_in_dict_path(d: Dict[Any, Any], path: Tuple[Any, ...], val: Any) -> None:
+    """
+    Set a value in a dictionary with a tuple of keys.
+
+    Parameters
+    ----------
+    d: Dict[Any, Any]
+        The dictionary to search.
+
+    path: Tuple[Any, ...]
+        The path of keys to traverse.
+
+    val: Any
+        The value to set at the end of the path.
+    """
+    get_val_from_dict_path(d, path[:-1])[path[-1]] = val
+
+
 def replace_password(d: Dict[str, Any], replace_with: str = '*') -> Dict[str, Any]:
     """
     Recursively replace passwords in a dictionary.
@@ -717,7 +796,7 @@ def replace_password(d: Dict[str, Any], replace_with: str = '*') -> Dict[str, An
             from meerschaum.connectors.sql import SQLConnector
             try:
                 uri_params = SQLConnector.parse_uri(v)
-            except Exception as e:
+            except Exception:
                 uri_params = None
             if not uri_params:
                 continue
@@ -877,6 +956,7 @@ def dict_from_od(od: collections.OrderedDict) -> Dict[Any, Any]:
             _d[k] = dict_from_od(v)
     return _d
 
+
 def remove_ansi(s: str) -> str:
     """
     Remove ANSI escape characters from a string.
@@ -1153,7 +1233,7 @@ def items_str(
     return output
 
 
-def interval_str(delta: Union[timedelta, int]) -> str:
+def interval_str(delta: Union[timedelta, int], round_unit: bool = False) -> str:
     """
     Return a human-readable string for a `timedelta` (or `int` minutes).
 
@@ -1162,20 +1242,57 @@ def interval_str(delta: Union[timedelta, int]) -> str:
     delta: Union[timedelta, int]
         The interval to print. If `delta` is an integer, assume it corresponds to minutes.
 
+    round_unit: bool, default False
+        If `True`, round the output to a single unit.
+
     Returns
     -------
     A formatted string, fit for human eyes.
     """
     from meerschaum.utils.packages import attempt_import
-    if is_int(delta):
+    if is_int(str(delta)) and not round_unit:
         return str(delta)
-    humanfriendly = attempt_import('humanfriendly')
+
+    humanfriendly = attempt_import('humanfriendly', lazy=False)
     delta_seconds = (
         delta.total_seconds()
-        if isinstance(delta, timedelta)
+        if hasattr(delta, 'total_seconds')
         else (delta * 60)
     )
-    return humanfriendly.format_timespan(delta_seconds)
+
+    is_negative = delta_seconds < 0
+    delta_seconds = abs(delta_seconds)
+    replace_units = {}
+
+    if round_unit:
+        if delta_seconds < 1:
+            delta_seconds = round(delta_seconds, 2)
+        elif delta_seconds < 60:
+            delta_seconds = int(delta_seconds)
+        elif delta_seconds < 3600:
+            delta_seconds = int(delta_seconds / 60) * 60
+        elif delta_seconds < 86400:
+            delta_seconds = int(delta_seconds / 3600) * 3600
+        elif delta_seconds < (86400 * 7):
+            delta_seconds = int(delta_seconds / 86400) * 86400
+        elif delta_seconds < (86400 * 7 * 4):
+            delta_seconds = int(delta_seconds / (86400 * 7)) * (86400 * 7)
+        elif delta_seconds < (86400 * 7 * 4 * 13):
+            delta_seconds = int(delta_seconds / (86400 * 7 * 4)) * (86400 * 7)
+            replace_units['weeks'] = 'months'
+        else:
+            delta_seconds = int(delta_seconds / (86400 * 364)) * (86400 * 364)
+
+    delta_str = humanfriendly.format_timespan(delta_seconds)
+    if ',' in delta_str and round_unit:
+        delta_str = delta_str.split(',')[0]
+    elif ' and ' in delta_str and round_unit:
+        delta_str = delta_str.split(' and ')[0]
+
+    for parsed_unit, replacement_unit in replace_units.items():
+        delta_str = delta_str.replace(parsed_unit, replacement_unit)
+
+    return delta_str + (' ago' if is_negative else '')
 
 
 def is_docker_available() -> bool:
@@ -1406,7 +1523,7 @@ def separate_negation_values(
         If `None`, use the system default (`_`).
     """
     if negation_prefix is None:
-        from meerschaum.config.static import STATIC_CONFIG
+        from meerschaum._internal.static import STATIC_CONFIG
         negation_prefix = STATIC_CONFIG['system']['fetch_pipes_keys']['negation_prefix']
     _in_vals, _ex_vals = [], []
     for v in vals:
@@ -1442,7 +1559,7 @@ def get_in_ex_params(params: Optional[Dict[str, Any]]) -> Dict[str, Tuple[List[A
         col: separate_negation_values(
             (
                 val
-                if isinstance(val, (list, tuple))
+                if isinstance(val, (list, tuple, set)) or hasattr(val, 'astype')
                 else [val]
             )
         )
@@ -1610,6 +1727,36 @@ def safely_extract_tar(tarf: 'file', output_dir: Union[str, 'pathlib.Path']) ->
     return safe_extract(tarf, output_dir)
 
 
+def to_snake_case(name: str) -> str:
+    """
+    Return the given string in snake-case-style.
+
+    Parameters
+    ----------
+    name: str
+        The input text to convert to snake case.
+
+    Returns
+    -------
+    A snake-case version of `name`.
+
+    Examples
+    --------
+    >>> to_snake_case("HelloWorld!")
+    'hello_world'
+    >>> to_snake_case("This has spaces in it.")
+    'this_has_spaces_in_it'
+    >>> to_snake_case("already_in_snake_case")
+    'already_in_snake_case'
+    """
+    import re
+    name = re.sub(r'(.)([A-Z][a-z]+)', r'\1_\2', name)
+    name = re.sub(r'([a-z0-9])([A-Z])', r'\1_\2', name)
+    name = re.sub(r'[^\w\s]', '', name)
+    name = re.sub(r'\s+', '_', name)
+    return name.lower()
+
+
 ##################
 # Legacy imports #
 ##################
@@ -1756,6 +1903,15 @@ def json_serialize_datetime(dt: datetime) -> Union[str, None]:
     return serialize_datetime(dt)
 
 
+def replace_pipes_in_dict(*args, **kwargs):
+    """
+    Placeholder function to prevent breaking legacy behavior.
+    See `meerschaum.utils.pipes.replace_pipes_in_dict`.
+    """
+    from meerschaum.utils.pipes import replace_pipes_in_dict
+    return replace_pipes_in_dict(*args, **kwargs)
+
+
 _current_module = sys.modules[__name__]
 __all__ = tuple(
     name
@@ -1763,4 +1919,5 @@ __all__ = tuple(
     if callable(obj)
         and name not in __pdoc__
         and getattr(obj, '__module__', None) == _current_module.__name__
+        and not name.startswith('_')
 )

meerschaum/utils/packages/__init__.py

@@ -755,7 +755,7 @@ def get_pip(
     import subprocess
     from meerschaum.utils.misc import wget
     from meerschaum.config._paths import CACHE_RESOURCES_PATH
-    from meerschaum.config.static import STATIC_CONFIG
+    from meerschaum._internal.static import STATIC_CONFIG
     url = STATIC_CONFIG['system']['urls']['get-pip.py']
     dest = CACHE_RESOURCES_PATH / 'get-pip.py'
     try:
@@ -837,7 +837,7 @@ def pip_install(
 
     """
     from meerschaum.config._paths import VIRTENV_RESOURCES_PATH
-    from meerschaum.config.static import STATIC_CONFIG
+    from meerschaum._internal.static import STATIC_CONFIG
     from meerschaum.utils.warnings import warn
     if args is None:
         args = ['--upgrade'] if not _uninstall else []
@@ -1500,15 +1500,12 @@ def import_pandas(
 def import_rich(
     lazy: bool = True,
     debug: bool = False,
-    **kw : Any
+    **kw: Any
 ) -> 'ModuleType':
     """
     Quality of life function for importing `rich`.
     """
     from meerschaum.utils.formatting import ANSI, UNICODE
-    if not ANSI and not UNICODE:
-        return None
-
     ## need typing_extensions for `from rich import box`
     typing_extensions = attempt_import(
         'typing_extensions', lazy=False, debug=debug

meerschaum/utils/packages/_packages.py

@@ -54,23 +54,25 @@ packages: Dict[str, Dict[str, str]] = {
         'virtualenv'                 : 'virtualenv>=20.1.0',
         'attrs'                      : 'attrs>=24.2.0',
         'uv'                         : 'uv>=0.2.11',
+        'pydantic'                   : 'pydantic>=2.11.7',
+        'annotated-types'            : 'annotated-types>=0.7.0',
     },
     '_internal'                      : {
         'apscheduler'                : (
                                        f"{_MRSM_PACKAGE_ARCHIVES_PREFIX}"
-                                       "APScheduler-4.0.0a5.post87+mrsm-py3-none-any.whl>=4.0.0a5"
+                                       "apscheduler-4.0.0a6.post8+mrsm-py3-none-any.whl>=4.0.0a6"
         ),
-        'dataclass_wizard'           : 'dataclass-wizard>=0.28.0',
+        'dataclass_wizard'           : 'dataclass-wizard>=0.35.0',
     },
     'jobs': {
-        'dill'                       : 'dill>=0.3.3',
-        'daemon'                     : 'python-daemon>=0.2.3',
-        'watchfiles'                 : 'watchfiles>=0.21.0',
-        'psutil'                     : 'psutil>=5.8.0',
+        'dill'                       : 'dill>=0.4.0',
+        'daemon'                     : 'python-daemon>=3.1.2',
+        'watchfiles'                 : 'watchfiles>=1.1.0',
+        'psutil'                     : 'psutil>=7.0.0',
     },
     'drivers': {
         'cryptography'               : 'cryptography>=38.0.1',
-        'psycopg'                    : 'psycopg[binary]>=3.2.1',
+        'psycopg'                    : 'psycopg[binary]>=3.2.9',
         'pymysql'                    : 'PyMySQL>=0.9.0',
         'aiomysql'                   : 'aiomysql>=0.0.21',
         'sqlalchemy_cockroachdb'     : 'sqlalchemy-cockroachdb>=2.0.0',
@@ -122,7 +124,7 @@ packages: Dict[str, Dict[str, str]] = {
         'mkdocs_section_index'       : 'mkdocs-section-index>=0.3.3',
         'mkdocs_linkcheck'           : 'mkdocs-linkcheck>=1.0.6',
         'mkdocs_redirects'           : 'mkdocs-redirects>=1.0.4',
-        'jinja2'                     : 'jinja2==3.0.3',
+        'jinja2'                     : 'jinja2>=3.1.6',
     },
     'gui': {
         'webview'                    : 'pywebview>=3.6.3',
@@ -137,43 +139,43 @@ packages: Dict[str, Dict[str, str]] = {
     },
 }
 packages['sql'] = {
-    'numpy'                          : 'numpy>=1.18.5',
-    'pandas'                         : 'pandas[parquet]>=2.0.1',
-    'pyarrow'                        : 'pyarrow>=16.1.0',
+    'numpy'                          : 'numpy>=2.3.1',
+    'pandas'                         : 'pandas[parquet]>=2.3.1',
+    'pyarrow'                        : 'pyarrow>=20.0.0',
     'dask'                           : 'dask[complete]>=2024.12.1',
     'partd'                          : 'partd>=1.4.2',
     'pytz'                           : 'pytz',
-    'joblib'                         : 'joblib>=0.17.0',
-    'sqlalchemy'                     : 'SQLAlchemy>=2.0.5',
+    'joblib'                         : 'joblib>=1.5.1',
+    'sqlalchemy'                     : 'SQLAlchemy>=2.0.41',
     'geoalchemy'                     : 'GeoAlchemy2>=0.17.1',
-    'databases'                      : 'databases>=0.4.0',
-    'aiosqlite'                      : 'aiosqlite>=0.16.0',
-    'asyncpg'                        : 'asyncpg>=0.21.0',
+    'databases'                      : 'databases>=0.9.0',
+    'aiosqlite'                      : 'aiosqlite>=0.21.0',
+    'asyncpg'                        : 'asyncpg>=0.30.0',
 }
 packages['sql'].update(packages['drivers'])
 packages['sql'].update(packages['core'])
 packages['sql'].update(packages['gis'])
 packages['dash'] = {
-    'flask_compress'                 : 'Flask-Compress>=1.10.1',
-    'dash'                           : 'dash>=2.6.2',
+    'flask_compress'                 : 'Flask-Compress>=1.17.0',
+    'dash'                           : 'dash>=3.1.1',
     'dash_bootstrap_components'      : 'dash-bootstrap-components>=1.7.1',
     'dash_ace'                       : 'dash-ace>=0.2.1',
-    'dash_extensions'                : 'dash-extensions>=1.0.4',
-    'dash_daq'                       : 'dash-daq>=0.5.0',
-    'terminado'                      : 'terminado>=0.12.1',
-    'tornado'                        : 'tornado>=6.1.0',
+    'dash_extensions'                : 'dash-extensions>=2.0.4',
+    'dash_daq'                       : 'dash-daq>=0.6.0',
+    'terminado'                      : 'terminado>=0.18.1',
+    'tornado'                        : 'tornado>=6.5.1',
 }
 packages['api'] = {
-    'uvicorn'                        : 'uvicorn[standard]>=0.29.0',
-    'gunicorn'                       : 'gunicorn>=22.0.0',
-    'dotenv'                         : 'python-dotenv>=0.20.0',
-    'websockets'                     : 'websockets>=11.0.3',
-    'fastapi'                        : 'fastapi>=0.111.0',
-    'fastapi_login'                  : 'fastapi-login>=1.7.2',
-    'multipart'                      : 'python-multipart>=0.0.9',
-    'httpx'                          : 'httpx>=0.27.2',
-    'httpcore'                       : 'httpcore>=1.0.6',
-    'valkey'                         : 'valkey>=6.0.0',
+    'uvicorn'                        : 'uvicorn[standard]>=0.35.0',
+    'gunicorn'                       : 'gunicorn>=23.0.0',
+    'dotenv'                         : 'python-dotenv>=1.1.1',
+    'websockets'                     : 'websockets>=15.0.1',
+    'fastapi'                        : 'fastapi>=0.116.0',
+    'fastapi_login'                  : 'fastapi-login>=1.10.3',
+    'multipart'                      : 'python-multipart>=0.0.20',
+    'httpx'                          : 'httpx>=0.28.1',
+    'httpcore'                       : 'httpcore>=1.0.9',
+    'valkey'                         : 'valkey>=6.1.0',
 }
 packages['api'].update(packages['sql'])
 packages['api'].update(packages['formatting'])