meerschaum 2.7.9__py3-none-any.whl → 2.8.0__py3-none-any.whl

meerschaum/api/routes/_plugins.py

@@ -7,41 +7,47 @@ Routes for managing plugins
 """
 
 from __future__ import annotations
-from meerschaum.utils.typing import Optional, List, SuccessTuple, Union, Any, Dict
+import json
+import shutil
+import pathlib
+import os
+
+from meerschaum.utils.typing import Optional, List, SuccessTuple, Any, Dict
 
 from meerschaum.api import (
     fastapi,
     app,
     endpoints,
     get_api_connector,
-    pipes,
-    get_pipe,
     manager,
     debug,
-    private, no_auth,
+    private,
+    no_auth,
+    default_instance_keys,
 )
-import fastapi
 from meerschaum.api.tables import get_tables
-from fastapi import FastAPI, File, UploadFile
+from fastapi import File, UploadFile
 from meerschaum.utils.packages import attempt_import
-import meerschaum.core
 from meerschaum.core import Plugin
-starlette_responses = attempt_import('starlette.responses', warn=False)
+starlette_responses = attempt_import('starlette.responses', warn=False, lazy=False)
 FileResponse = starlette_responses.FileResponse
 
 sqlalchemy = attempt_import('sqlalchemy', lazy=False)
 plugins_endpoint = endpoints['plugins']
 
+PLUGINS_INSTANCE_KEYS = default_instance_keys
+
+
 @app.post(plugins_endpoint + '/{name}', tags=['Plugins'])
 def register_plugin(
-        name: str,
-        version: str = None,
-        attributes: str = None,
-        archive: UploadFile = File(...),
-        curr_user = (
-            fastapi.Depends(manager) if not no_auth else None
-        ),
-    ) -> SuccessTuple:
+    name: str,
+    version: str = None,
+    attributes: str = None,
+    archive: UploadFile = File(...),
+    curr_user = (
+        fastapi.Depends(manager) if not no_auth else None
+    ),
+) -> SuccessTuple:
     """
     Register a plugin and save its archive file.
 
@@ -78,7 +84,6 @@ def register_plugin(
             "you can toggle various registration types."
         )
 
-    import json, shutil, pathlib, os
     get_tables()
     if attributes is None:
         attributes = json.dumps({})
@@ -86,7 +91,7 @@ def register_plugin(
     if isinstance(attributes, str) and attributes[0] == '{':
         try:
             attributes = json.loads(attributes)
-        except Exception as e:
+        except Exception:
             pass
 
     plugin = Plugin(name, version=version, attributes=attributes)
@@ -97,13 +102,15 @@ def register_plugin(
         )
 
     if curr_user is not None:
-        plugin_user_id = get_api_connector().get_plugin_user_id(plugin)
-        curr_user_id = get_api_connector().get_user_id(curr_user) if curr_user is not None else -1
+        plugin_user_id = get_api_connector(PLUGINS_INSTANCE_KEYS).get_plugin_user_id(plugin)
+        curr_user_id = get_api_connector(PLUGINS_INSTANCE_KEYS).get_user_id(curr_user) if curr_user is not None else -1
         if plugin_user_id is not None and plugin_user_id != curr_user_id:
             return False, f"User '{curr_user.username}' cannot edit plugin '{plugin}'."
         plugin.user_id = curr_user_id
 
-    success, msg = get_api_connector().register_plugin(plugin, make_archive=False, debug=debug)
+    success, msg = get_api_connector(
+        PLUGINS_INSTANCE_KEYS
+    ).register_plugin(plugin, make_archive=False, debug=debug)
 
     if success:
         archive_path = plugin.archive_path
@@ -117,11 +124,11 @@ def register_plugin(
 
 @app.get(plugins_endpoint + '/{name}', tags=['Plugins'])
 def get_plugin(
-        name: str,
-        curr_user = (
-            fastapi.Depends(manager) if private else None
-        ),
-    ) -> Any:
+    name: str,
+    curr_user = (
+        fastapi.Depends(manager) if private else None
+    ),
+) -> Any:
     """
     Download a plugin's archive file.
     """
@@ -133,24 +140,25 @@ def get_plugin(
 
 @app.get(plugins_endpoint + '/{name}/attributes', tags=['Plugins'])
 def get_plugin_attributes(
-        name: str,
-        curr_user = (
-            fastapi.Depends(manager) if private else None
-        ),
-    ) -> Dict[str, Any]:
+    name: str,
+    curr_user = (
+        fastapi.Depends(manager) if private else None
+    ),
+) -> Dict[str, Any]:
     """
     Get a plugin's attributes.
     """
-    return get_api_connector().get_plugin_attributes(Plugin(name))
+    return get_api_connector(PLUGINS_INSTANCE_KEYS).get_plugin_attributes(Plugin(name))
+
 
 @app.get(plugins_endpoint, tags=['Plugins'])
 def get_plugins(
-        user_id : Optional[int] = None,
-        search_term : Optional[str] = None,
-        curr_user = (
-            fastapi.Depends(manager) if private else None
-        ),
-    ) -> List[str]:
+    user_id: Optional[int] = None,
+    search_term: Optional[str] = None,
+    curr_user = (
+        fastapi.Depends(manager) if private else None
+    ),
+) -> List[str]:
     """
     Get a list of plugins.
 
@@ -166,26 +174,29 @@ def get_plugins(
     -------
     A list of strings.
     """
-    return get_api_connector().get_plugins(user_id=user_id, search_term=search_term)
+    return get_api_connector(
+        PLUGINS_INSTANCE_KEYS
+    ).get_plugins(user_id=user_id, search_term=search_term)
+
 
 @app.delete(plugins_endpoint + '/{name}', tags=['Plugins'])
 def delete_plugin(
-        name : str,
-        curr_user = (
-            fastapi.Depends(manager) if private else None
-        ),
-    ) -> SuccessTuple:
+    name: str,
+    curr_user = (
+        fastapi.Depends(manager) if private else None
+    ),
+) -> SuccessTuple:
     """
     Delete a plugin and its archive file from the repository.
     """
     get_tables()
     plugin = Plugin(name)
-    plugin_user_id = get_api_connector().get_plugin_user_id(plugin)
+    plugin_user_id = get_api_connector(PLUGINS_INSTANCE_KEYS).get_plugin_user_id(plugin)
     if plugin_user_id is None:
         return False, f"Plugin '{plugin}' is not registered."
 
     if curr_user is not None:
-        curr_user_id = get_api_connector().get_user_id(curr_user)
+        curr_user_id = get_api_connector(PLUGINS_INSTANCE_KEYS).get_user_id(curr_user)
         if plugin_user_id != curr_user_id:
             return False, f"User '{curr_user.username}' cannot delete plugin '{plugin}'."
     else:
@@ -196,7 +207,7 @@ def delete_plugin(
     if not _remove_success[0]:
         return _remove_success
 
-    _delete_success = get_api_connector().delete_plugin(plugin, debug=debug)
+    _delete_success = get_api_connector(PLUGINS_INSTANCE_KEYS).delete_plugin(plugin, debug=debug)
     if not _delete_success[0]:
         return _delete_success
 

meerschaum/api/routes/_users.py

@@ -16,7 +16,7 @@ from meerschaum.utils.packages import attempt_import
 from meerschaum.api import (
     fastapi, app, endpoints, get_api_connector, manager,
     debug, check_allow_chaining, DISALLOW_CHAINING_MESSAGE,
-    no_auth, private,
+    no_auth, private, default_instance_keys,
 )
 from meerschaum.utils.misc import string_to_dict
 from meerschaum.config import get_config
@@ -28,31 +28,38 @@ users_endpoint = endpoints['users']
 import fastapi
 from fastapi import HTTPException, Form
 
+USERS_INSTANCE_KEYS = default_instance_keys
+
 
 @app.get(users_endpoint + "/me", tags=['Users'])
 def read_current_user(
     curr_user = (
         fastapi.Depends(manager) if not no_auth else None
     ),
-) -> Dict[str, Union[str, int]]:
+) -> Dict[str, Union[str, int, None, Dict[str, Any]]]:
     """
     Get information about the currently logged-in user.
     """
     return {
         'username': (
-            curr_user.username if curr_user is not None else 'no_auth'
+            curr_user.username
+            if curr_user is not None
+            else 'no_auth'
         ),
         'user_id': (
-            get_api_connector().get_user_id(curr_user)
-            if curr_user is not None else -1
+            get_api_connector(USERS_INSTANCE_KEYS).get_user_id(curr_user)
+            if curr_user is not None
+            else -1
         ),
         'user_type': (
-            get_api_connector().get_user_type(curr_user)
-            if curr_user is not None else 'admin'
+            get_api_connector(USERS_INSTANCE_KEYS).get_user_type(curr_user)
+            if curr_user is not None
+            else 'admin'
         ),
         'attributes': (
-            get_api_connector().get_user_attributes(curr_user)
-            if curr_user is not None else {}
+            get_api_connector(USERS_INSTANCE_KEYS).get_user_attributes(curr_user)
+            if curr_user is not None
+            else {}
         ),
     }
 
@@ -66,7 +73,7 @@ def get_users(
     """
     Get a list of the registered users.
     """
-    return get_api_connector().get_users(debug=debug)
+    return get_api_connector(USERS_INSTANCE_KEYS).get_users(debug=debug)
 
 
 @app.post(users_endpoint + "/register", tags=['Users'])
@@ -90,25 +97,25 @@ def register_user(
         try:
             attributes = string_to_dict(attributes)
         except Exception:
-            return False, f"Invalid dictionary string received for attributes."
+            return False, "Invalid dictionary string received for attributes."
 
     allow_users = get_config('system', 'api', 'permissions', 'registration', 'users')
     if not allow_users:
         return False, (
             "The administrator for this server has not allowed user registration.\n\n"
-            + "Please contact the system administrator, or if you are running this server, "
-            + "open the configuration file with `edit config system` and search for 'permissions'. "
-            + " Under the keys api:permissions:registration, "
-            + "you can toggle various registration types."
+            "Please contact the system administrator, or if you are running this server, "
+            "open the configuration file with `edit config system` and search for 'permissions'. "
+            " Under the keys api:permissions:registration, "
+            "you can toggle various registration types."
         )
     if type == 'admin':
         return False, (
-            "New users cannot be of type 'admin' when using the API connector. " +
-            "Register a normal user first, then edit the user from an authorized account, " +
+            "New users cannot be of type 'admin' when using the API connector. "
+            "Register a normal user first, then edit the user from an authorized account, "
             "or use a SQL connector instead."
         )
     user = User(username, password, type=type, email=email, attributes=attributes)
-    return get_api_connector().register_user(user, debug=debug)
+    return get_api_connector(USERS_INSTANCE_KEYS).register_user(user, debug=debug)
 
 
 @app.post(users_endpoint + "/edit", tags=['Users'])
@@ -129,21 +136,21 @@ def edit_user(
         try:
             attributes = string_to_dict(attributes)
         except Exception:
-            return False, f"Invalid dictionary string received for attributes."
+            return False, "Invalid dictionary string received for attributes."
 
     user = User(username, password, email=email, attributes=attributes)
-    user_type = get_api_connector().get_user_type(curr_user) if curr_user is not None else 'admin'
+    user_type = get_api_connector(USERS_INSTANCE_KEYS).get_user_type(curr_user) if curr_user is not None else 'admin'
     if user_type == 'admin' and type is not None:
         user.type = type
     if user_type == 'admin' or curr_user.username == user.username:
-        return get_api_connector().edit_user(user, debug=debug)
+        return get_api_connector(USERS_INSTANCE_KEYS).edit_user(user, debug=debug)
 
     return False, f"Cannot edit user '{user}': Permission denied"
 
 
 @app.get(users_endpoint + "/{username}/id", tags=['Users'])
 def get_user_id(
-    username : str,
+    username: str,
     curr_user = (
         fastapi.Depends(manager) if not no_auth else None
     ),
@@ -151,12 +158,12 @@ def get_user_id(
     """
     Get a user's ID.
     """
-    return get_api_connector().get_user_id(User(username), debug=debug)
+    return get_api_connector(USERS_INSTANCE_KEYS).get_user_id(User(username), debug=debug)
 
 
 @app.get(users_endpoint + "/{username}/attributes", tags=['Users'])
 def get_user_attributes(
-    username : str,
+    username: str,
     curr_user = (
         fastapi.Depends(manager) if private else None
     ),
@@ -164,7 +171,7 @@ def get_user_attributes(
     """
     Get a user's attributes.
     """
-    return get_api_connector().get_user_attributes(User(username), debug=debug)
+    return get_api_connector(USERS_INSTANCE_KEYS).get_user_attributes(User(username), debug=debug)
 
 
 @app.delete(users_endpoint + "/{username}", tags=['Users'])
@@ -179,11 +186,12 @@ def delete_user(
     """
     user = User(username)
     user_type = (
-        get_api_connector().get_user_type(curr_user, debug=debug)
-        if curr_user is not None else 'admin'
+        get_api_connector(USERS_INSTANCE_KEYS).get_user_type(curr_user, debug=debug)
+        if curr_user is not None
+        else 'admin'
     )
     if user_type == 'admin' or curr_user.username == user.username:
-        return get_api_connector().delete_user(user, debug=debug)
+        return get_api_connector(USERS_INSTANCE_KEYS).delete_user(user, debug=debug)
 
     return False, f"Cannot delete user '{user}': Permission denied"
 
@@ -203,12 +211,12 @@ def get_user_password_hash(
     """
     if not check_allow_chaining():
         raise HTTPException(status_code=403, detail=DISALLOW_CHAINING_MESSAGE)
-    return get_api_connector().get_user_password_hash(User(username), debug=debug)
+    return get_api_connector(USERS_INSTANCE_KEYS).get_user_password_hash(User(username), debug=debug)
 
 
 @app.get(users_endpoint + '/{username}/type', tags=['Users'])
 def get_user_type(
-    username : str,
+    username: str,
     curr_user = (
         fastapi.Depends(manager) if not no_auth else None
     ),
@@ -218,4 +226,4 @@ def get_user_type(
     """
     if not check_allow_chaining():
         raise HTTPException(status_code=403, detail=DISALLOW_CHAINING_MESSAGE)
-    return get_api_connector().get_user_type(User(username))
+    return get_api_connector(USERS_INSTANCE_KEYS).get_user_type(User(username))

meerschaum/api/routes/_version.py

@@ -8,14 +8,13 @@ Return version information
 
 import fastapi
 from meerschaum.api import app, endpoints, private, manager
-from meerschaum.utils.typing import Union
 
 @app.get(endpoints['version'], tags=['Version'])
 def get_api_version(
-        curr_user = (
-            fastapi.Depends(manager) if private else None
-        ),
-    ):
+    curr_user = (
+        fastapi.Depends(manager) if private else None
+    ),
+):
     """
     Get the Meerschaum API version.
     """
@@ -24,13 +23,12 @@ def get_api_version(
 
 @app.get(endpoints['version'] + "/mrsm", tags=['Version'])
 def get_meerschaum_version(
-        curr_user = (
-            fastapi.Depends(manager) if private else None
-        ),
-    ):
+    curr_user = (
+        fastapi.Depends(manager) if private else None
+    ),
+):
     """
     Get the Meerschaum instance version.
     """
     from meerschaum import __version__ as version
     return version
-

meerschaum/api/routes/_webterm.py

@@ -76,7 +76,7 @@ async def get_webterm(
         text = response.text
         if request.url.scheme == 'https':
             text = text.replace('ws://', 'wss://')
-        text = text.replace(f'_websocket/{username}', f'_websocket/{session_id}')
+        text = text.replace(f'websocket/{username}', f'websocket/{session_id}')
         return HTMLResponse(
             content=text,
             status_code=response.status_code,
@@ -100,7 +100,7 @@ async def webterm_websocket(websocket: WebSocket, session_id: str):
 
     username = get_username_from_session(session_id)
 
-    ws_url = f"ws://localhost:8765/_websocket/{username or session_id}"
+    ws_url = f"ws://localhost:8765/websocket/{username or session_id}"
     async with websockets.connect(ws_url) as ws:
         async def forward_messages():
             try:

meerschaum/config/_default.py

@@ -111,6 +111,12 @@ default_system_config = {
             'connector': 'valkey:main',
             'session_expires_minutes': 43200,
         },
+        'data': {
+            'max_response_row_limit': 100_000,
+        },
+        'endpoints': {
+            'docs_in_production': True,
+        },
         'permissions':       {
             'registration': {
                 'users': True,
@@ -124,6 +130,10 @@ default_system_config = {
                 'insecure_parent_instance': False,
                 'child_apis': False,
             },
+            'instances': {
+                'allow_multiple_instances': True,
+                'allowed_instance_keys': ['*']
+            },
         },
         'protocol': default_meerschaum_config['connectors']['api']['default']['protocol'],
     },

meerschaum/config/_version.py

@@ -2,4 +2,4 @@
 Specify the Meerschaum release version.
 """
 
-__version__ = "2.7.9"
+__version__ = "2.8.0"

meerschaum/config/static/__init__.py

@@ -7,7 +7,6 @@ Insert non-user-editable configuration files here.
 """
 
 import os
-import uuid
 from typing import Dict, Any
 from meerschaum.utils.misc import generate_password
 
@@ -33,9 +32,12 @@ STATIC_CONFIG: Dict[str, Any] = {
             'websocket': '/ws',
             'dash': '/dash',
             'webterm': r'/webterm/{session_id}',
-            'webterm_websocket': r'/_websocket/{session_id}',
+            'webterm_websocket': r'/websocket/{session_id}',
             'info': '/info',
             'healthcheck': '/healthcheck',
+            'docs': '/docs',
+            'redoc': '/redoc',
+            'openapi': '/openapi.json',
         },
         'oauth': {
             'token_expires_minutes': 720,
@@ -149,6 +151,7 @@ STATIC_CONFIG: Dict[str, Any] = {
         },
         'exists_timeout_seconds': 5.0,
         'static_schema_cache_seconds': 60.0,
+        'max_bound_time_days': 36525,
     },
     'jobs': {
         'check_restart_seconds': 1.0,

meerschaum/connectors/api/_APIConnector.py

@@ -169,12 +169,12 @@ class APIConnector(Connector):
     @property
     def session(self):
         if self._session is None:
-            certifi = attempt_import('certifi', lazy=False)
+            _ = attempt_import('certifi', lazy=False)
             requests = attempt_import('requests', lazy=False)
             if requests:
                 self._session = requests.Session()
             if self._session is None:
-                error(f"Failed to import requests. Is requests installed?")
+                error("Failed to import requests. Is requests installed?")
         return self._session
 
     @property
@@ -191,6 +191,7 @@ class APIConnector(Connector):
 
         if self._token is None or expired:
             success, msg = self.login()
-            if not success:
+            if not success and not self.__dict__.get('_emitted_warning'):
                 warn(msg, stack=False)
+                self._emitted_warning = True
         return self._token

meerschaum/connectors/api/_login.py

@@ -7,19 +7,21 @@ Log into the API instance or refresh the token.
 """
 
 from __future__ import annotations
+
+import json
+import datetime
 from meerschaum.utils.typing import SuccessTuple, Any, Union
+from meerschaum.config.static import STATIC_CONFIG
+from meerschaum.utils.warnings import warn as _warn
+
 
 def login(
-        self,
-        debug: bool = False,
-        warn: bool = True,
-        **kw: Any
-    ) -> SuccessTuple:
+    self,
+    debug: bool = False,
+    warn: bool = True,
+    **kw: Any
+) -> SuccessTuple:
     """Log in and set the session token."""
-    from meerschaum.utils.warnings import warn as _warn, info, error
-    from meerschaum.core import User
-    from meerschaum.config.static import STATIC_CONFIG
-    import json, datetime
     try:
         login_data = {
             'username': self.username,
@@ -27,11 +29,12 @@ def login(
         }
     except AttributeError:
         return False, f"Please login with the command `login {self}`."
+
     response = self.post(
         STATIC_CONFIG['api']['endpoints']['login'],
-        data = login_data,
-        use_token = False,
-        debug = debug
+        data=login_data,
+        use_token=False,
+        debug=debug,
     )
     if response:
         msg = f"Successfully logged into '{self}' as user '{login_data['username']}'."
@@ -45,16 +48,17 @@ def login(
             f"Failed to log into '{self}' as user '{login_data['username']}'.\n" +
             f"    Please verify login details for connector '{self}'."
         )
-        if warn:
+        if warn and not self.__dict__.get('_emitted_warning', False):
             _warn(msg, stack=False)
+            self._emitted_warning = True
 
     return response.__bool__(), msg
 
 
 def test_connection(
-        self,
-        **kw: Any
-    ) -> Union[bool, None]:
+    self,
+    **kw: Any
+) -> Union[bool, None]:
     """Test if a successful connection to the API may be made."""
     from meerschaum.connectors.poll import retry_connect
     _default_kw = {
@@ -65,5 +69,5 @@ def test_connection(
     _default_kw.update(kw)
     try:
         return retry_connect(**_default_kw)
-    except Exception as e:
+    except Exception:
         return False

meerschaum/connectors/api/_pipes.py

@@ -581,6 +581,7 @@ def get_pipe_rowcount(
         If provided, bound the count by these parameters.
 
     remote: bool, default False
+        If `True`, return the rowcount for the fetch definition.
 
     Returns
     -------

meerschaum/connectors/api/_request.py

@@ -248,16 +248,15 @@ def delete(self, r_url: str, **kwargs: Any) -> 'requests.Response':
 
 
 def wget(
-        self,
-        r_url: str,
-        dest: Optional[Union[str, pathlib.Path]] = None,
-        headers: Optional[Dict[str, Any]] = None,
-        use_token: bool = True,
-        debug: bool = False,
-        **kw: Any
-    ) -> pathlib.Path:
-    """Mimic wget with requests.
-    """
+    self,
+    r_url: str,
+    dest: Optional[Union[str, pathlib.Path]] = None,
+    headers: Optional[Dict[str, Any]] = None,
+    use_token: bool = True,
+    debug: bool = False,
+    **kw: Any
+) -> pathlib.Path:
+    """Mimic wget with requests."""
     from meerschaum.utils.misc import wget
     if headers is None:
         headers = {}

meerschaum/connectors/sql/_cli.py

@@ -109,13 +109,21 @@ def _cli_exit(
     ### and because `main.cli()` is not defined.
     launch_cli = f"cli_main.cli(['{cli_arg_str}'])"
     if self.flavor == 'mssql':
+        attrs = self.parse_uri(self.URI)
+        host = attrs.get('host', None)
+        port = attrs.get('port', None)
+        database = attrs.get('database', None)
+        username = attrs.get('username', None)
+        password = attrs.get('password', None)
+        if not host or not port or not database:
+            raise ValueError(f"Cannot determine attributes for '{self}'.")
         launch_cli = (
             "mssqlclioptionsparser, mssql_cli = attempt_import("
             + "'mssqlcli.mssqlclioptionsparser', 'mssqlcli.mssql_cli', lazy=False)\n"
             + "ms_parser = mssqlclioptionsparser.create_parser()\n"
-            + f"ms_options = ms_parser.parse_args(['--server', 'tcp:{self.host},{self.port}', "
-            + f"'--database', '{self.database}', "
-            + f"'--username', '{self.username}', '--password', '{self.password}'])\n"
+            + f"ms_options = ms_parser.parse_args(['--server', 'tcp:{host},{port}', "
+            + f"'--database', '{database}', "
+            + f"'--username', '{username}', '--password', '{password}'])\n"
             + "ms_object = mssql_cli.MssqlCli(ms_options)\n"
             + "try:\n"
             + "    ms_object.connect_to_database()\n"

meerschaum/connectors/sql/_instance.py

@@ -186,7 +186,7 @@ def _drop_old_temporary_tables(
     ]
     if docs:
         queries = [sqlalchemy.insert(temp_tables_table).values(**doc) for doc in docs]
-        results = [self.exec(query, silent=True, debug=debug) for query in queries]
+        _ = [self.exec(query, silent=True, debug=debug) for query in queries]
         _in_memory_temp_tables.update(
             {
                 table: True