meerschaum 3.0.0rc4__py3-none-any.whl → 3.0.0rc8__py3-none-any.whl

meerschaum/actions/start.py

@@ -7,6 +7,8 @@ Start subsystems (API server, logging daemon, etc.).
 """
 
 from __future__ import annotations
+
+import meerschaum as mrsm
 from meerschaum.utils.typing import SuccessTuple, Optional, List, Any, Union, Dict
 
 
@@ -25,6 +27,7 @@ def start(
         'webterm': _start_webterm,
         'connectors': _start_connectors,
         'pipeline': _start_pipeline,
+        'daemons': _start_daemons,
     }
     return choose_subaction(action, options, **kw)
 
@@ -308,6 +311,7 @@ def _start_gui(
     action: Optional[List[str]] = None,
     mrsm_instance: Optional[str] = None,
     port: Optional[int] = None,
+    webterm_port: Optional[int] = None,
     debug: bool = False,
     **kw
 ) -> SuccessTuple:
@@ -321,7 +325,6 @@ def _start_gui(
 
     from meerschaum.utils.venv import venv_exec
     from meerschaum.utils.packages import attempt_import
-    from meerschaum.utils.warnings import warn
     from meerschaum.utils.debug import dprint
     from meerschaum.utils.networking import find_open_ports
     from meerschaum.connectors.parse import parse_instance_keys
@@ -329,9 +332,10 @@ def _start_gui(
     webview, requests = attempt_import('webview', 'requests')
 
     success, msg = True, "Success"
-    host = '127.0.0.1'
-    if port is None:
-        port = 8765
+    host = mrsm.get_config('webterm', 'host')
+    port = port or webterm_port
+    if not port:
+        port = mrsm.get_config('webterm', 'port')
 
     if not is_webterm_running(host, port, session_id='mrsm'):
         port = next(find_open_ports(port, 9000))
@@ -369,7 +373,7 @@ def _start_gui(
                 break
         except Exception as e:
             if debug:
-                dprint(e)
+                dprint(str(e))
             continue
     if starting_up is False:
         return False, f"The webterm failed to start within {timeout} seconds."
@@ -417,7 +421,6 @@ def _start_webterm(
         - `-i`, '--instance'
             The default instance to use for the Webterm shell.
     """
-    import uuid
     from meerschaum._internal.term import get_webterm_app_and_manager, tornado_ioloop
     from meerschaum._internal.term.tools import (
         is_webterm_running,
@@ -426,15 +429,17 @@ def _start_webterm(
     )
     from meerschaum.utils.networking import find_open_ports
     from meerschaum.utils.warnings import info
+    from meerschaum.config.paths import WEBTERM_INTERNAL_RESOURCES_PATH
 
     if host is None:
-        host = '127.0.0.1'
+        host = mrsm.get_config('api', 'webterm', 'host')
     if port is None:
-        port = 8765
+        port = mrsm.get_config('api', 'webterm', 'port')
     if sysargs is None:
         sysargs = ['start', 'webterm']
     session_id = 'mrsm'
-    tornado_app, term_manager = get_webterm_app_and_manager(instance_keys=mrsm_instance)
+
+    env_path = WEBTERM_INTERNAL_RESOURCES_PATH / (str(port) + '.json')
 
     if is_webterm_running(host, port, session_id=session_id):
         if force:
@@ -445,11 +450,18 @@ def _start_webterm(
                 + "    Include `-f` to start another server on a new port\n"
                 + "    or specify a different port with `-p`."
             )
+
+    tornado_app, term_manager = get_webterm_app_and_manager(
+        instance_keys=mrsm_instance,
+        port=port,
+        env_path=env_path,
+    )
     if not nopretty:
         info(
             f"Starting the webterm at http://{host}:{port}/webterm/{session_id} ..."
             "\n    Press CTRL+C to quit."
         )
+
     tornado_app.listen(port, host)
     loop = tornado_ioloop.IOLoop.instance()
     try:
@@ -462,10 +474,15 @@ def _start_webterm(
         term_manager.shutdown()
         loop.close()
 
-    sessions = get_mrsm_tmux_sessions()
+    sessions = get_mrsm_tmux_sessions(port=port)
     for session in sessions:
         kill_tmux_session(session)
 
+    try:
+        env_path.unlink()
+    except Exception:
+        pass
+
     return True, "Success"
 
 
@@ -483,7 +500,6 @@ def _start_connectors(
     from meerschaum.connectors.parse import parse_instance_keys
     from meerschaum.utils.pool import get_pool
     from meerschaum.utils.warnings import warn
-    from meerschaum.utils.formatting import pprint
     from meerschaum.utils.misc import items_str
     if action is None:
         action = []
@@ -575,7 +591,6 @@ def _start_pipeline(
     """
     import json
     import time
-    import sys
     from meerschaum._internal.entry import entry
     from meerschaum.utils.warnings import info, warn
     from meerschaum.utils.misc import is_int
@@ -630,7 +645,7 @@ def _start_pipeline(
     def do_entry() -> None:
         nonlocal success, msg, proc
         if timeout_seconds is None:
-            success, msg = entry(sub_args_line, _patch_args=patch_args)
+            success, msg = entry(sub_args_line, _patch_args=patch_args, _use_cli_daemon=False)
             return
 
         sub_args_line_escaped = sub_args_line.replace("'", "<QUOTE>")
@@ -640,7 +655,7 @@ def _start_pipeline(
             "from meerschaum._internal.entry import entry\n\n"
             f"sub_args_line = '{sub_args_line_escaped}'.replace(\"<QUOTE>\", \"'\")\n"
             f"patch_args = json.loads('{patch_args_escaped_str}'.replace('<QUOTE>', \"'\"))\n"
-            "success, msg = entry(sub_args_line, _patch_args=patch_args)\n"
+            "success, msg = entry(sub_args_line, _patch_args=patch_args, _use_cli_daemon=False)\n"
             f"print('{fence_begin}' + json.dumps((success, msg)) + '{fence_end}')"
         )
         proc = venv_exec(src, venv=None, as_proc=True)
@@ -688,6 +703,112 @@ def _start_pipeline(
     return success, msg
 
 
+def _start_daemons(
+    timeout_seconds: Union[int, float, None] = None,
+    yes: bool = False,
+    force: bool = False,
+    noask: bool = False,
+    debug: bool = False,
+    **kwargs
+) -> SuccessTuple:
+    """
+    Start the Meerschaum CLI daemon processes.
+    """
+    from meerschaum.utils.warnings import warn, dprint
+    from meerschaum._internal.cli.daemons import (
+        get_cli_daemon,
+        get_cli_lock_path,
+    )
+    from meerschaum._internal.cli.workers import (
+        get_existing_cli_workers,
+        get_existing_cli_worker_indices,
+    )
+    from meerschaum.utils.prompt import yes_no
+    from meerschaum.actions import actions
+
+    workers = get_existing_cli_workers()
+    if not workers:
+        if debug:
+            dprint("No daemons are running, spawning a new process...")
+        workers = [get_cli_daemon()]
+
+    accepted_restart = False
+    any_daemons_are_running = any((worker.job.status == 'running') for worker in workers)
+    lock_paths = [get_cli_lock_path(ix) for ix in get_existing_cli_worker_indices()]
+    any_locks_exist = any(lock_path.exists() for lock_path in lock_paths)
+
+    if any_locks_exist:
+        warn(
+            "Locks are currently held by the CLI daemons.\n"
+            "Run again with `--force` to remove the locks.",
+            stack=False,
+        )
+
+        if not force:
+            return False, "Actions are currently running."
+
+        for lock_path in lock_paths:
+            try:
+                if lock_path.exists():
+                    lock_path.unlink()
+            except Exception as e:
+                warn(f"Failed to release lock:\n{e}")
+
+    if any_daemons_are_running:
+        accepted_restart = force or yes_no(
+            "Restart running CLI daemons?",
+            yes=yes,
+            noask=noask,
+            default='n',
+        )
+
+        if not accepted_restart:
+            return True, "Daemons are already running; nothing to do."
+
+        stop_success, stop_msg = actions['stop'](
+            ['daemons'],
+            timeout_seconds=timeout_seconds,
+            debug=debug,
+        )
+        if not stop_success:
+            return stop_success, stop_msg
+
+    worker = get_cli_daemon()
+
+    if debug:
+        dprint("Cleaning up CLI daemon...")
+    cleanup_success, cleanup_msg = worker.cleanup()
+    if not cleanup_success:
+        return cleanup_success, cleanup_msg
+
+    if debug:
+        dprint("Starting CLI daemon...")
+
+    start_success, start_msg = worker.job.start()
+    if not start_success:
+        return start_success, start_msg
+
+    return True, "Success"
+
+
+def _start_worker(action: Optional[List[str]] = None, **kwargs: Any) -> SuccessTuple:
+    """
+    Start a CLI worker process. This is intended for internal use only.
+    """
+    from meerschaum._internal.cli.workers import ActionWorker
+    from meerschaum.utils.misc import is_int
+
+    if not action:
+        return False, "No worker index is provided."
+
+    if not is_int(action[0]):
+        return False, "Invalid worker index."
+
+    ix = int(action[0])
+    worker = ActionWorker(ix)
+    return worker.run()
+
+
 ### NOTE: This must be the final statement of the module.
 ###       Any subactions added below these lines will not
 ###       be added to the `help` docstring.

meerschaum/actions/stop.py

@@ -7,7 +7,7 @@ Stop running jobs that were started with `-d` or `start job`.
 """
 
 from __future__ import annotations
-from meerschaum.utils.typing import Optional, List, SuccessTuple, Any
+from meerschaum.utils.typing import Optional, List, SuccessTuple, Any, Union
 
 
 def stop(action: Optional[List[str]] = None, **kw) -> SuccessTuple:
@@ -17,6 +17,7 @@ def stop(action: Optional[List[str]] = None, **kw) -> SuccessTuple:
     from meerschaum.actions import choose_subaction
     options = {
         'jobs': _stop_jobs,
+        'daemons': _stop_daemons,
     }
     return choose_subaction(action, options, **kw)
 
@@ -53,7 +54,7 @@ def _complete_stop(
         return options[sub](action=action, **kw)
 
     from meerschaum._internal.shell import default_action_completer
-    return default_action_completer(action=(['start'] + action), **kw)
+    return default_action_completer(action=(['stop'] + action), **kw)
 
 
 def _stop_jobs(
@@ -113,7 +114,7 @@ def _stop_jobs(
 
     if not jobs_to_stop:
         if jobs:
-            return True, "The selected jobs are currently running."
+            return True, "The selected jobs are currently stopped."
         return False, "No running, paused or restarting jobs to stop."
 
     if not action:
@@ -163,6 +164,38 @@ def _stop_jobs(
     return success, msg
 
 
+def _stop_daemons(
+    timeout_seconds: Union[int, float, None] = None,
+    debug: bool = False,
+    **kwargs
+) -> SuccessTuple:
+    """
+    Stop the Meerschaum CLI daemon.
+    """
+    import shutil
+    from meerschaum._internal.cli.workers import get_existing_cli_workers
+    from meerschaum.config.paths import CLI_RESOURCES_PATH
+    workers = get_existing_cli_workers()
+
+    for worker in workers:
+        stop_success, stop_msg = worker.job.stop(timeout_seconds=timeout_seconds, debug=debug)
+        if not stop_success:
+            return stop_success, stop_msg
+
+        cleanup_success, cleanup_msg = worker.cleanup(debug=debug)
+        if not cleanup_success:
+            return cleanup_success, cleanup_msg
+
+    try:
+        if CLI_RESOURCES_PATH.exists():
+            shutil.rmtree(CLI_RESOURCES_PATH)
+        CLI_RESOURCES_PATH.mkdir(parents=True, exist_ok=True)
+    except Exception as e:
+        return False, f"Failed to clean up CLI resources directory.\n{e}"
+
+    return True, "Success"
+
+
 ### NOTE: This must be the final statement of the module.
 ###       Any subactions added below these lines will not
 ###       be added to the `help` docstring.

meerschaum/actions/sync.py

@@ -289,6 +289,7 @@ def _sync_pipes(
     from meerschaum.utils.formatting import print_pipes_results
     from meerschaum._internal.static import STATIC_CONFIG
     from meerschaum.utils.misc import interval_str
+    from meerschaum.utils.daemon import running_in_daemon
 
     noninteractive_val = os.environ.get(STATIC_CONFIG['environment']['noninteractive'], None)
     noninteractive = str(noninteractive_val).lower() in ('1', 'true', 'yes')
@@ -301,7 +302,11 @@ def _sync_pipes(
     cooldown = 2 * (min_seconds + 1)
     success_pipes, failure_pipes = [], []
     while run:
-        _progress = progress() if shell and not noninteractive else None
+        _progress = (
+            progress()
+            if (shell and not noninteractive and not running_in_daemon())
+            else None
+        )
         cm = _progress if _progress is not None else contextlib.nullcontext()
 
         lap_begin = time.perf_counter()

meerschaum/api/__init__.py

@@ -21,7 +21,6 @@ from meerschaum.config._paths import API_UVICORN_CONFIG_PATH, API_UVICORN_RESOUR
 from meerschaum.plugins import _api_plugins
 from meerschaum.utils.warnings import warn, dprint
 from meerschaum.utils.threading import RLock
-from meerschaum.utils.misc import is_pipe_registered
 from meerschaum.connectors.parse import parse_instance_keys
 
 from meerschaum import __version__ as version
@@ -67,16 +66,13 @@ from meerschaum.api._exceptions import APIPermissionError
 uvicorn_config_path = API_UVICORN_RESOURCES_PATH / SERVER_ID / 'config.json'
 
 uvicorn_config = None
-sys_config = get_config('system', 'api')
-permissions_config = get_config('system', 'api', 'permissions')
+sys_config = get_config('api')
+permissions_config = get_config('api', 'permissions')
 
 def get_uvicorn_config() -> Dict[str, Any]:
     """Read the Uvicorn configuration JSON and return a dictionary."""
     global uvicorn_config
     import json
-    runtime = os.environ.get(STATIC_CONFIG['environment']['runtime'], None)
-    if runtime == 'api':
-        return get_config('system', 'api', 'uvicorn')
     _uvicorn_config = uvicorn_config
     with _locks['uvicorn_config']:
         if uvicorn_config is None:
@@ -85,6 +81,8 @@ def get_uvicorn_config() -> Dict[str, Any]:
                     uvicorn_config = json.load(f)
                 _uvicorn_config = uvicorn_config
             except Exception:
+                import traceback
+                traceback.print_exc()
                 _uvicorn_config = sys_config.get('uvicorn', None)
 
             if _uvicorn_config is None:
@@ -102,6 +100,10 @@ production = get_uvicorn_config().get('production', False)
 _include_dash = (not no_dash)
 _include_webterm = (not no_webterm) and _include_dash
 docs_enabled = not production or sys_config.get('endpoints', {}).get('docs_in_production', True)
+webterm_port = (
+    get_uvicorn_config().get('webterm_port', None)
+    or mrsm.get_config('api', 'webterm', 'port')
+)
 
 default_instance_keys = None
 _instance_connectors = defaultdict(lambda: None)
@@ -129,7 +131,7 @@ def get_api_connector(instance_keys: Optional[str] = None):
     )
     found_match: bool = False
     for allowed_keys_pattern in allowed_instance_keys:
-        if fnmatch(instance_keys, allowed_keys_pattern):
+        if fnmatch(str(instance_keys), allowed_keys_pattern):
             found_match = True
             break
     if not found_match:
@@ -141,7 +143,9 @@ def get_api_connector(instance_keys: Optional[str] = None):
         if _instance_connectors[instance_keys] is None:
             try:
                 is_valid_connector = True
-                _instance_connectors[instance_keys] = parse_instance_keys(instance_keys, debug=debug)
+                instance_connector = parse_instance_keys(instance_keys, debug=debug)
+                instance_connector._cache_connector = get_cache_connector()
+                _instance_connectors[instance_keys] = instance_connector
             except Exception:
                 is_valid_connector = False
 
@@ -168,7 +172,7 @@ def get_cache_connector(connector_keys: Optional[str] = None):
         return None
 
     connector_keys = connector_keys or get_config(
-        'system', 'api', 'cache', 'connector',
+        'api', 'cache', 'connector',
         warn=False,
     )
     if connector_keys is None:
@@ -196,7 +200,11 @@ def pipes(instance_keys: Optional[str] = None, refresh: bool = False) -> PipesDi
     with _locks['pipes-' + instance_keys]:
         pipes = _instance_pipes[instance_keys]
         if pipes is None or refresh:
-            pipes = _get_pipes(mrsm_instance=instance_keys)
+            pipes = _get_pipes(
+                mrsm_instance=instance_keys,
+                cache=True,
+                cache_connector_keys=get_cache_connector(),
+            )
             _instance_pipes[instance_keys] = pipes
     return pipes
 
@@ -218,9 +226,23 @@ def get_pipe(
             detail="Unable to serve any pipes with connector keys `mrsm` over the API.",
         )
 
-    pipe = mrsm.Pipe(connector_keys, metric_key, location_key, mrsm_instance=instance_keys)
-    if is_pipe_registered(pipe, pipes(instance_keys, refresh=False)):
-        return pipes(instance_keys, refresh=refresh)[connector_keys][metric_key][location_key]
+    pipes_dict = pipes(instance_keys)
+    if (
+        not refresh
+        and connector_keys in pipes_dict
+        and metric_key in pipes_dict[connector_keys]
+        and location_key in pipes_dict[connector_keys][metric_key]
+    ):
+        return pipes_dict[connector_keys][metric_key][location_key]
+
+    pipe = mrsm.Pipe(
+        connector_keys,
+        metric_key,
+        location_key,
+        mrsm_instance=instance_keys,
+        cache=True,
+        cache_connector_keys=get_cache_connector(),
+    )
     return pipe
 
 

meerschaum/api/_events.py

@@ -8,13 +8,13 @@ Declare FastAPI events in this module (startup, shutdown, etc.).
 
 import sys
 import os
-import time
 from meerschaum.api import (
     app,
     get_api_connector,
     get_cache_connector,
     get_uvicorn_config,
     debug,
+    webterm_port,
     no_dash,
     _include_dash,
     _include_webterm,
@@ -75,7 +75,7 @@ async def startup():
     try:
         if _include_webterm:
             from meerschaum.api.dash.webterm import start_webterm
-            start_webterm()
+            start_webterm(webterm_port=webterm_port)
 
         connected = retry_connect(
             get_api_connector(),

meerschaum/api/_oauth2.py

@@ -21,6 +21,7 @@ from meerschaum.core import User, Token
 fastapi, starlette = attempt_import('fastapi', 'starlette', lazy=False, check_update=CHECK_UPDATE)
 fastapi_responses = attempt_import('fastapi.responses', lazy=False, check_update=CHECK_UPDATE)
 fastapi_login = attempt_import('fastapi_login', check_update=CHECK_UPDATE)
+jose_jwt, jose_exceptions = attempt_import('jose.jwt', 'jose.exceptions', lazy=False, check_update=CHECK_UPDATE)
 from fastapi import Depends, HTTPException, Request
 from starlette import status
 
@@ -91,6 +92,7 @@ async def load_user_or_token(
             status_code=status.HTTP_401_UNAUTHORIZED,
             detail="Not authenticated.",
         )
+
     authorization = authorization.replace('Basic ', '').replace('Bearer ', '')
     if not authorization.startswith('mrsm-key:'):
         if not users:
@@ -98,12 +100,15 @@ async def load_user_or_token(
                 status=status.HTTP_401_UNAUTHORIZED,
                 detail="Users not authenticated for this endpoint.",
             )
+
         return await manager(request)
+
     if not tokens:
         raise HTTPException(
             status_code=status.HTTP_401_UNAUTHORIZED,
             detail="Tokens not authenticated for this endpoint.",
         )
+
     return get_token_from_authorization(authorization)
 
 
@@ -112,6 +117,7 @@ def ScopedAuth(scopes: List[str]):
     Dependency factory for authenticating with either a user session or a scoped token.
     """
     async def _authenticate(
+        request: Request,
         user_or_token: Union[User, Token, None] = Depends(
             load_user_or_token,
         ),
@@ -126,12 +132,45 @@ def ScopedAuth(scopes: List[str]):
                 headers={"WWW-Authenticate": "Basic"},
             )
 
-        fresh_scopes = user_or_token.get_scopes(refresh=True, debug=debug)
-        if '*' in fresh_scopes:
+        authorization = request.headers.get('authorization', request.headers.get('Authorization', None))
+        is_long_lived = authorization and 'mrsm-key:' in authorization
+
+        current_scopes = []
+        ### For long-lived API tokens, always hit the database.
+        if is_long_lived:
+            current_scopes = user_or_token.get_scopes(refresh=True, debug=debug)
+        
+        ### For JWTs, trust the scopes in the token.
+        else:
+            if not authorization:
+                # This should be caught by `load_user_or_token` but we can be safe.
+                raise HTTPException(
+                    status_code=status.HTTP_401_UNAUTHORIZED,
+                    detail="Not authenticated.",
+                )
+            
+            scheme, _, token_str = authorization.partition(' ')
+            if not token_str or scheme.lower() != 'bearer':
+                raise HTTPException(
+                    status_code=status.HTTP_401_UNAUTHORIZED,
+                    detail="Unsupported authentication scheme.",
+                )
+
+            try:
+                payload = jose_jwt.decode(token_str, SECRET, algorithms=['HS256'])
+                current_scopes = payload.get('scopes', [])
+            except jose_exceptions.JWTError:
+                raise HTTPException(
+                    status_code=status.HTTP_401_UNAUTHORIZED,
+                    detail="Invalid access token.",
+                    headers={"WWW-Authenticate": "Bearer"},
+                )
+
+        if '*' in current_scopes:
             return user_or_token
 
         for scope in scopes:
-            if scope not in fresh_scopes:
+            if scope not in current_scopes:
                 raise HTTPException(
                     status_code=status.HTTP_403_FORBIDDEN,
                     detail=f"Missing required scope: '{scope}'",
@@ -159,4 +198,8 @@ def generate_secret_key() -> bytes:
 
 
 SECRET = generate_secret_key()
-manager = LoginManager(SECRET, token_url=endpoints['login'])
+manager = LoginManager(
+    SECRET,
+    token_url=endpoints['login'],
+    scopes=STATIC_CONFIG['tokens']['scopes'],
+)

meerschaum/api/dash/callbacks/dashboard.py

@@ -1193,3 +1193,32 @@ def toggle_pages_offcanvas(n_clicks: Optional[int], is_open: bool):
     if n_clicks:
         return not is_open, pages_children
     return is_open, pages_children
+
+
+@dash_app.callback(
+    Output({'type': 'calculate-rowcount-div', 'index': MATCH}, 'children'),
+    Input({'type': 'calculate-rowcount-button', 'index': MATCH}, 'n_clicks'),
+    prevent_initial_call=True,
+)
+def calculate_rowcount_button_click(n_clicks: int):
+    """
+    Calculate the rowcount for the pipe.
+    """
+    if not n_clicks:
+        raise PreventUpdate
+
+    triggered = dash.callback_context.triggered
+    if triggered[0]['value'] is None:
+        raise PreventUpdate
+
+    pipe = pipe_from_ctx(triggered, 'n_clicks')
+    if pipe is None:
+        raise PreventUpdate
+
+    try:
+        rowcount = pipe.get_rowcount(debug=debug)
+        return f"{rowcount:,}"
+    except Exception as e:
+        return (
+            alert_from_success_tuple((False, f"Failed to calculate row count: {e}"))
+        )

meerschaum/api/dash/callbacks/jobs.py

@@ -13,6 +13,7 @@ import time
 import traceback
 from datetime import datetime, timezone
 
+import meerschaum as mrsm
 from meerschaum.jobs import get_jobs
 from meerschaum.utils.typing import Optional, Dict, Any
 from meerschaum.api import CHECK_UPDATE
@@ -136,12 +137,12 @@ def manage_job_button_click(
     old_status = job.status
     try:
         success, msg = manage_functions[manage_job_action]()
-    except Exception as e:
+    except Exception:
         success, msg = False, traceback.format_exc()
 
     ### Wait for a status change before building the elements.
     timeout_seconds = 1.0
-    check_interval_seconds = 0.01
+    check_interval_seconds = mrsm.get_config('system', 'cli', 'refresh_seconds')
     begin = time.perf_counter()
     while (time.perf_counter() - begin) < timeout_seconds:
         if job.status != old_status:

meerschaum/api/dash/callbacks/login.py

@@ -16,11 +16,14 @@ from meerschaum.utils.typing import Optional
 dash = attempt_import('dash', lazy=False, check_update=CHECK_UPDATE)
 from dash.exceptions import PreventUpdate
 from dash.dependencies import Input, Output, State
+
 from meerschaum.api.dash import dash_app, debug, pipes, _get_pipes
 from meerschaum.api.dash.sessions import set_session
 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 meerschaum.api._oauth2 import CustomOAuth2PasswordRequestForm
+from meerschaum._internal.static import STATIC_CONFIG
 from fastapi_login.exceptions import InvalidCredentialsException
 from fastapi.exceptions import HTTPException
 dbc = attempt_import('dash_bootstrap_components', lazy=False, check_update=CHECK_UPDATE)
@@ -73,7 +76,13 @@ def login_button_click(
         raise PreventUpdate
 
     try:
-        _ = login({'username': username, 'password': password})
+        form = CustomOAuth2PasswordRequestForm(
+            grant_type='password',
+            username=username,
+            password=password,
+            scope=' '.join(STATIC_CONFIG['tokens']['scopes'])
+        )
+        _ = login(form)
         session_id = str(uuid.uuid4())
         session_data = {
             'session-id': session_id,