meerschaum 2.2.3__py3-none-any.whl → 2.2.5__py3-none-any.whl

meerschaum/utils/daemon/FileDescriptorInterceptor.py

@@ -65,24 +65,31 @@ class FileDescriptorInterceptor:
             except BlockingIOError:
                 continue
             except OSError as e:
-                continue
+                from meerschaum.utils.warnings import warn
+                warn(f"OSError in FileDescriptorInterceptor: {e}")
+                break
 
-            first_char_is_newline = data[0] == b'\n'
-            last_char_is_newline = data[-1] == b'\n'
+            try:
+                first_char_is_newline = data[0] == b'\n'
+                last_char_is_newline = data[-1] == b'\n'
 
-            injected_str = self.injection_hook()
-            injected_bytes = injected_str.encode('utf-8')
+                injected_str = self.injection_hook()
+                injected_bytes = injected_str.encode('utf-8')
 
-            if is_first_read:
-                data = b'\n' + data
-                is_first_read = False
+                if is_first_read:
+                    data = b'\n' + data
+                    is_first_read = False
 
-            modified_data = (
-                (data[:-1].replace(b'\n', b'\n' + injected_bytes) + b'\n')
-                if last_char_is_newline
-                else data.replace(b'\n', b'\n' + injected_bytes)
-            )
-            os.write(self.new_file_descriptor, modified_data)
+                modified_data = (
+                    (data[:-1].replace(b'\n', b'\n' + injected_bytes) + b'\n')
+                    if last_char_is_newline
+                    else data.replace(b'\n', b'\n' + injected_bytes)
+                )
+                os.write(self.new_file_descriptor, modified_data)
+            except Exception as e:
+                from meerschaum.utils.warnings import warn
+                warn(f"Error in FileDescriptorInterceptor data processing: {e}")
+                break
 
 
     def stop_interception(self):

meerschaum/utils/daemon/RotatingFile.py

@@ -355,26 +355,29 @@ class RotatingFile(io.IOBase):
         As such, if data is larger than max_file_size, then the corresponding subfile
         may exceed this limit.
         """
-        self.file_path.parent.mkdir(exist_ok=True, parents=True)
-        if isinstance(data, bytes):
-            data = data.decode('utf-8')
-
-        prefix_str = self.get_timestamp_prefix_str() if self.write_timestamps else ""
-        suffix_str = "\n" if self.write_timestamps else ""
-        self.refresh_files(
-            potential_new_len = len(prefix_str + data + suffix_str),
-            start_interception = self.write_timestamps,
-        )
         try:
-            if prefix_str:
-                self._current_file_obj.write(prefix_str)
-            self._current_file_obj.write(data)
-            if suffix_str:
-                self._current_file_obj.write(suffix_str)
+            self.file_path.parent.mkdir(exist_ok=True, parents=True)
+            if isinstance(data, bytes):
+                data = data.decode('utf-8')
+
+            prefix_str = self.get_timestamp_prefix_str() if self.write_timestamps else ""
+            suffix_str = "\n" if self.write_timestamps else ""
+            self.refresh_files(
+                potential_new_len = len(prefix_str + data + suffix_str),
+                start_interception = self.write_timestamps,
+            )
+            try:
+                if prefix_str:
+                    self._current_file_obj.write(prefix_str)
+                self._current_file_obj.write(data)
+                if suffix_str:
+                    self._current_file_obj.write(suffix_str)
+            except Exception as e:
+                warn(f"Failed to write to subfile:\n{traceback.format_exc()}")
+            self.flush()
+            self.delete(unused_only=True)
         except Exception as e:
-            warn(f"Failed to write to subfile:\n{traceback.format_exc()}")
-        self.flush()
-        self.delete(unused_only=True)
+            warn(f"Unexpected error in RotatingFile.write: {e}")
 
 
     def delete(self, unused_only: bool = False) -> None:

meerschaum/utils/dataframe.py

@@ -8,13 +8,21 @@ Utility functions for working with DataFrames.
 
 from __future__ import annotations
 from datetime import datetime
+
+import meerschaum as mrsm
 from meerschaum.utils.typing import (
     Optional, Dict, Any, List, Hashable, Generator,
-    Iterator, Iterable, Union, Tuple,
+    Iterator, Iterable, Union, TYPE_CHECKING,
 )
 
+if TYPE_CHECKING:
+    pd, dask = mrsm.attempt_import('pandas', 'dask')
+
 
-def add_missing_cols_to_df(df: 'pd.DataFrame', dtypes: Dict[str, Any]) -> pd.DataFrame:
+def add_missing_cols_to_df(
+    df: 'pd.DataFrame',
+    dtypes: Dict[str, Any],
+) -> 'pd.DataFrame':
     """
     Add columns from the dtypes dictionary as null columns to a new DataFrame.
 
@@ -723,7 +731,7 @@ def get_datetime_bound_from_df(
         df: Union['pd.DataFrame', dict, list],
         datetime_column: str,
         minimum: bool = True,
-    ) -> Union[int, 'datetime.datetime', None]:
+    ) -> Union[int, datetime, None]:
     """
     Return the minimum or maximum datetime (or integer) from a DataFrame.
 
@@ -818,7 +826,7 @@ def chunksize_to_npartitions(chunksize: Optional[int]) -> int:
 
 
 def df_from_literal(
-        pipe: Optional['meerschaum.Pipe'] = None,
+        pipe: Optional[mrsm.Pipe] = None,
         literal: str = None,
         debug: bool = False
     ) -> 'pd.DataFrame':

meerschaum/utils/debug.py

@@ -93,22 +93,16 @@ def _checkpoint(
     ) -> None:
     """If the `_progress` and `_task` objects are provided, increment the task by one step.
     If `_total` is provided, update the total instead.
-
-    Parameters
-    ----------
-    _progress: Optional['rich.progress.Progress'] :
-         (Default value = None)
-    _task: Optional[int] :
-         (Default value = None)
-    _total: Optional[int] :
-         (Default value = None)
-    **kw :
-        
-
-    Returns
-    -------
-
     """
     if _progress is not None and _task is not None:
         _kw = {'total': _total} if _total is not None else {'advance': 1}
         _progress.update(_task, **_kw)
+
+
+def trace(browser: bool = True):
+    """
+    Open a web-based debugger to trace the execution of the program.
+    """
+    from meerschaum.utils.packages import attempt_import
+    heartrate = attempt_import('heartrate')
+    heartrate.trace(files=heartrate.files.all, browser=browser)

meerschaum/utils/formatting/__init__.py

@@ -10,7 +10,7 @@ from __future__ import annotations
 import platform
 import os
 import sys
-from meerschaum.utils.typing import Optional, Union, Any
+from meerschaum.utils.typing import Optional, Union, Any, Dict
 from meerschaum.utils.formatting._shell import make_header
 from meerschaum.utils.formatting._pprint import pprint
 from meerschaum.utils.formatting._pipes import (
@@ -298,6 +298,7 @@ def print_options(
         header: Optional[str] = None,
         num_cols: Optional[int] = None,
         adjust_cols: bool = True,
+        sort_options: bool = False,
         **kw
     ) -> None:
     """
@@ -339,6 +340,8 @@ def print_options(
     _options = []
     for o in options:
         _options.append(str(o))
+    if sort_options:
+        _options = sorted(_options)
     _header = f"Available {name}" if header is None else header
 
     if num_cols is None:
@@ -349,7 +352,7 @@ def print_options(
             print()
             print(make_header(_header))
         ### print actions
-        for option in sorted(_options):
+        for option in _options:
             if not nopretty:
                 print("  - ", end="")
             print(option)
@@ -385,7 +388,7 @@ def print_options(
 
     if _header is not None:
         table = Table(
-            title = '\n' + _header,
+            title = ('\n' + _header) if header else header,
             box = box.SIMPLE,
             show_header = False,
             show_footer = False,
@@ -397,13 +400,22 @@ def print_options(
     for i in range(num_cols):
         table.add_column()
 
-    chunks = iterate_chunks(
-        [Text.from_ansi(highlight_pipes(o)) for o in sorted(_options)],
-        num_cols,
-        fillvalue=''
-    )
-    for c in chunks:
-        table.add_row(*c)
+    if len(_options) < 12:
+        # If fewer than 12 items, use a single column
+        for option in _options:
+            table.add_row(Text.from_ansi(highlight_pipes(option)))
+    else:
+        # Otherwise, use multiple columns as before
+        num_rows = (len(_options) + num_cols - 1) // num_cols
+        for i in range(num_rows):
+            row = []
+            for j in range(num_cols):
+                index = i + j * num_rows
+                if index < len(_options):
+                    row.append(Text.from_ansi(highlight_pipes(_options[index])))
+                else:
+                    row.append('')
+            table.add_row(*row)
 
     get_console().print(table)
     return None
@@ -455,6 +467,7 @@ def fill_ansi(string: str, style: str = '') -> str:
 
     return rich_text_to_str(msg)
 
+
 def __getattr__(name: str) -> str:
     """
     Lazily load module-level variables.

meerschaum/utils/misc.py

@@ -6,6 +6,7 @@ Miscellaneous functions go here
 """
 
 from __future__ import annotations
+import sys
 from datetime import timedelta, datetime, timezone
 from meerschaum.utils.typing import (
     Union,
@@ -22,8 +23,11 @@ from meerschaum.utils.typing import (
     Hashable,
     Generator,
     Iterator,
+    TYPE_CHECKING,
 )
 import meerschaum as mrsm
+if TYPE_CHECKING:
+    import collections
 
 __pdoc__: Dict[str, bool] = {
     'to_pandas_dtype': False,
@@ -208,6 +212,7 @@ def parse_config_substitution(
 
     return leading_key[len(leading_key):][len():-1].split(delimeter)
 
+
 def edit_file(
         path: Union[pathlib.Path, str],
         default_editor: str = 'pyvim',
@@ -233,7 +238,6 @@ def edit_file(
     Returns
     -------
     A bool indicating the file was successfully edited.
-
     """
     import os
     from subprocess import call
@@ -254,7 +258,7 @@ def edit_file(
 
 
 def is_pipe_registered(
-        pipe: 'meerschaum.Pipe',
+        pipe: mrsm.Pipe,
         pipes: PipesDict,
         debug: bool = False
     ) -> bool:
@@ -726,25 +730,53 @@ def replace_password(d: Dict[str, Any], replace_with: str = '*') -> Dict[str, An
     return _d
 
 
+def filter_arguments(
+    func: Callable[[Any], Any],
+    *args: Any,
+    **kwargs: Any
+) -> Tuple[Tuple[Any], Dict[str, Any]]:
+    """
+    Filter out unsupported positional and keyword arguments.
+
+    Parameters
+    ----------
+    func: Callable[[Any], Any]
+        The function to inspect.
+
+    *args: Any
+        Positional arguments to filter and pass to `func`.
+
+    **kwargs
+        Keyword arguments to filter and pass to `func`.
+
+    Returns
+    -------
+    The `args` and `kwargs` accepted by `func`.
+    """
+    args = filter_positionals(func, *args)
+    kwargs = filter_keywords(func, **kwargs)
+    return args, kwargs
+
+
 def filter_keywords(
-        func: Callable[[Any], Any],
-        **kw: Any
-    ) -> Dict[str, Any]:
+    func: Callable[[Any], Any],
+    **kw: Any
+) -> Dict[str, Any]:
     """
-    Filter out unsupported keywords.
+    Filter out unsupported keyword arguments.
 
     Parameters
     ----------
     func: Callable[[Any], Any]
         The function to inspect.
-        
+
     **kw: Any
         The arguments to be filtered and passed into `func`.
 
     Returns
     -------
     A dictionary of keyword arguments accepted by `func`.
-    
+
     Examples
     --------
     ```python
@@ -766,6 +798,69 @@ def filter_keywords(
     return {k: v for k, v in kw.items() if k in func_params}
 
 
+def filter_positionals(
+    func: Callable[[Any], Any],
+    *args: Any
+) -> Tuple[Any]:
+    """
+    Filter out unsupported positional arguments.
+
+    Parameters
+    ----------
+    func: Callable[[Any], Any]
+        The function to inspect.
+
+    *args: Any
+        The arguments to be filtered and passed into `func`.
+        NOTE: If the function signature expects more arguments than provided,
+        the missing slots will be filled with `None`.
+
+    Returns
+    -------
+    A tuple of positional arguments accepted by `func`.
+
+    Examples
+    --------
+    ```python
+    >>> def foo(a, b):
+    ...     return a * b
+    >>> filter_positionals(foo, 2, 4, 6)
+    (2, 4)
+    >>> foo(*filter_positionals(foo, 2, 4, 6))
+    8
+    ```
+
+    """
+    import inspect
+    from meerschaum.utils.warnings import warn
+    func_params = inspect.signature(func).parameters
+    acceptable_args: List[Any] = []
+
+    def _warn_invalids(_num_invalid):
+        if _num_invalid > 0:
+            warn(
+                "Too few arguments were provided. "
+                + f"{_num_invalid} argument"
+                + ('s have ' if _num_invalid != 1 else " has ")
+                + " been filled with `None`.",
+            )
+
+    num_invalid: int = 0
+    for i, (param, val) in enumerate(func_params.items()):
+        if '=' in str(val) or '*' in str(val):
+            _warn_invalids(num_invalid)
+            return tuple(acceptable_args)
+
+        try:
+            acceptable_args.append(args[i])
+        except IndexError:
+            acceptable_args.append(None)
+            num_invalid += 1
+
+    _warn_invalids(num_invalid)
+    return tuple(acceptable_args)
+
+
 def dict_from_od(od: collections.OrderedDict) -> Dict[Any, Any]:
     """
     Convert an ordered dict to a dict.
@@ -974,10 +1069,11 @@ def async_wrap(func):
 def debug_trace(browser: bool = True):
     """
     Open a web-based debugger to trace the execution of the program.
+
+    This is an alias import for `meerschaum.utils.debug.debug_trace`.
     """
-    from meerschaum.utils.packages import attempt_import
-    heartrate = attempt_import('heartrate')
-    heartrate.trace(files=heartrate.files.all, browser=browser)
+    from meerschaum.utils.debug import trace
+    trace(browser=browser)
 
 
 def items_str(
@@ -1554,3 +1650,13 @@ def _get_subaction_names(*args, **kwargs) -> Any:
     """
     from meerschaum.actions import _get_subaction_names as real_function
     return real_function(*args, **kwargs)
+
+
+_current_module = sys.modules[__name__]
+__all__ = tuple(
+    name
+    for name, obj in globals().items()
+    if callable(obj)
+        and name not in __pdoc__
+        and getattr(obj, '__module__', None) == _current_module.__name__
+)

meerschaum/utils/packages/_packages.py

@@ -42,6 +42,7 @@ packages: Dict[str, Dict[str, str]] = {
         'requests'                   : 'requests>=2.23.0',
         'binaryornot'                : 'binaryornot>=0.4.4',
         'pyvim'                      : 'pyvim>=3.0.2',
+        'ptpython'                   : 'ptpython>=3.0.27',
         'aiofiles'                   : 'aiofiles>=0.6.0',
         'packaging'                  : 'packaging>=21.3.0',
         'prompt_toolkit'             : 'prompt-toolkit>=3.0.39',

meerschaum/utils/prompt.py

@@ -61,6 +61,7 @@ def prompt(
     from meerschaum.utils.formatting import colored, ANSI, CHARSET, highlight_pipes, fill_ansi
     from meerschaum.config import get_config
     from meerschaum.config.static import _static_config
+    from meerschaum.utils.misc import filter_keywords
     noask = check_noask(noask)
     if not noask:
         prompt_toolkit = attempt_import('prompt_toolkit')
@@ -101,7 +102,7 @@ def prompt(
         prompt_toolkit.prompt(
             prompt_toolkit.formatted_text.ANSI(question),
             wrap_lines = wrap_lines,
-            **kw
+            **filter_keywords(prompt_toolkit.prompt, **kw)
         ) if not noask else ''
     )
     if noask:
@@ -192,10 +193,11 @@ def yes_no(
 
 def choose(
         question: str,
-        choices: List[str],
-        default: Optional[str] = None,
+        choices: List[Union[str, Tuple[str, str]]],
+        default: Union[str, List[str], None] = None,
         numeric: bool = True,
         multiple: bool = False,
+        as_indices: bool = False,
         delimiter: str = ',',
         icon: bool = True,
         warn: bool = True,
@@ -210,10 +212,12 @@ def choose(
     question: str
         The question to be printed.
 
-    choices: List[str]
+    choices: List[Union[str, Tuple[str, str]]
         A list of options.
+        If an option is a tuple of two strings, the first string is treated as the index
+        and not displayed. In this case, set `as_indices` to `True` to return the index.
 
-    default: Optional[str], default None
+    default: Union[str, List[str], None], default None
         If the user declines to enter a choice, return this value.
 
     numeric: bool, default True
@@ -223,6 +227,11 @@ def choose(
     multiple: bool, default False
         If `True`, allow the user to choose multiple answers separated by `delimiter`.
 
+    as_indices: bool, default False
+        If `True`, return the indices for the choices.
+        If a choice is a tuple of two strings, the first is assumed to be the index.
+        Otherwise the index in the list is returned.
+
     delimiter: str, default ','
         If `multiple`, separate answers by this string. Raise a warning if this string is contained
         in any of the choices.
@@ -243,6 +252,7 @@ def choose(
     """
     from meerschaum.utils.warnings import warn as _warn
     from meerschaum.utils.packages import attempt_import
+    from meerschaum.utils.misc import print_options
     noask = check_noask(noask)
 
     ### Handle empty choices.
@@ -254,8 +264,14 @@ def choose(
     if isinstance(default, list):
         multiple = True
 
+    choices_indices = {}
+    for i, c in enumerate(choices):
+        if isinstance(c, tuple):
+            i, c = c
+        choices_indices[i] = c
+
     def _enforce_default(d):
-        if d is not None and d not in choices and warn:
+        if d is not None and d not in choices and d not in choices_indices and warn:
             _warn(
                 f"Default choice '{default}' is not contained in the choices {choices}. "
                 + "Setting numeric = False.",
@@ -271,16 +287,18 @@ def choose(
             break
 
     _default = default
-    _choices = choices
+    _choices = list(choices_indices.values())
     if multiple:
-        question += f"\n    Enter your choices, separated by '{delimiter}'."
+        question += f"\n    Enter your choices, separated by '{delimiter}'.\n"
 
     altered_choices = {}
     altered_indices = {}
     altered_default_indices = {}
     delim_replacement = '_' if delimiter != '_' else '-'
     can_strip_start_spaces, can_strip_end_spaces = True, True
-    for c in choices:
+    for i, c in choices_indices.items():
+        if isinstance(c, tuple):
+            key, c = c
         if can_strip_start_spaces and c.startswith(' '):
             can_strip_start_spaces = False
         if can_strip_end_spaces and c.endswith(' '):
@@ -301,8 +319,8 @@ def choose(
             default[i] = new_d
 
         ### Check if the choices have the delimiter.
-        for i, c in enumerate(choices):
-            if delimiter in c and warn:
+        for i, c in choices_indices.items():
+            if delimiter in c and not numeric and warn:
                 _warn(
                     f"The delimiter '{delimiter}' is contained within choice '{c}'.\n"
                     + f"Replacing the string '{delimiter}' with '{delim_replacement}' in "
@@ -313,34 +331,53 @@ def choose(
                 altered_choices[new_c] = c
                 altered_indices[i] = new_c
         for i, new_c in altered_indices.items():
-            choices[i] = new_c
+            choices_indices[i] = new_c
         default = delimiter.join(default) if isinstance(default, list) else default
 
+    question_options = []
     if numeric:
         _choices = [str(i + 1) for i, c in enumerate(choices)]
         _default = ''
         if default is not None:
             for d in (default.split(delimiter) if multiple else [default]):
+                if d not in choices and d in choices_indices:
+                    d_index = d
+                    d_value = choices_indices[d]
+                    for _i, _option in enumerate(choices):
+                        if (
+                            isinstance(_option, tuple) and (
+                                _option[1] == d_value
+                                or
+                                _option[0] == d_index
+                            )
+                        ) or d_index == _i:
+                            d = _option
+
                 _d = str(choices.index(d) + 1)
                 _default += _d + delimiter
         _default = _default[:-1 * len(delimiter)]
-        question += '\n'
+        #  question += '\n'
         choices_digits = len(str(len(choices)))
-        for i, c in enumerate(choices):
-            question += f"  {i + 1}. " + (" " * (choices_digits - len(str(i + 1)))) + f"{c}\n"
+        for i, c in enumerate(choices_indices.values()):
+            question_options.append(
+                f"  {i + 1}. "
+                + (" " * (choices_digits - len(str(i + 1))))
+                + f"{c}\n"
+            )
         default_tuple = (_default, default) if default is not None else None
     else:
         default_tuple = default
-        question += '\n'
-        for c in choices:
-            question += f"  - {c}\n"
+        #  question += '\n'
+        for c in choices_indices.values():
+            question_options.append(f"{c}\n")
 
     if 'completer' not in kw:
         WordCompleter = attempt_import('prompt_toolkit.completion').WordCompleter
-        kw['completer'] = WordCompleter(choices, sentence=True)
+        kw['completer'] = WordCompleter(choices_indices.values(), sentence=True)
 
     valid = False
     while not valid:
+        print_options(question_options, header='')
         answer = prompt(
             question,
             icon = icon,
@@ -383,7 +420,10 @@ def choose(
         if not numeric:
             return answer
         try:
-            return choices[int(answer) - 1]
+            _answer = choices[int(answer) - 1]
+            if as_indices and isinstance(choice, tuple):
+                return _answer[0]
+            return _answer
         except Exception as e:
             _warn(f"Could not cast answer '{answer}' to an integer.", stacklevel=3)
 
@@ -393,7 +433,10 @@ def choose(
     for a in answers:
         try:
             _answer = choices[int(a) - 1]
-            _answers.append(altered_choices.get(_answer, _answer))
+            _answer_to_return = altered_choices.get(_answer, _answer)
+            if isinstance(_answer_to_return, tuple) and as_indices:
+                _answer_to_return = _answer_to_return[0]
+            _answers.append(_answer_to_return)
         except Exception as e:
             _warn(f"Could not cast answer '{a}' to an integer.", stacklevel=3)
     return _answers

meerschaum/utils/typing.py

@@ -14,6 +14,7 @@ try:
         Hashable,
         Generator,
         Iterator,
+        TYPE_CHECKING,
     )
 except Exception as e:
     import urllib.request, sys, pathlib, os