meerschaum 2.3.6__py3-none-any.whl → 2.4.0.dev0__py3-none-any.whl

meerschaum/connectors/valkey/_plugins.py

@@ -0,0 +1,265 @@
+#! /usr/bin/env python3
+# vim:fenc=utf-8
+
+"""
+Define methods for registering plugins.
+"""
+
+from __future__ import annotations
+
+import json
+
+import meerschaum as mrsm
+from meerschaum.utils.typing import Optional, Any, List, SuccessTuple, Dict, Union
+
+PLUGINS_TABLE: str = "mrsm_plugins"
+PLUGIN_PREFIX: str = "mrsm_plugin"
+
+
+def get_plugins_pipe(self) -> mrsm.Pipe:
+    """
+    Return the pipe to store the plugins.
+    """
+    return mrsm.Pipe(
+        'mrsm', 'plugins',
+        columns=['plugin_name'],
+        temporary=True,
+        target=PLUGINS_TABLE,
+        instance=self,
+    )
+
+
+@classmethod
+def get_plugin_key(cls, plugin_name: str, sub_key: str) -> str:
+    """
+    Return the key for a plugin's attribute.
+    """
+    return cls.get_entity_key(PLUGIN_PREFIX, plugin_name, sub_key)
+
+
+@classmethod
+def get_plugin_keys_vals(
+    cls,
+    plugin: 'mrsm.core.Plugin',
+    mutable_only: bool = False,
+) -> Dict[str, str]:
+    """
+    Return a dictionary containing keys and values to set for the plugin.
+
+    Parameters
+    ----------
+    plugin: mrsm.core.Plugin
+        The plugin for which to generate the keys.
+
+    mutable_only: bool, default False
+        If `True`, only return keys which may be edited.
+
+    Returns
+    -------
+    A dictionary mapping a plugins's keys to values.
+    """
+    plugin_attributes_str = json.dumps(plugin.attributes, separators=(',', ':'))
+    mutable_keys_vals = {
+        cls.get_plugin_key(plugin.name, 'attributes'): plugin_attributes_str,
+        cls.get_plugin_key(plugin.name, 'version'): plugin.version,
+    }
+    if mutable_only:
+        return mutable_keys_vals
+
+    immutable_keys_vals = {
+        cls.get_plugin_key(plugin.name, 'user_id'): plugin.user_id,
+    }
+
+    return {**immutable_keys_vals, **mutable_keys_vals}
+
+
+def register_plugin(
+    self,
+    plugin: 'mrsm.core.Plugin',
+    force: bool = False,
+    debug: bool = False,
+    **kw: Any
+) -> SuccessTuple:
+    """Register a new plugin to the `mrsm_plugins` "table"."""
+    from meerschaum.utils.misc import generate_password
+
+    plugins_pipe = self.get_plugins_pipe()
+    keys_vals = self.get_plugin_keys_vals(plugin)
+
+    try:
+        sync_success, sync_msg = plugins_pipe.sync(
+            [
+                {
+                    'plugin_name': plugin.name,
+                    'user_id': plugin.user_id,
+                },
+            ],
+            check_existing=False,
+            debug=debug,
+        )
+        if not sync_success:
+            return sync_success, sync_msg
+
+        for key, val in keys_vals.items():
+            if val is not None:
+                self.set(key, val)
+
+        success, msg = True, "Success"
+    except Exception as e:
+        success = False
+        msg = f"Failed to register plugin '{plugin.name}':\n{e}"
+
+    if not success:
+        for key in keys_vals:
+            try:
+                self.client.delete(key)
+            except Exception:
+                pass
+
+    return success, msg
+
+
+def get_plugin_id(
+    self,
+    plugin: 'mrsm.core.Plugin',
+    debug: bool = False
+) -> Union[str, None]:
+    """
+    Return a plugin's ID.
+    """
+    return plugin.name
+
+
+def get_plugin_version(
+    self,
+    plugin: 'mrsm.core.Plugin',
+    debug: bool = False,
+) -> Union[str, None]:
+    """
+    Return a plugin's version.
+    """
+    version_key = self.get_plugin_key(plugin.name, 'version')
+
+    try:
+        return self.get(version_key)
+    except Exception:
+        return None
+
+
+def get_plugin_user_id(
+    self,
+    plugin: 'mrsm.core.Plugin',
+    debug: bool = False
+) -> Union[str, None]:
+    """
+    Return a plugin's user ID.
+    """
+    user_id_key = self.get_plugin_key(plugin.name, 'user_id')
+
+    try:
+        return self.get(user_id_key)
+    except Exception:
+        return None
+
+
+def get_plugin_username(
+    self,
+    plugin: 'mrsm.core.Plugin',
+    debug: bool = False
+) -> Union[str]:
+    """
+    Return the username of a plugin's owner.
+    """
+    user_id = self.get_plugin_user_id(plugin, debug=debug)
+    if user_id is None:
+        return None
+
+    username_key = self.get_user_key(user_id, 'username')
+    try:
+        return self.get(username_key)
+    except Exception:
+        return None
+
+
+def get_plugin_attributes(
+    self,
+    plugin: 'mrsm.core.Plugin',
+    debug: bool = False
+) -> Dict[str, Any]:
+    """
+    Return the attributes of a plugin.
+    """
+    attributes_key = self.get_plugin_key(plugin.name, 'attributes')
+    try:
+        attributes_str = self.get(attributes_key)
+        if not attributes_str:
+            return {}
+        return json.loads(attributes_str)
+    except Exception:
+        return {}
+
+
+def get_plugins(
+    self,
+    user_id: Optional[int] = None,
+    search_term: Optional[str] = None,
+    debug: bool = False,
+    **kw: Any
+) -> List[str]:
+    """
+    Return a list of plugin names.
+    """
+    plugins_pipe = self.get_plugins_pipe()
+    params = {}
+    if user_id:
+        params['user_id'] = user_id
+
+    df = plugins_pipe.get_data(['plugin_name'], params=params, debug=debug)
+    docs = df.to_dict(orient='records')
+
+    return [
+        doc['plugin_name']
+        for doc in docs
+        if (plugin_name := doc['plugin_name']).startswith(search_term or '')
+    ]
+
+
+def delete_plugin(
+    self,
+    plugin: 'mrsm.core.Plugin',
+    debug: bool = False,
+    **kw: Any
+) -> SuccessTuple:
+    """
+    Delete a plugin from the plugins table.
+    """
+    plugins_pipe = self.get_plugins_pipe()
+    clear_success, clear_msg = plugins_pipe.clear(params={'plugin_name': plugin.name}, debug=debug)
+    if not clear_success:
+        return clear_success, clear_msg
+
+    keys_vals = self.get_plugin_keys_vals(plugin)
+    try:
+        old_keys_vals = {
+            key: self.get(key)
+            for key in keys_vals
+        }
+    except Exception as e:
+        return False, f"Failed to delete plugin '{plugin.name}':\n{e}"
+
+    try:
+        for key in keys_vals:
+            self.client.delete(key)
+        success, msg = True, "Success"
+    except Exception as e:
+        success = False
+        msg = f"Failed to delete plugin '{plugin.name}':\n{e}"
+
+    if not success:
+        try:
+            for key, old_val in old_keys_vals.items():
+                self.set(key, old_val)
+        except Exception:
+            pass
+
+    return success, msg

meerschaum/connectors/valkey/_users.py

@@ -0,0 +1,305 @@
+#! /usr/bin/env python3
+# vim:fenc=utf-8
+
+"""
+Define methods for managing users.
+"""
+
+from __future__ import annotations
+
+import json
+
+import meerschaum as mrsm
+from meerschaum.utils.typing import Any, Union, SuccessTuple, Dict, List
+
+USERS_TABLE: str = 'mrsm_users'
+USER_PREFIX: str = 'mrsm_user'
+
+
+def get_users_pipe(self):
+    """
+    Return the pipe which stores the registered users.
+    """
+    return mrsm.Pipe(
+        'mrsm', 'users',
+        columns=['user_id'],
+        temporary=True,
+        target=USERS_TABLE,
+        instance=self,
+    )
+
+
+@classmethod
+def get_user_key(cls, user_id_or_username: str, sub_key: str, by_username: bool = False) -> str:
+    """
+    Return the key to store metadata about a user.
+
+    Parameters
+    ----------
+    user_id_or_username: str
+        The user ID or username of the given user.
+        If `by_username` is `True`, then provide the username.
+
+    sub_key: str
+        The key suffix, e.g. `'attributes'`.
+
+    by_username: bool, default False
+        If `True`, then treat `user_id_or_username` as a username.
+
+    Returns
+    -------
+    A key to store information about a user.
+
+    Examples
+    --------
+    >>> get_user_key('deadbeef', 'attributes')
+    'mrsm_user:user_id:deadbeef:attributes'
+    >>> get_user_key('foo', 'user_id', by_username=True)
+    'mrsm_user:username:foo:user_id'
+    """
+    key_type = 'user_id' if not by_username else 'username'
+    return cls.get_entity_key(USER_PREFIX, key_type, user_id_or_username, sub_key)
+
+
+@classmethod
+def get_user_keys_vals(
+    cls,
+    user: 'mrsm.core.User',
+    mutable_only: bool = False,
+) -> Dict[str, str]:
+    """
+    Return a dictionary containing keys and values to set for the user.
+
+    Parameters
+    ----------
+    user: mrsm.core.User
+        The user for which to generate the keys.
+
+    mutable_only: bool, default False
+        If `True`, only return keys which may be edited.
+
+    Returns
+    -------
+    A dictionary mapping a user's keys to values.
+    """
+    user_attributes_str = json.dumps(user.attributes, separators=(',', ':'))
+    mutable_keys_vals = {
+        cls.get_user_key(user.user_id, 'attributes'): user_attributes_str,
+        cls.get_user_key(user.user_id, 'email'): user.email,
+        cls.get_user_key(user.user_id, 'type'): user.type,
+        cls.get_user_key(user.user_id, 'password_hash'): user.password_hash,
+    }
+    if mutable_only:
+        return mutable_keys_vals
+
+    immutable_keys_vals = {
+        cls.get_user_key(user.user_id, 'username'): user.username,
+        cls.get_user_key(user.username, 'user_id', by_username=True): user.user_id,
+    }
+
+    return {**immutable_keys_vals, **mutable_keys_vals}
+
+
+def register_user(
+    self,
+    user: 'mrsm.core.User',
+    debug: bool = False,
+    **kwargs: Any
+) -> SuccessTuple:
+    """
+    Register a new user.
+    """
+    from meerschaum.utils.misc import generate_password
+
+    user.user_id = generate_password(12)
+    users_pipe = self.get_users_pipe()
+    keys_vals = self.get_user_keys_vals(user)
+
+    try:
+        sync_success, sync_msg = users_pipe.sync(
+            [
+                {
+                    'user_id': user.user_id,
+                    'username': user.username,
+                },
+            ],
+            check_existing=False,
+            debug=debug,
+        )
+        if not sync_success:
+            return sync_success, sync_msg
+
+        for key, val in keys_vals.items():
+            if val is not None:
+                self.set(key, val)
+
+        success, msg = True, "Success"
+    except Exception as e:
+        success = False
+        import traceback
+        traceback.print_exc()
+        msg = f"Failed to register '{user.username}':\n{e}"
+
+    if not success:
+        for key in keys_vals:
+            try:
+                self.client.delete(key)
+            except Exception:
+                pass
+
+    return success, msg
+
+
+def get_user_id(self, user: 'mrsm.core.User', debug: bool = False) -> Union[str, None]:
+    """
+    Return the ID for a user, or `None`.
+    """
+    username_user_id_key = self.get_user_key(user.username, 'user_id', by_username=True)
+    try:
+        user_id = self.get(username_user_id_key)
+    except Exception:
+        user_id = None
+    return user_id
+
+
+def edit_user(
+    self,
+    user: 'mrsm.core.User',
+    debug: bool = False,
+    **kw: Any
+) -> SuccessTuple:
+    """
+    Edit the attributes for an existing user.
+    """
+    keys_vals = self.get_user_keys_vals(user, mutable_only=True)
+    try:
+        old_keys_vals = {
+            key: self.get(key)
+            for key in keys_vals
+        }
+    except Exception as e:
+        return False, f"Failed to edit user:\n{e}"
+
+    try:
+        for key, val in keys_vals.items():
+            self.set(key, val)
+        success, msg = True, "Success"
+    except Exception as e:
+        success = False
+        msg = f"Failed to edit user:\n{e}"
+
+    if not success:
+        try:
+            for key, old_val in old_keys_vals.items():
+                self.set(key, old_val)
+        except Exception:
+            pass
+
+    return success, msg
+
+
+def get_user_attributes(
+    self,
+    user: 'mrsm.core.User',
+    debug: bool = False
+) -> Union[Dict[str, Any], None]:
+    """
+    Return the user's attributes.
+    """
+    user_id = user.user_id if user.user_id is not None else self.get_user_id(user, debug=debug)
+    user_id_attributes_key = self.get_user_key(user_id, 'attributes')
+    try:
+        return json.loads(self.get(user_id_attributes_key))
+    except Exception:
+        return None
+
+
+def delete_user(
+    self,
+    user: 'mrsm.core.User',
+    debug: bool = False
+) -> SuccessTuple:
+    """
+    Delete a user's keys.
+    """
+    user_id = user.user_id if user.user_id is not None else self.get_user_id(user, debug=debug)
+    users_pipe = self.get_users_pipe()
+    keys_vals = self.get_user_keys_vals(user)
+    try:
+        old_keys_vals = {
+            key: self.get(key)
+            for key in keys_vals
+        }
+    except Exception as e:
+        return False, f"Failed to delete user:\n{e}"
+
+    clear_success, clear_msg = users_pipe.clear(params={'user_id': user_id})
+    if not clear_success:
+        return clear_success, clear_msg
+
+    try:
+        for key in keys_vals:
+            self.client.delete(key)
+        success, msg = True, "Success"
+    except Exception as e:
+        success = False
+        msg = f"Failed to delete user:\n{e}"
+
+    if not success:
+        try:
+            for key, old_val in old_keys_vals.items():
+                self.set(key, old_val)
+        except Exception:
+            pass
+
+    return success, msg
+
+
+def get_users(
+    self,
+    debug: bool = False,
+    **kw: Any
+) -> List[str]:
+    """
+    Get the registered usernames.
+    """
+    users_pipe = self.get_users_pipe()
+    df = users_pipe.get_data()
+    if df is None:
+        return []
+
+    return list(df['username'])
+
+
+def get_user_password_hash(
+    self,
+    user: 'mrsm.core.User',
+    debug: bool = False,
+    **kw: Any
+) -> Union[str, None]:
+    """
+    Return the password has for a user.
+    """
+    user_id = user.user_id if user.user_id is not None else self.get_user_id(user, debug=debug)
+    user_id_password_hash_key = self.get_user_key(user_id, 'password_hash')
+    try:
+        return self.get(user_id_password_hash_key)
+    except Exception:
+        return None
+
+
+def get_user_type(
+    self,
+    user: 'mrsm.core.User',
+    debug: bool = False,
+    **kw: Any
+) -> Union[str, None]:
+    """
+    Return the user's type.
+    """
+    user_id = user.user_id if user.user_id is not None else self.get_user_id(user, debug=debug)
+    user_id_type_key = self.get_user_key(user_id, 'type')
+    try:
+        return self.get(user_id_type_key)
+    except Exception:
+        return None

meerschaum/core/Pipe/__init__.py

@@ -121,6 +121,8 @@ class Pipe:
         filter_existing,
         _get_chunk_label,
         get_num_workers,
+        _persist_new_json_columns,
+        _persist_new_numeric_columns,
     )
     from ._verify import (
         verify,

meerschaum/core/Pipe/_attributes.py

@@ -122,8 +122,7 @@ def dtypes(self) -> Union[Dict[str, Any], None]:
     configured_dtypes = self.parameters.get('dtypes', {})
     remote_dtypes = self.infer_dtypes(persist=False)
     patched_dtypes = apply_patch_to_config(remote_dtypes, configured_dtypes)
-    self.parameters['dtypes'] = patched_dtypes
-    return self.parameters['dtypes']
+    return patched_dtypes
 
 
 @dtypes.setter

meerschaum/core/Pipe/_drop.py

@@ -10,10 +10,10 @@ from __future__ import annotations
 from meerschaum.utils.typing import SuccessTuple, Any
 
 def drop(
-        self,
-        debug: bool = False,
-        **kw: Any
-    ) -> SuccessTuple:
+    self,
+    debug: bool = False,
+    **kw: Any
+) -> SuccessTuple:
     """
     Call the Pipe's instance connector's `drop_pipe()` method.
 

meerschaum/core/Pipe/_dtypes.py

@@ -16,12 +16,12 @@ if TYPE_CHECKING:
     pd = mrsm.attempt_import('pandas')
 
 def enforce_dtypes(
-        self,
-        df: 'pd.DataFrame',
-        chunksize: Optional[int] = -1,
-        safe_copy: bool = True,
-        debug: bool = False,
-    ) -> 'pd.DataFrame':
+    self,
+    df: 'pd.DataFrame',
+    chunksize: Optional[int] = -1,
+    safe_copy: bool = True,
+    debug: bool = False,
+) -> 'pd.DataFrame':
     """
     Cast the input dataframe to the pipe's registered data types.
     If the pipe does not exist and dtypes are not set, return the dataframe.
@@ -35,7 +35,7 @@ def enforce_dtypes(
     if df is None:
         if debug:
             dprint(
-                f"Received None instead of a DataFrame.\n"
+                "Received None instead of a DataFrame.\n"
                 + "    Skipping dtype enforcement..."
             )
         return df
@@ -46,24 +46,24 @@ def enforce_dtypes(
         if isinstance(df, str):
             df = parse_df_datetimes(
                 pd.read_json(StringIO(df)),
-                ignore_cols = [
+                ignore_cols=[
                     col
                     for col, dtype in pipe_dtypes.items()
                     if 'datetime' not in str(dtype)
                 ],
-                chunksize = chunksize,
-                debug = debug,
+                chunksize=chunksize,
+                debug=debug,
             )
         else:
             df = parse_df_datetimes(
                 df,
-                ignore_cols = [
+                ignore_cols=[
                     col
                     for col, dtype in pipe_dtypes.items()
                     if 'datetime' not in str(dtype)
                 ],
-                chunksize = chunksize,
-                debug = debug,
+                chunksize=chunksize,
+                debug=debug,
             )
     except Exception as e:
         warn(f"Unable to cast incoming data as a DataFrame...:\n{e}\n\n{traceback.format_exc()}")
@@ -80,7 +80,7 @@ def enforce_dtypes(
     return _enforce_dtypes(df, pipe_dtypes, safe_copy=safe_copy, debug=debug)
 
 
-def infer_dtypes(self, persist: bool=False, debug: bool=False) -> Dict[str, Any]:
+def infer_dtypes(self, persist: bool = False, debug: bool = False) -> Dict[str, Any]:
     """
     If `dtypes` is not set in `meerschaum.Pipe.parameters`,
     infer the data types from the underlying table if it exists.