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

meerschaum/api/models/_pipes.py

@@ -3,19 +3,19 @@
 # vim:fenc=utf-8
 
 """
-Register new Pipes
+Pydantic model for a pipe's keys.
 """
 
 from __future__ import annotations
-from meerschaum.utils.typing import Any, Dict, Optional
 
-from meerschaum.utils.packages import attempt_import
-pydantic = attempt_import('pydantic', warn=False)
+import meerschaum as mrsm
+from meerschaum.utils.typing import Optional
+
+pydantic = mrsm.attempt_import('pydantic', warn=False, lazy=False)
+
 
 class MetaPipe(pydantic.BaseModel):
-    connector_keys: str ### e.g. sql:main
+    connector_keys: str
     metric_key: str
     location_key: Optional[str] = None
-    instance: Optional[str] = None
-
-
+    instance_keys: Optional[str] = None

meerschaum/api/resources/static/css/dash.css

@@ -24,8 +24,8 @@ a {
 }
 #webterm-iframe {
   width: 102%;
-  height: 85vh !important;
-  max-height: 85vh;
+  height: 83vh !important;
+  max-height: 83vh;
 }
 .codeblock {
   background-color: var(--bs-secondary) !important;

meerschaum/api/resources/templates/termpage.html

@@ -88,7 +88,11 @@ window.addEventListener(
     if (action_str === "__TMUX_NEW_WINDOW") {
       line = "\x02:";
       window.terminal.socket.send(JSON.stringify(["stdin", line]));
-      line = "new-window python3 -m meerschaum\r";
+      line = "new-window python3 -m meerschaum";
+      if (instance.length > 0) {
+          line += " -i " + instance;
+      }
+      line += "\r"
       window.terminal.socket.send(JSON.stringify(["stdin", line]));
       return;
     }

meerschaum/api/routes/__init__.py

@@ -3,17 +3,20 @@
 # vim:fenc=utf-8
 
 """
-Import all routes from other modules in package
+Import the routes submodules to register them to the FastAPI app.
 """
 
-from meerschaum.api.routes._login import *
-from meerschaum.api.routes._actions import *
-from meerschaum.api.routes._jobs import *
-from meerschaum.api.routes._connectors import *
-from meerschaum.api.routes._index import *
-from meerschaum.api.routes._misc import *
-from meerschaum.api.routes._pipes import *
-from meerschaum.api.routes._plugins import *
-from meerschaum.api.routes._users import *
-from meerschaum.api.routes._version import *
-from meerschaum.api.routes._webterm import *
+import meerschaum.api.routes._login
+import meerschaum.api.routes._actions
+import meerschaum.api.routes._jobs
+import meerschaum.api.routes._connectors
+import meerschaum.api.routes._index
+import meerschaum.api.routes._misc
+import meerschaum.api.routes._pipes
+import meerschaum.api.routes._plugins
+import meerschaum.api.routes._users
+import meerschaum.api.routes._version
+
+from meerschaum.api import _include_dash
+if _include_dash:
+    import meerschaum.api.routes._webterm

meerschaum/api/routes/_connectors.py

@@ -7,55 +7,57 @@ Get the currently registered connectors.
 """
 
 import fastapi
-from fastapi import Body, HTTPException
-from meerschaum.api import app, endpoints, private, no_auth, manager
+from fastapi import HTTPException
+
+import meerschaum as mrsm
+from meerschaum.api import app, endpoints, no_auth, manager
 from meerschaum.utils.typing import Optional, Dict, List, Union
 
 endpoint = endpoints['connectors']
 
+
 @app.get(endpoint, tags=['Connectors'])
 def get_connectors(
-        type : Optional[str] = None,
-        curr_user = (
-            fastapi.Depends(manager) if not no_auth else None
-        ),
-    ) -> Union[Dict[str, List[str]], List[str]]:
+    type: Optional[str] = None,
+    curr_user = (
+        fastapi.Depends(manager) if not no_auth else None
+    ),
+) -> Union[Dict[str, List[str]], List[str]]:
     """
     Return the keys of the registered connectors.
 
     Parameters
     ----------
-    type:
-        If a `type` is specified, return the list of connectors that belong to that type.
+    type: Optional[str], default None
+        If provided, return the list of connectors of type `type`.
         Otherwise, return a dictionary of types that map to lists of labels.
-        Defaults to `None`.
+
+    Returns
+    -------
+    A dictionary of types and labels, or a list of labels.
     """
-    from meerschaum.config import get_config
-    if type is not None and type not in get_config('meerschaum', 'connectors'):
+    if type is not None and type not in mrsm.get_config('meerschaum', 'connectors'):
         raise HTTPException(status_code=404, detail=f"No connectors of type '{type}'.")
-    types = []
-    if type is not None:
-        types.append(type)
-    else:
-        for t in get_config('meerschaum', 'connectors'):
-            types.append(t)
-
+    types = [type] if type is not None else mrsm.get_config('meerschaum', 'connectors').keys()
     response_dict = {}
-    for t in types:
-        response_dict[t] = list(get_config('meerschaum', 'connectors', t))
-        if 'default' in response_dict[t]:
-            response_dict[t].remove('default')
+    for typ in types:
+        response_dict[typ] = [
+            _typ
+            for _typ in mrsm.get_config('meerschaum', 'connectors', typ)
+            if _typ != 'default'
+        ]
     if type is not None:
         return response_dict[type]
     return response_dict
 
+
 @app.get(endpoint + "/{type}", tags=['Connectors'])
 def get_connectors_by_type(
-        type : str,
-        curr_user = (
-            fastapi.Depends(manager) if not no_auth else None
-        ),
-    ):
+    type: str,
+    curr_user = (
+        fastapi.Depends(manager) if not no_auth else None
+    ),
+):
     """
     Convenience method for `get_connectors()`.
     """

meerschaum/api/routes/_index.py

@@ -3,7 +3,7 @@
 # vim:fenc=utf-8
 
 """
-Default route
+Redirect the index path to `/dash` if applicable.
 """
 
 import starlette.responses
@@ -12,16 +12,25 @@ from meerschaum.api import (
     endpoints,
     HTMLResponse,
     Request,
-    version,
+    docs_enabled,
     _include_dash,
 )
-from meerschaum.utils.packages import attempt_import
 RedirectResponse = starlette.responses.RedirectResponse
 
+INDEX_REDIRECT_URL: str = (
+    endpoints['dash']
+    if _include_dash
+    else (
+        endpoints['docs']
+        if docs_enabled
+        else endpoints['openapi']
+    )
+)
+
+
 @app.get(endpoints['index'], response_class=HTMLResponse)
-def index(request : Request):
+def index(request: Request):
     """
-    Meerschaum WebAPI index page.
+    Meerschaum Web API index page.
     """
-    _url = endpoints['dash'] if _include_dash else '/docs'
-    return RedirectResponse(url=_url)
+    return RedirectResponse(url=INDEX_REDIRECT_URL)

meerschaum/api/routes/_misc.py

@@ -7,33 +7,41 @@ Miscellaneous routes
 """
 
 from __future__ import annotations
-from meerschaum.utils.typing import Dict, Union, Any
-
 import os
+
+from meerschaum.utils.typing import Dict, Union, Any, Optional
 from meerschaum import get_pipes
 from meerschaum.api import (
-    app, endpoints, check_allow_chaining, SERVER_ID, debug, get_api_connector,
-    private, no_auth, manager
+    app,
+    endpoints,
+    check_allow_chaining,
+    SERVER_ID,
+    debug,
+    get_api_connector,
+    private,
+    manager
 )
+from meerschaum.config.paths import API_STATIC_PATH
+from meerschaum import __version__ as version
 import fastapi
 from starlette.responses import FileResponse, JSONResponse
 from meerschaum.connectors.poll import _wrap_retry_connect
 
+
 @app.get(endpoints['favicon'], tags=['Misc'])
 def get_favicon() -> Any:
     """
     Return the favicon file.
     """
-    from meerschaum.config._paths import API_STATIC_PATH
-    return FileResponse(os.path.join(API_STATIC_PATH, 'ico', 'logo.ico'))
+    return FileResponse(API_STATIC_PATH / 'ico' / 'logo.ico')
 
 
 @app.get(endpoints['chaining'], tags=['Misc'])
 def get_chaining_status(
-        curr_user = (
-            fastapi.Depends(manager) if private else None
-        ),
-    ) -> bool:
+    curr_user = (
+        fastapi.Depends(manager) if private else None
+    ),
+) -> bool:
     """
     Return whether this API instance may be chained.
     """
@@ -42,17 +50,17 @@ def get_chaining_status(
 
 @app.get(endpoints['info'], tags=['Misc'])
 def get_instance_info(
-        curr_user = (
-            fastapi.Depends(manager) if private else None
-        ),
-    ) -> Dict[str, Union[str, int]]:
+    curr_user = (
+        fastapi.Depends(manager) if private else None
+    ),
+    instance_keys: Optional[str] = None,
+) -> Dict[str, Union[str, int]]:
     """
     Return information about this API instance.
     """
-    from meerschaum import __version__ as version
-    num_plugins = len(get_api_connector().get_plugins(debug=debug))
-    num_users = len(get_api_connector().get_users(debug=debug))
-    num_pipes = len(get_pipes(mrsm_instance=get_api_connector(), as_list=True))
+    num_plugins = len(get_api_connector(instance_keys).get_plugins(debug=debug))
+    num_users = len(get_api_connector(instance_keys).get_users(debug=debug))
+    num_pipes = len(get_pipes(mrsm_instance=get_api_connector(instance_keys), as_list=True))
     return {
         'version': version,
         'num_plugins': num_plugins,
@@ -62,14 +70,14 @@ def get_instance_info(
 
 
 @app.get(endpoints['healthcheck'], tags=['Misc'])
-def get_healtheck() -> Dict[str, Any]:
+def get_healtheck(instance_keys: Optional[str] = None) -> Dict[str, Any]:
     """
     Return a success message to confirm this API is reachable.
     """
-    conn = get_api_connector()
+    conn = get_api_connector(instance_keys)
     success = _wrap_retry_connect(
         conn.meta,
-        max_retries = 1, 
+        max_retries=1, 
     )
     message = "Success" if success else "Failed to connect to instance connector."
     status_code = 200 if success else 503
@@ -82,7 +90,7 @@ if debug:
         curr_user = (
             fastapi.Depends(manager) if private else None
         ),
-    ) -> str:
+    ) -> Dict[str, Union[int, str]]:
         return {
             'server': SERVER_ID,
             'process': os.getpid(),