meerschaum 2.2.5.dev2__py3-none-any.whl → 2.2.6__py3-none-any.whl

meerschaum/api/__init__.py

@@ -237,4 +237,3 @@ for module_name, functions_list in _api_plugins.items():
                 + f"when executing function '{function.__name__}' with exception:\n{e}",
                 stack=False,
             )
-

meerschaum/api/dash/__init__.py

@@ -50,7 +50,6 @@ stylesheets = [
     '/static/css/bootstrap.min.css',
     '/static/css/dbc_dark.css',
     '/static/css/dash.css',
-    #  '/static/js/node_modules/xterm/css/xterm.css',
 ]
 scripts = ['/static/js/node_modules/xterm/lib/xterm.js']
 dash_app = enrich.DashProxy(

meerschaum/api/dash/callbacks/custom.py

@@ -21,7 +21,7 @@ def init_dash_plugins():
         for _function in _functions:
             try:
                 _function(dash_app)
-            except Exception as e:
+            except Exception:
                 warn(
                     f"Failed to load function '{_function.__name__}' "
                     + f"from plugin '{_module_name}':\n"

meerschaum/api/dash/callbacks/login.py

@@ -17,6 +17,7 @@ from dash.dependencies import Input, Output, State
 from meerschaum.api.dash import dash_app, debug, pipes, _get_pipes, active_sessions
 from meerschaum.api.dash.connectors import get_web_connector
 from meerschaum.api.routes._login import login
+from meerschaum.api.dash.components import alert_from_success_tuple
 from fastapi_login.exceptions import InvalidCredentialsException
 from fastapi.exceptions import HTTPException
 dbc = attempt_import('dash_bootstrap_components', lazy=False, check_update=CHECK_UPDATE)
@@ -39,6 +40,7 @@ def show_registration_disabled_collapse(n_clicks, is_open):
     Output('session-store', 'data'),
     Output('username-input', 'className'),
     Output('location', 'pathname'),
+    Output('login-alert-div', 'children'),
     Input('username-input', 'n_submit'),
     Input('password-input', 'n_submit'),
     Input('login-button', 'n_clicks'),
@@ -48,14 +50,14 @@ def show_registration_disabled_collapse(n_clicks, is_open):
     State('location', 'pathname'),
 )
 def login_button_click(
-        username_submit,
-        password_submit,
-        n_clicks,
-        username,
-        password,
-        location_href,
-        location_pathname,
-    ):
+    username_submit,
+    password_submit,
+    n_clicks,
+    username,
+    password,
+    location_href,
+    location_pathname,
+):
     """
     When the user submits the login form, check the login.
     On successful login, set the session id.
@@ -63,12 +65,18 @@ def login_button_click(
     form_class = 'form-control'
     ctx = dash.callback_context
     if not username or not password or not ctx.triggered:
-        return {}, form_class, dash.no_update
+        raise PreventUpdate
+
     try:
-        token_dict = login({'username': username, 'password': password})
-        session_data = {'session-id': str(uuid.uuid4()), 'location.href': location_href}
+        _ = login({'username': username, 'password': password})
+        session_data = {
+            'session-id': str(uuid.uuid4()),
+            'location.href': location_href,
+        }
         active_sessions[session_data['session-id']] = {'username': username}
+        alerts = []
     except HTTPException:
         form_class += ' is-invalid'
-        session_data = None
-    return session_data, form_class, dash.no_update
+        session_data = dash.no_update
+        alerts = alert_from_success_tuple((False, "Invalid login."))
+    return session_data, form_class, dash.no_update, alerts

meerschaum/api/dash/pages/login.py

@@ -31,7 +31,7 @@ registration_div = html.Div(
         else [
             dcc.Markdown("""
                 #### **Web registration is disabled for security.**
-                You can still register users on this instance with a SQL connector.
+                You can register users via the CLI with `mrsm register user`.
             """),
             dbc.Button(
                 'More information.',
@@ -80,6 +80,7 @@ layout = dbc.Container([
     html.Br(),
     dbc.Container([
         dcc.Location(id='location-login', refresh=True),
+        html.Div(id="login-alert-div"),
         html.Div([
             dbc.Container(
                 html.Img(
@@ -129,4 +130,3 @@ layout = dbc.Container([
         ]),
     ], className='jumbotron')
 ])
-

meerschaum/api/dash/plugins.py

@@ -7,7 +7,7 @@ Functions for interacting with plugins via the web interface.
 """
 
 from __future__ import annotations
-from meerschaum.utils.typing import List, Tuple, SuccessTuple
+from meerschaum.utils.typing import List, Tuple, SuccessTuple, Optional, WebState, Dict, Any
 from meerschaum.utils.packages import import_dcc, import_html
 from meerschaum.api import get_api_connector, endpoints, CHECK_UPDATE
 html, dcc = import_html(check_update=CHECK_UPDATE), import_dcc(check_update=CHECK_UPDATE)
@@ -17,10 +17,10 @@ from meerschaum.api.dash import dash_app, debug, active_sessions
 
 
 def get_plugins_cards(
-        state: Optional[WebState] = None,
-        search_term: Optional[str] = None,
-        session_data: Optional[Dict[str, Any]] = None,
-    ) -> Tuple[List[dbc.Card], List[SuccessTuple]]:
+    state: Optional[WebState] = None,
+    search_term: Optional[str] = None,
+    session_data: Optional[Dict[str, Any]] = None,
+) -> Tuple[List[dbc.Card], List[SuccessTuple]]:
     """
     Return the cards and alerts for plugins.
     """
@@ -96,4 +96,3 @@ def is_plugin_owner(plugin_name: str, session_data: Dict['str', Any]) -> bool:
         _username is not None
         and _username == _plugin_username
     )
-

meerschaum/api/routes/_login.py

@@ -32,16 +32,16 @@ def load_user(
 
 
 @app.post(endpoints['login'], tags=['Users'])
-async def login(
+def login(
         data: CustomOAuth2PasswordRequestForm = fastapi.Depends()
-        #  data: dict[str, str],
-        #  request: Request
     ) -> Dict[str, Any]:
     """
     Login and set the session token.
     """
     username, password = (
-        (data.username, data.password)
+        (data['username'], data['password'])
+        if isinstance(data, dict)
+        else (data.username, data.password)
     ) if not no_auth else ('no-auth', 'no-auth')
 
     user = User(username, password)
@@ -62,7 +62,7 @@ async def login(
     return {
         'access_token': access_token,
         'token_type': 'bearer',
-        'expires' : expires_dt,
+        'expires': expires_dt,
     }
 
 

meerschaum/config/__init__.py

@@ -26,7 +26,14 @@ from meerschaum.config._paths import (
 from meerschaum.config._patch import (
     apply_patch_to_config,
 )
-__all__ = ('get_plugin_config', 'write_plugin_config', 'get_config', 'write_config', 'set_config',)
+__all__ = (
+    'get_plugin_config',
+    'write_plugin_config',
+    'get_config',
+    'write_config',
+    'set_config',
+    'paths',
+)
 __pdoc__ = {'static': False, 'resources': False, 'stack': False, }
 _locks = {'config': RLock()}
 

meerschaum/config/_paths.py

@@ -34,12 +34,29 @@ if ENVIRONMENT_ROOT_DIR in os.environ:
             f"Invalid root directory '{str(_ROOT_DIR_PATH)}' set for " +
             f"environment variable '{ENVIRONMENT_ROOT_DIR}'.\n" +
             f"Please enter a valid path for {ENVIRONMENT_ROOT_DIR}.",
-            file = sys.stderr,
+            file=sys.stderr,
         )
         sys.exit(1)
 else:
     _ROOT_DIR_PATH = DEFAULT_ROOT_DIR_PATH
 
+
+ENVIRONMENT_CONFIG_DIR = STATIC_CONFIG['environment']['config_dir']
+if ENVIRONMENT_CONFIG_DIR in os.environ:
+    _CONFIG_DIR_PATH = Path(os.environ[ENVIRONMENT_CONFIG_DIR]).resolve()
+    if not _CONFIG_DIR_PATH.exists():
+        print(
+            (
+                f"Invalid configuration directory '{_CONFIG_DIR_PATH}' set"
+                + f" for environment variable '{ENVIRONMENT_CONFIG_DIR}'\n"
+                + f"Please enter a valid path for {ENVIRONMENT_CONFIG_DIR}."
+            ),
+            file=sys.stderr,
+        )
+        sys.exit(1)
+else:
+    _CONFIG_DIR_PATH = _ROOT_DIR_PATH / 'config'
+
 ENVIRONMENT_PLUGINS_DIR = STATIC_CONFIG['environment']['plugins']
 if ENVIRONMENT_PLUGINS_DIR in os.environ:
     try:
@@ -100,7 +117,7 @@ paths = {
     'PACKAGE_ROOT_PATH'              : Path(__file__).parent.parent.resolve().as_posix(),
     'ROOT_DIR_PATH'                  : _ROOT_DIR_PATH.as_posix(),
     'VIRTENV_RESOURCES_PATH'         : _VENVS_DIR_PATH.as_posix(),
-    'CONFIG_DIR_PATH'                : ('{ROOT_DIR_PATH}', 'config'),
+    'CONFIG_DIR_PATH'                : _CONFIG_DIR_PATH.as_posix(),
     'DEFAULT_CONFIG_DIR_PATH'        : ('{ROOT_DIR_PATH}', 'default_config'),
     'PATCH_DIR_PATH'                 : ('{ROOT_DIR_PATH}', 'patch_config'),
     'PERMANENT_PATCH_DIR_PATH'       : ('{ROOT_DIR_PATH}', 'permanent_patch_config'),
@@ -168,6 +185,7 @@ def set_root(root: Union[Path, str]):
         if isinstance(path_parts, tuple) and path_parts[0] == '{ROOT_DIR_PATH}':
             globals()[path_name] = __getattr__(path_name)
 
+
 def __getattr__(name: str) -> Path:
     if name not in paths:
         if name not in globals():

meerschaum/config/_version.py

@@ -2,4 +2,4 @@
 Specify the Meerschaum release version.
 """
 
-__version__ = "2.2.5.dev2"
+__version__ = "2.2.6"

meerschaum/config/paths.py

@@ -6,5 +6,24 @@
 External API for importing Meerschaum paths.
 """
 
-from meerschaum.config._paths import __getattr__, paths
-__all__ = tuple(paths.keys())
+import pathlib
+import inspect
+import meerschaum.config._paths as _paths
+
+
+def __getattr__(*args, **kwargs):
+    return _paths.__getattr__(*args, **kwargs)
+
+
+_globals_dict = inspect.getmembers(
+    _paths,
+    lambda member: not inspect.isroutine(member)
+)
+_all_caps_globals = [
+    name
+    for name, value in _globals_dict
+    if ('PATH' in name or 'FILE' in name) and not name.startswith('_')
+    and isinstance(value, pathlib.Path)
+]
+
+__all__ = tuple(_all_caps_globals + list(_paths.paths.keys()))

meerschaum/config/static/__init__.py

@@ -46,6 +46,7 @@ STATIC_CONFIG: Dict[str, Any] = {
     },
     'environment': {
         'config': 'MRSM_CONFIG',
+        'config_dir': 'MRSM_CONFIG_DIR',
         'patch': 'MRSM_PATCH',
         'root': 'MRSM_ROOT_DIR',
         'plugins': 'MRSM_PLUGINS_DIR',

meerschaum/connectors/Connector.py

@@ -18,7 +18,7 @@ class InvalidAttributesError(Exception):
 
 class Connector(metaclass=abc.ABCMeta):
     """
-    The base connector class to hold connection attributes,
+    The base connector class to hold connection attributes.
     """
     def __init__(
             self,
@@ -27,6 +27,8 @@ class Connector(metaclass=abc.ABCMeta):
             **kw: Any
         ):
         """
+        Set the given keyword arguments as attributes.
+
         Parameters
         ----------
         type: str
@@ -35,9 +37,12 @@ class Connector(metaclass=abc.ABCMeta):
         label: str
             The `label` for the connector.
 
+
+        Examples
+        --------
         Run `mrsm edit config` and to edit connectors in the YAML file:
 
-        ```
+        ```yaml
         meerschaum:
             connections:
                 {type}:

meerschaum/connectors/__init__.py

@@ -24,6 +24,7 @@ from meerschaum.connectors.api.APIConnector import APIConnector
 from meerschaum.connectors.sql._create_engine import flavor_configs as sql_flavor_configs
 
 __all__ = (
+    "make_connector",
     "Connector",
     "SQLConnector",
     "APIConnector",
@@ -290,13 +291,14 @@ def make_connector(
     --------
     >>> import meerschaum as mrsm
     >>> from meerschaum.connectors import make_connector, Connector
+    >>> 
+    >>> @make_connector
     >>> class FooConnector(Connector):
-    ...     def __init__(self, label: str, **kw):
-    ...         super().__init__('foo', label, **kw)
+    ...     REQUIRED_ATTRIBUTES: list[str] = ['username', 'password']
     ... 
-    >>> make_connector(FooConnector)
-    >>> mrsm.get_connector('foo', 'bar')
-    foo:bar
+    >>> conn = mrsm.get_connector('foo:bar', username='dog', password='cat')
+    >>> print(conn.username, conn.password)
+    dog cat
     >>> 
     """
     import re

meerschaum/connectors/api/APIConnector.py

@@ -83,12 +83,16 @@ class APIConnector(Connector):
         if 'uri' in kw:
             from_uri_params = self.from_uri(kw['uri'], as_dict=True)
             label = label or from_uri_params.get('label', None)
-            from_uri_params.pop('label', None)
+            _ = from_uri_params.pop('label', None)
             kw.update(from_uri_params)
 
         super().__init__('api', label=label, **kw)
         if 'protocol' not in self.__dict__:
-            self.protocol = 'http'
+            self.protocol = (
+                'https' if self.__dict__.get('uri', '').startswith('https')
+                else 'http'
+            )
+
         if 'uri' not in self.__dict__:
             self.verify_attributes(required_attributes)
         else:
@@ -97,6 +101,7 @@ class APIConnector(Connector):
             if 'host' not in conn_attrs:
                 raise Exception(f"Invalid URI for '{self}'.")
             self.__dict__.update(conn_attrs)
+
         self.url = (
             self.protocol + '://' +
             self.host

meerschaum/connectors/api/_actions.py

@@ -9,44 +9,31 @@ Functions to interact with /mrsm/actions
 from __future__ import annotations
 from meerschaum.utils.typing import SuccessTuple, Optional, List
 
-def get_actions(
-        self,
-    ) -> list:
-    """Get available actions from the API server"""
+def get_actions(self) -> list:
+    """Get available actions from the API instance."""
     from meerschaum.config.static import STATIC_CONFIG
     return self.get(STATIC_CONFIG['api']['endpoints']['actions'])
 
 
 def do_action(
-        self,
-        action: Optional[List[str]] = None,
-        sysargs: Optional[List[str]] = None,
-        debug: bool = False,
-        **kw
-    ) -> SuccessTuple:
+    self,
+    action: Optional[List[str]] = None,
+    sysargs: Optional[List[str]] = None,
+    debug: bool = False,
+    **kw
+) -> SuccessTuple:
     """Execute a Meerschaum action remotely.
-    
-    If sysargs is provided, parse those instead. Otherwise infer everything from keyword arguments.
-    
-    NOTE: The first index of `action` should NOT be removed!
-    Example: action = ['show', 'config']
-    
-    Returns: tuple (succeeded : bool, message : str)
 
-    Parameters
-    ----------
-    action: Optional[List[str]] :
-         (Default value = None)
-    sysargs: Optional[List[str]] :
-         (Default value = None)
-    debug: bool :
-         (Default value = False)
-    **kw :
-        
-
-    Returns
-    -------
+    If `sysargs` are provided, parse those instead.
+    Otherwise infer everything from keyword arguments.
 
+    Examples
+    --------
+    >>> conn = mrsm.get_connector('api:main')
+    >>> conn.do_action(['show', 'pipes'])
+    (True, "Success")
+    >>> conn.do_action(['show', 'arguments'], name='test')
+    (True, "Success")
     """
     import sys, json
     from meerschaum.utils.debug import dprint
@@ -63,7 +50,12 @@ def do_action(
     else:
         json_dict = kw
         json_dict['action'] = action
-        json_dict['debug'] = debug
+        if 'noask' not in kw:
+            json_dict['noask'] = True
+        if 'yes' not in kw:
+            json_dict['yes'] = True
+        if debug:
+            json_dict['debug'] = debug
 
     root_action = json_dict['action'][0]
     del json_dict['action'][0]

meerschaum/connectors/api/_uri.py

@@ -11,11 +11,11 @@ from meerschaum.utils.warnings import warn, error
 
 @classmethod
 def from_uri(
-        cls,
-        uri: str,
-        label: Optional[str] = None,
-        as_dict: bool = False,
-    ) -> Union[
+    cls,
+    uri: str,
+    label: Optional[str] = None,
+    as_dict: bool = False,
+) -> Union[
         'meerschaum.connectors.APIConnector',
         Dict[str, Union[str, int]],
     ]:

meerschaum/core/Pipe/__init__.py

@@ -50,6 +50,7 @@ with correct credentials, as well as a network connection and valid permissions.
 """
 
 from __future__ import annotations
+import sys
 import copy
 from meerschaum.utils.typing import Optional, Dict, Any, Union, InstanceConnector, List
 from meerschaum.utils.formatting._pipes import pipe_repr
@@ -433,13 +434,16 @@ class Pipe:
             + str(self.instance_keys) + sep
         )
 
-    def __repr__(self, **kw) -> str:
-        return pipe_repr(self, **kw)
+    def __repr__(self, ansi: bool=True, **kw) -> str:
+        if not hasattr(sys, 'ps1'):
+            ansi = False
+
+        return pipe_repr(self, ansi=ansi, **kw)
 
     def __pt_repr__(self):
         from meerschaum.utils.packages import attempt_import
         prompt_toolkit_formatted_text = attempt_import('prompt_toolkit.formatted_text', lazy=False)
-        return prompt_toolkit_formatted_text.ANSI(self.__repr__())
+        return prompt_toolkit_formatted_text.ANSI(pipe_repr(self, ansi=True))
 
     def __getstate__(self) -> Dict[str, Any]:
         """

meerschaum/core/Pipe/_data.py

@@ -8,24 +8,32 @@ Retrieve Pipes' data from instances.
 
 from __future__ import annotations
 from datetime import datetime, timedelta
-from meerschaum.utils.typing import Optional, Dict, Any, Union, Generator, List, Tuple, Iterator
+
+import meerschaum as mrsm
+from meerschaum.utils.typing import (
+    Optional, Dict, Any, Union, List, Tuple, Iterator, TYPE_CHECKING,
+)
 from meerschaum.config import get_config
 
+if TYPE_CHECKING:
+    pd = mrsm.attempt_import('pandas')
+
+
 def get_data(
-        self,
-        select_columns: Optional[List[str]] = None,
-        omit_columns: Optional[List[str]] = None,
-        begin: Union[datetime, int, None] = None,
-        end: Union[datetime, int, None] = None,
-        params: Optional[Dict[str, Any]] = None,
-        as_iterator: bool = False,
-        as_chunks: bool = False,
-        as_dask: bool = False,
-        chunk_interval: Union[timedelta, int, None] = None,
-        fresh: bool = False,
-        debug: bool = False,
-        **kw: Any
-    ) -> Union['pd.DataFrame', Generator['pd.DataFrame'], None]:
+    self,
+    select_columns: Optional[List[str]] = None,
+    omit_columns: Optional[List[str]] = None,
+    begin: Union[datetime, int, None] = None,
+    end: Union[datetime, int, None] = None,
+    params: Optional[Dict[str, Any]] = None,
+    as_iterator: bool = False,
+    as_chunks: bool = False,
+    as_dask: bool = False,
+    chunk_interval: Union[timedelta, int, None] = None,
+    fresh: bool = False,
+    debug: bool = False,
+    **kw: Any
+) -> Union['pd.DataFrame', Iterator['pd.DataFrame'], None]:
     """
     Get a pipe's data from the instance connector.
 

meerschaum/core/Pipe/_deduplicate.py

@@ -8,7 +8,7 @@ Delete duplicate rows within a pipe's table.
 
 from __future__ import annotations
 from datetime import datetime, timedelta
-from meerschaum.utils.typing import SuccessTuple, Any, Optional, Dict, Tuple
+from meerschaum.utils.typing import SuccessTuple, Any, Optional, Dict, Tuple, Union
 
 
 def deduplicate(

meerschaum/core/Pipe/_dtypes.py

@@ -8,7 +8,12 @@ Enforce data types for a pipe's underlying table.
 
 from __future__ import annotations
 from io import StringIO
+import meerschaum as mrsm
 from meerschaum.utils.typing import Dict, Any, Optional
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    pd = mrsm.attempt_import('pandas')
 
 def enforce_dtypes(
         self,

meerschaum/core/Pipe/_fetch.py

@@ -8,11 +8,14 @@ Functions for fetching new data into the Pipe
 
 from __future__ import annotations
 from datetime import timedelta, datetime
+
 import meerschaum as mrsm
-from meerschaum.utils.typing import Optional, Any, Union, SuccessTuple, Iterator
+from meerschaum.utils.typing import Optional, Any, Union, SuccessTuple, Iterator, TYPE_CHECKING
 from meerschaum.config import get_config
 from meerschaum.utils.warnings import warn
-from meerschaum.utils.misc import filter_keywords
+
+if TYPE_CHECKING:
+    pd = mrsm.attempt_import('pandas')
 
 def fetch(
         self,
@@ -55,6 +58,7 @@ def fetch(
 
     from meerschaum.connectors import custom_types, get_connector_plugin
     from meerschaum.utils.debug import dprint, _checkpoint
+    from meerschaum.utils.misc import filter_arguments
 
     _chunk_hook = kw.pop('chunk_hook', None)
     kw['workers'] = self.get_num_workers(kw.get('workers', None))
@@ -72,24 +76,22 @@ def fetch(
                 chunk_message = '\n' + chunk_label + '\n' + chunk_message
             return chunk_success, chunk_message
 
-
     with mrsm.Venv(get_connector_plugin(self.connector)):
-        df = self.connector.fetch(
+        _args, _kwargs = filter_arguments(
+            self.connector.fetch,
             self,
-            **filter_keywords(
-                self.connector.fetch,
-                begin=_determine_begin(
-                    self,
-                    begin,
-                    check_existing=check_existing,
-                    debug=debug,
-                ),
-                end=end,
-                chunk_hook=_chunk_hook,
+            begin=_determine_begin(
+                self,
+                begin,
+                check_existing=check_existing,
                 debug=debug,
-                **kw
-            )
+            ),
+            end=end,
+            chunk_hook=_chunk_hook,
+            debug=debug,
+            **kw
         )
+        df = self.connector.fetch(*_args, **_kwargs)
     return df