meerschaum 2.9.5__py3-none-any.whl → 3.0.0rc2__py3-none-any.whl

meerschaum/connectors/api/_tokens.py

@@ -0,0 +1,146 @@
+#! /usr/bin/env python3
+# vim:fenc=utf-8
+
+"""
+Implement the `APIConnector` token methods.
+"""
+
+import json
+import uuid
+from datetime import datetime
+from typing import Union, List, Optional
+
+import meerschaum as mrsm
+from meerschaum.core import Token
+from meerschaum._internal.static import STATIC_CONFIG
+tokens_endpoint = STATIC_CONFIG['api']['endpoints']['tokens']
+
+
+def register_token(self, token: Token, debug: bool = False) -> mrsm.SuccessTuple:
+    """
+    Register the provided token to the API.
+    """
+    from meerschaum.utils.dtypes import json_serialize_value
+    r_url = tokens_endpoint + '/register'
+    response = self.post(
+        r_url,
+        data=json.dumps({
+            'label': token.label,
+            'scopes': token.scopes,
+            'expiration': token.expiration,
+        }, default=json_serialize_value),
+        debug=debug,
+    )
+    if not response:
+        return False, f"Failed to register token:\n{response.text}"
+
+    data = response.json()
+    token.label = data['label']
+    token.secret = data['secret']
+    token.id = uuid.UUID(data['id'])
+    if data.get('expiration', None):
+        token.expiration = datetime.fromisoformat(data['expiration'])
+
+    return True, f"Registered token '{token.label}'."
+
+
+def get_token_model(self, token_id: uuid.UUID, debug: bool = False) -> 'Union[TokenModel, None]':
+    """
+    Return a token's model from the API instance.
+    """
+    from meerschaum.models import TokenModel
+    r_url = tokens_endpoint + f'/{token_id}'
+    response = self.get(r_url, debug=debug)
+    if not response:
+        return None
+    data = response.json()
+    return TokenModel(**data)
+
+
+def get_tokens(self, labels: Optional[List[str]] = None, debug: bool = False) -> List[Token]:
+    """
+    Return the tokens registered to the current user.
+    """
+    from meerschaum.utils.warnings import warn
+    r_url = tokens_endpoint
+    params = {}
+    if labels:
+        params['labels'] = ','.join(labels)
+    response = self.get(r_url, params={'labels': labels}, debug=debug)
+    if not response:
+        warn(f"Could not get tokens from '{self}':\n{response.text}")
+        return []
+
+    tokens = [
+        Token(instance=self, **payload)
+        for payload in response.json()
+    ]
+    return tokens
+
+
+def edit_token(self, token: Token, debug: bool = False) -> mrsm.SuccessTuple:
+    """
+    Persist the token's in-memory state to the API.
+    """
+    r_url = tokens_endpoint + f"/{token.id}/edit"
+    response = self.post(
+        r_url,
+        json={
+            'creation': token.creation.isoformat() if token.creation else None,
+            'expiration': token.expiration.isoformat() if token.expiration else None,
+            'label': token.label,
+            'is_valid': token.is_valid,
+            'scopes': token.scopes,
+        },
+    )
+    if not response:
+        return False, f"Failed to edit token:\n{response.text}"
+
+    success, msg = response.json()
+    return success, msg
+
+
+def invalidate_token(self, token: Token, debug: bool = False) -> mrsm.SuccessTuple:
+    """
+    Invalidate the token, disabling it for future requests.
+    """
+    r_url = tokens_endpoint + f"/{token.id}/invalidate"
+    response = self.post(r_url)
+    if not response:
+        return False, f"Failed to invalidate token:\n{response.text}"
+
+    success, msg = response.json()
+    return success, msg
+
+
+def get_token_scopes(self, token_id: Union[uuid.UUID, Token], debug: bool = False) -> List[str]:
+    """
+    Return the scopes for a token.
+    """
+    _token_id = (token_id.id if isinstance(token_id, Token) else token_id)
+    model = self.get_token_model(_token_id, debug=debug).scopes
+    return getattr(model, 'scopes', [])
+
+
+def token_exists(self, token_id: Union[uuid.UUID, Token], debug: bool = False) -> bool:
+    """
+    Return `True` if a token exists.
+    """
+    _token_id = (token_id.id if isinstance(token_id, Token) else token_id)
+    model = self.get_token_model(_token_id, debug=debug)
+    if model is None:
+        return False
+    return model.creation is not None
+
+
+def delete_token(self, token: Token, debug: bool = False) -> mrsm.SuccessTuple:
+    """
+    Delete the token from the API.
+    """
+    r_url = tokens_endpoint + f"/{token.id}"
+    response = self.delete(r_url, debug=debug)
+    if not response:
+        return False, f"Failed to delete token:\n{response.text}"
+    
+    success, msg = response.json()
+    return success, msg

meerschaum/connectors/api/_users.py

@@ -7,18 +7,23 @@ Manage users via the API Connector.
 """
 
 from __future__ import annotations
-from meerschaum.utils.typing import Optional, Any, List, SuccessTuple
+
+import json
+from uuid import UUID
+
+import meerschaum as mrsm
+from meerschaum.utils.typing import Optional, Any, List, SuccessTuple, Union
+
 
 def get_users(
-        self,
-        debug: bool = False,
-        **kw : Any
-    ) -> List[str]:
+    self,
+    debug: bool = False,
+    **kw: Any
+) -> List[str]:
     """
     Return a list of registered usernames.
     """
-    from meerschaum.config.static import STATIC_CONFIG
-    import json
+    from meerschaum._internal.static import STATIC_CONFIG
     response = self.get(
         f"{STATIC_CONFIG['api']['endpoints']['users']}",
         debug = debug,
@@ -31,15 +36,15 @@ def get_users(
     except Exception as e:
         return []
 
+
 def edit_user(
-        self,
-        user: 'meerschaum.core.User',
-        debug: bool = False,
-        **kw: Any
-    ) -> SuccessTuple:
+    self,
+    user: mrsm.core.User,
+    debug: bool = False,
+    **kw: Any
+) -> SuccessTuple:
     """Edit an existing user."""
-    import json
-    from meerschaum.config.static import STATIC_CONFIG
+    from meerschaum._internal.static import STATIC_CONFIG
     r_url = f"{STATIC_CONFIG['api']['endpoints']['users']}/edit"
     data = {
         'username': user.username,
@@ -54,7 +59,7 @@ def edit_user(
         if isinstance(_json, dict) and 'detail' in _json:
             return False, _json['detail']
         success_tuple = tuple(_json)
-    except Exception as e:
+    except Exception:
         msg = response.text if response else f"Failed to edit user '{user}'."
         return False, msg
 
@@ -62,14 +67,13 @@ def edit_user(
 
 
 def register_user(
-        self,
-        user: 'meerschaum.core.User',
-        debug: bool = False,
-        **kw: Any
-    ) -> SuccessTuple:
+    self,
+    user: mrsm.core.User,
+    debug: bool = False,
+    **kw: Any
+) -> SuccessTuple:
     """Register a new user."""
-    import json
-    from meerschaum.config.static import STATIC_CONFIG
+    from meerschaum._internal.static import STATIC_CONFIG
     r_url = f"{STATIC_CONFIG['api']['endpoints']['users']}/register"
     data = {
         'username': user.username,
@@ -94,31 +98,37 @@ def register_user(
 
     
 def get_user_id(
-        self,
-        user: 'meerschaum.core.User',
-        debug: bool = False,
-        **kw: Any
-    ) -> Optional[int]:
+    self,
+    user: mrsm.core.User,
+    debug: bool = False,
+    **kw: Any
+) -> Union[int, str, UUID, None]:
     """Get a user's ID."""
-    from meerschaum.config.static import STATIC_CONFIG
-    import json
+    from meerschaum._internal.static import STATIC_CONFIG
+    from meerschaum.utils.misc import is_int, is_uuid
     r_url = f"{STATIC_CONFIG['api']['endpoints']['users']}/{user.username}/id"
     response = self.get(r_url, debug=debug, **kw)
     try:
-        user_id = int(json.loads(response.text))
+        id_text = str(json.loads(response.text))
+        if is_int(id_text):
+            user_id = int(id_text)
+        elif is_uuid(id_text):
+            user_id = UUID(id_text)
+        else:
+            user_id = id_text
     except Exception as e:
         user_id = None
     return user_id
 
+
 def delete_user(
-        self,
-        user: 'meerschaum.core.User',
-        debug: bool = False,
-        **kw: Any
-    ) -> SuccessTuple:
+    self,
+    user: mrsm.core.User,
+    debug: bool = False,
+    **kw: Any
+) -> SuccessTuple:
     """Delete a user."""
-    from meerschaum.config.static import STATIC_CONFIG
-    import json
+    from meerschaum._internal.static import STATIC_CONFIG
     r_url = f"{STATIC_CONFIG['api']['endpoints']['users']}/{user.username}"
     response = self.delete(r_url, debug=debug)
     try:
@@ -126,53 +136,55 @@ def delete_user(
         if isinstance(_json, dict) and 'detail' in _json:
             return False, _json['detail']
         success_tuple = tuple(_json)
-    except Exception as e:
+    except Exception:
         success_tuple = False, f"Failed to delete user '{user.username}'."
     return success_tuple
 
+
 def get_user_attributes(
-        self,
-        user: 'meerschaum.core.User',
-        debug: bool = False,
-        **kw
-    ) -> int:
+    self,
+    user: mrsm.core.User,
+    debug: bool = False,
+    **kw
+) -> int:
     """Get a user's attributes."""
-    from meerschaum.config.static import STATIC_CONFIG
-    import json
+    from meerschaum._internal.static import STATIC_CONFIG
     r_url = f"{STATIC_CONFIG['api']['endpoints']['users']}/{user.username}/attributes"
     response = self.get(r_url, debug=debug, **kw)
     try:
         attributes = json.loads(response.text)
-    except Exception as e:
+    except Exception:
         attributes = None
     return attributes
 
+
 #############################
 # Chaining functions below. #
 #############################
 
 def get_user_password_hash(
-        self,
-        user: 'meerschaum.core.User',
-        debug: bool = False,
-        **kw: Any
-    ) -> Optional[str]:
+    self,
+    user: mrsm.core.User,
+    debug: bool = False,
+    **kw: Any
+) -> Optional[str]:
     """If configured, get a user's password hash."""
-    from meerschaum.config.static import STATIC_CONFIG
+    from meerschaum._internal.static import STATIC_CONFIG
     r_url = STATIC_CONFIG['api']['endpoints']['users'] + '/' + user.username + '/password_hash'
     response = self.get(r_url, debug=debug, **kw)
     if not response:
         return None
     return response.json()
 
+
 def get_user_type(
-        self,
-        user: 'meerschaum.core.User',
-        debug: bool = False,
-        **kw: Any
-    ) -> Optional[str]:
+    self,
+    user: mrsm.core.User,
+    debug: bool = False,
+    **kw: Any
+) -> Optional[str]:
     """If configured, get a user's type."""
-    from meerschaum.config.static import STATIC_CONFIG
+    from meerschaum._internal.static import STATIC_CONFIG
     r_url = STATIC_CONFIG['api']['endpoints']['users'] + '/' + user.username + '/type'
     response = self.get(r_url, debug=debug, **kw)
     if not response:

meerschaum/connectors/instance/_InstanceConnector.py

@@ -0,0 +1,83 @@
+#! /usr/bin/env python3
+# vim:fenc=utf-8
+
+"""
+Define the interface for instance connectors.
+"""
+
+from __future__ import annotations
+
+import abc
+from typing import Any, Union, Dict, List, Tuple, Optional
+
+import meerschaum as mrsm
+from meerschaum.connectors._Connector import Connector
+
+
+class InstanceConnector(Connector):
+    """
+    Instance connectors define the interface for managing pipes and provide methods
+    for management of users, plugins, tokens, and other metadata built atop pipes.
+    """
+
+    IS_INSTANCE: bool = True
+    IS_THREAD_SAFE: bool = False
+
+    from ._users import (
+        get_users_pipe,
+        register_user,
+        get_user_id,
+        get_username,
+        get_users,
+        edit_user,
+        delete_user,
+        get_user_password_hash,
+        get_user_type,
+        get_user_attributes,
+    )
+
+    from ._plugins import (
+        get_plugins_pipe,
+        register_plugin,
+        get_plugin_user_id,
+        delete_plugin,
+        get_plugin_id,
+        get_plugin_version,
+        get_plugins,
+        get_plugin_user_id,
+        get_plugin_username,
+        get_plugin_attributes,
+    )
+
+    from ._tokens import (
+        get_tokens_pipe,
+        register_token,
+        edit_token,
+        invalidate_token,
+        delete_token,
+        get_token,
+        get_tokens,
+        get_token_model,
+        get_token_secret_hash,
+        token_exists,
+        get_token_scopes,
+    )
+
+    from ._pipes import (
+        register_pipe,
+        get_pipe_attributes,
+        get_pipe_id,
+        edit_pipe,
+        delete_pipe,
+        fetch_pipes_keys,
+        pipe_exists,
+        drop_pipe,
+        drop_pipe_indices,
+        sync_pipe,
+        create_pipe_indices,
+        clear_pipe,
+        get_pipe_data,
+        get_sync_time,
+        get_pipe_columns_types,
+        get_pipe_columns_indices,
+    )

meerschaum/connectors/instance/__init__.py

@@ -0,0 +1,10 @@
+#! /usr/bin/env python3
+# vim:fenc=utf-8
+
+"""
+Define high-level instance connector methods.
+"""
+
+from meerschaum.connectors.instance._InstanceConnector import InstanceConnector
+
+__all__ = ('InstanceConnector',)