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

meerschaum/connectors/__init__.py

@@ -14,7 +14,7 @@ For ease of use, you can also import from the root `meerschaum` module:
 from __future__ import annotations
 
 import meerschaum as mrsm
-from meerschaum.utils.typing import Any, Union, List, Dict
+from meerschaum.utils.typing import Any, Union, List, Dict, Optional
 from meerschaum.utils.threading import RLock
 from meerschaum.utils.warnings import warn
 
@@ -51,6 +51,7 @@ _locks: Dict[str, RLock] = {
     'connectors'               : RLock(),
     'types'                    : RLock(),
     'custom_types'             : RLock(),
+    'plugins_types'            : RLock(),
     '_loaded_plugin_connectors': RLock(),
     'instance_types'           : RLock(),
 }
@@ -58,6 +59,8 @@ _locks: Dict[str, RLock] = {
 ### Fill this with objects only when connectors are first referenced.
 types: Dict[str, Any] = {}
 custom_types: set = set()
+plugins_types: Dict[str, List[str]] = {}
+_known_custom_types: set = set()
 _loaded_plugin_connectors: bool = False
 
 
@@ -72,7 +75,6 @@ def get_connector(
     Return existing connector or create new connection and store for reuse.
     
     You can create new connectors if enough parameters are provided for the given type and flavor.
-    
 
     Parameters
     ----------
@@ -297,16 +299,23 @@ def make_connector(cls, _is_executor: bool = False):
     >>> 
     """
     import re
+    from meerschaum.plugins import _get_parent_plugin
     suffix_regex = (
         r'connector$'
         if not _is_executor
         else r'executor$'
     )
+    plugin_name = _get_parent_plugin(2)
     typ = re.sub(suffix_regex, '', cls.__name__.lower())
     with _locks['types']:
         types[typ] = cls
     with _locks['custom_types']:
         custom_types.add(typ)
+    if plugin_name:
+        with _locks['plugins_types']:
+            if plugin_name not in plugins_types:
+                plugins_types[plugin_name] = []
+            plugins_types[plugin_name].append(typ)
     with _locks['connectors']:
         if typ not in connectors:
             connectors[typ] = {}
@@ -337,6 +346,30 @@ def load_plugin_connectors():
     import_plugins(*to_import)
 
 
+def unload_plugin_connectors(
+    plugin_names: Optional[List[str]] = None,
+    debug: bool = False,
+) -> None:
+    """
+    Unload custom connectors added by plugins.
+    """
+    from meerschaum.plugins import get_plugins_names
+    global custom_types, _known_custom_types, types, plugins_types, connectors
+
+    plugin_names = plugin_names or get_plugins_names()
+
+    for plugin_name in plugin_names:
+        plugin_types = plugins_types.get(plugin_name, [])
+        for typ in plugin_types:
+            _ = types.pop(typ, None)
+            _ = connectors.pop(typ, None)
+            if typ in instance_types:
+                instance_types.remove(typ)
+
+    custom_types.clear()
+    custom_types.update(_known_custom_types)
+
+
 def get_connector_plugin(
     connector: Connector,
 ) -> Union[str, None, mrsm.Plugin]:
@@ -373,3 +406,5 @@ def _load_builtin_custom_connectors():
     """
     import meerschaum.jobs.systemd
     import meerschaum.connectors.valkey
+    _known_custom_types.add('valkey')
+    _known_custom_types.add('systemd')

meerschaum/connectors/api/_APIConnector.py

@@ -233,4 +233,4 @@ class APIConnector(InstanceConnector):
         elif 'api_key' in self.__dict__:
             return 'api_key'
 
-        raise ValueError(f"Could not determine the login scheme for '{self}'.")
+        return 'password'

meerschaum/connectors/api/_jobs.py

@@ -380,3 +380,14 @@ def get_job_is_blocking_on_stdin(self, name: str, debug: bool = False) -> bool:
         return False
 
     return response.json()
+
+
+def get_job_prompt_kwargs(self, name: str, debug: bool = False) -> Dict[str, Any]:
+    """
+    Return the kwargs to the blocking `prompt()`, if available.
+    """
+    response = self.get(JOBS_ENDPOINT + f'/{name}/prompt_kwargs', debug=debug)
+    if not response:
+        return {}
+
+    return response.json()

meerschaum/connectors/api/_pipes.py

@@ -112,7 +112,13 @@ def fetch_pipes_keys(
     tags: Optional[List[str]] = None,
     params: Optional[Dict[str, Any]] = None,
     debug: bool = False
-) -> Union[List[Tuple[str, str, Union[str, None]]]]:
+) -> List[
+        Union[
+            Tuple[str, str, Union[str, None]],
+            Tuple[str, str, Union[str, None], List[str]],
+            Tuple[str, str, Union[str, None], Dict[str, Any]]
+        ]
+    ]:
     """
     Fetch registered Pipes' keys from the API.
     

meerschaum/connectors/instance/_plugins.py

@@ -16,13 +16,20 @@ def get_plugins_pipe(self) -> 'mrsm.Pipe':
     """
     Return the internal pipe for syncing plugins metadata.
     """
+    if '_plugins_pipe' in self.__dict__:
+        return self._plugins_pipe
+
+    cache_connector = self.__dict__.get('_cache_connector', None)
     users_pipe = self.get_users_pipe()
     user_id_dtype = users_pipe.dtypes.get('user_id', 'uuid')
-    return mrsm.Pipe(
+
+    self._plugins_pipe = mrsm.Pipe(
         'mrsm', 'plugins',
         instance=self,
         target='mrsm_plugins',
         temporary=True,
+        cache=True,
+        cache_connector_keys=cache_connector,
         static=True,
         null_indices=False,
         columns={
@@ -36,6 +43,7 @@ def get_plugins_pipe(self) -> 'mrsm.Pipe':
             'version': 'string',
         },
     )
+    return self._plugins_pipe
 
 
 def register_plugin(self, plugin: Plugin, debug: bool = False) -> mrsm.SuccessTuple:

meerschaum/connectors/instance/_tokens.py

@@ -15,23 +15,33 @@ import meerschaum as mrsm
 from meerschaum.core import Token, User
 from meerschaum.core.User import hash_password
 from meerschaum._internal.static import STATIC_CONFIG
+from meerschaum.utils.warnings import dprint
 
 
 def get_tokens_pipe(self) -> mrsm.Pipe:
     """
     Return the internal pipe for tokens management.
     """
+    if '_tokens_pipe' in self.__dict__:
+        return self._tokens_pipe
+
     users_pipe = self.get_users_pipe()
-    user_id_dtype = users_pipe.dtypes.get('user_id', 'uuid')
+    user_id_dtype = (
+        users_pipe._attributes.get('parameters', {}).get('dtypes', {}).get('user_id', 'uuid')
+    )
+
+    cache_connector = self.__dict__.get('_cache_connector', None)
 
-    return mrsm.Pipe(
+    self._tokens_pipe = mrsm.Pipe(
         'mrsm', 'tokens',
         instance=self,
         target='mrsm_tokens',
         temporary=True,
+        cache=True,
+        cache_connector_keys=cache_connector,
         static=True,
         autotime=True,
-        null_indices=True,
+        null_indices=False,
         columns={
             'datetime': 'creation',
             'primary': 'id',
@@ -51,6 +61,7 @@ def get_tokens_pipe(self) -> mrsm.Pipe:
             'secret_hash': 'string',
         },
     )
+    return self._tokens_pipe
 
 
 def register_token(
@@ -200,10 +211,16 @@ def get_tokens(
     if ids:
         params['id'] = ids
         
+    if debug:
+        dprint(f"Getting tokens with {user_id=}, {params=}")
+
     tokens_df = tokens_pipe.get_data(params=params, debug=debug)
     if tokens_df is None:
         return []
 
+    if debug:
+        dprint(f"Retrieved tokens dataframe:\n{tokens_df}")
+
     tokens_docs = tokens_df.to_dict(orient='records')
     return [
         Token(

meerschaum/connectors/instance/_users.py

@@ -18,11 +18,17 @@ def get_users_pipe(self) -> 'mrsm.Pipe':
     """
     Return the pipe used for users registration.
     """
-    return mrsm.Pipe(
+    if '_users_pipe' in self.__dict__:
+        return self._users_pipe
+
+    cache_connector = self.__dict__.get('_cache_connector', None)
+    self._users_pipe = mrsm.Pipe(
         'mrsm', 'users',
         instance=self,
         target='mrsm_users',
         temporary=True,
+        cache=True,
+        cache_connector_keys=cache_connector,
         static=True,
         null_indices=False,
         columns={
@@ -40,6 +46,7 @@ def get_users_pipe(self) -> 'mrsm.Pipe':
             'unique': 'username',
         },
     )
+    return self._users_pipe
 
 
 def register_user(

meerschaum/connectors/parse.py

@@ -111,7 +111,7 @@ def parse_repo_keys(keys: Optional[str] = None, **kw):
     """Parse the Meerschaum repository value into an APIConnector."""
     from meerschaum.config import get_config
     if keys is None:
-        keys = get_config('meerschaum', 'default_repository', patch=True)
+        keys = get_config('meerschaum', 'repository', patch=True)
     keys = str(keys)
     if ':' not in keys:
         keys = 'api:' + keys

meerschaum/connectors/sql/_create_engine.py

@@ -78,6 +78,9 @@ def create_engine(
     _host = self.__dict__.get('host', None)
     _port = self.__dict__.get('port', None)
     _database = self.__dict__.get('database', None)
+    if _database == '{SQLITE_DB_PATH}':
+        from meerschaum.config.paths import SQLITE_DB_PATH
+        _database = SQLITE_DB_PATH.as_posix()
     _options = self.__dict__.get('options', {})
     if isinstance(_options, str):
         _options = dict(urllib.parse.parse_qsl(_options))