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

meerschaum/connectors/sql/_pipes.py

@@ -25,7 +25,6 @@ def register_pipe(
     Register a new pipe.
     A pipe's attributes must be set before registering.
     """
-    from meerschaum.utils.debug import dprint
     from meerschaum.utils.packages import attempt_import
     from meerschaum.utils.sql import json_flavors
 
@@ -45,7 +44,7 @@ def register_pipe(
     ###    (which shouldn't be able to be registered anyway but that's an issue for later).
     parameters = None
     try:
-        parameters = pipe.parameters
+        parameters = pipe.get_parameters(apply_symlinks=False)
     except Exception as e:
         if debug:
             dprint(str(e))
@@ -76,7 +75,7 @@ def register_pipe(
 
 def edit_pipe(
     self,
-    pipe : mrsm.Pipe = None,
+    pipe: mrsm.Pipe,
     patch: bool = False,
     debug: bool = False,
     **kw : Any
@@ -108,10 +107,10 @@ def edit_pipe(
         original_parameters = Pipe(
             pipe.connector_keys, pipe.metric_key, pipe.location_key,
             mrsm_instance=pipe.instance_keys
-        ).parameters
+        ).get_parameters(apply_symlinks=False)
         parameters = apply_patch_to_config(
             original_parameters,
-            pipe.parameters
+            pipe._attributes['parameters']
         )
 
     ### ensure pipes table exists
@@ -170,11 +169,10 @@ def fetch_pipes_keys(
     debug: bool, default False
         Verbosity toggle.
     """
-    from meerschaum.utils.debug import dprint
     from meerschaum.utils.packages import attempt_import
     from meerschaum.utils.misc import separate_negation_values
     from meerschaum.utils.sql import OMIT_NULLSFIRST_FLAVORS, table_exists
-    from meerschaum.config.static import STATIC_CONFIG
+    from meerschaum._internal.static import STATIC_CONFIG
     import json
     from copy import deepcopy
     sqlalchemy, sqlalchemy_sql_functions = attempt_import(
@@ -338,7 +336,6 @@ def create_indices(
     """
     Create a pipe's indices.
     """
-    from meerschaum.utils.debug import dprint
     if debug:
         dprint(f"Creating indices for {pipe}...")
 
@@ -392,7 +389,6 @@ def drop_indices(
     """
     Drop a pipe's indices.
     """
-    from meerschaum.utils.debug import dprint
     if debug:
         dprint(f"Dropping indices for {pipe}...")
 
@@ -603,7 +599,10 @@ def get_create_index_queries(
     ### create datetime index
     dt_query = None
     if _datetime is not None:
-        if self.flavor == 'timescaledb' and pipe.parameters.get('hypertable', True):
+        if (
+            self.flavor in ('timescaledb', 'timescaledb-ha')
+            and pipe.parameters.get('hypertable', True)
+        ):
             _id_count = (
                 get_distinct_col_count(_id, f"SELECT {_id_name} FROM {_pipe_name}", self)
                 if (_id is not None and _create_space_partition) else None
@@ -719,7 +718,7 @@ def get_create_index_queries(
                         f"ADD CONSTRAINT {primary_key_constraint_name} PRIMARY KEY ({primary_key_name})"
                     )
                 ])
-            elif self.flavor == 'timescaledb':
+            elif self.flavor in ('timescaledb', 'timescaledb-ha'):
                 primary_queries.extend([
                     (
                         f"ALTER TABLE {_pipe_name}\n"
@@ -758,7 +757,7 @@ def get_create_index_queries(
 
     ### create id index
     if _id_name is not None:
-        if self.flavor == 'timescaledb':
+        if self.flavor in ('timescaledb', 'timescaledb-ha'):
             ### Already created indices via create_hypertable.
             id_query = (
                 None if (_id is not None and _create_space_partition)
@@ -797,7 +796,7 @@ def get_create_index_queries(
 
         cols_names_str = ", ".join(cols_names)
         index_query_params_clause = f" ({cols_names_str})"
-        if self.flavor == 'postgis':
+        if self.flavor in ('postgis', 'timescaledb-ha'):
             for col in cols:
                 col_typ = existing_cols_pd_types.get(cols[0], 'object')
                 if col_typ != 'object' and are_dtypes_equal(col_typ, 'geometry'):
@@ -1005,6 +1004,8 @@ def get_pipe_data(
     limit: Optional[int] = None,
     begin_add_minutes: int = 0,
     end_add_minutes: int = 0,
+    chunksize: Optional[int] = -1,
+    as_iterator: bool = False,
     debug: bool = False,
     **kw: Any
 ) -> Union[pd.DataFrame, None]:
@@ -1041,14 +1042,17 @@ def get_pipe_data(
         If specified, limit the number of rows retrieved to this value.
 
     begin_add_minutes: int, default 0
-        The number of minutes to add to the `begin` datetime (i.e. `DATEADD`.
+        The number of minutes to add to the `begin` datetime (i.e. `DATEADD`).
 
     end_add_minutes: int, default 0
-        The number of minutes to add to the `end` datetime (i.e. `DATEADD`.
+        The number of minutes to add to the `end` datetime (i.e. `DATEADD`).
 
     chunksize: Optional[int], default -1
         The size of dataframe chunks to load into memory.
 
+    as_iterator: bool, default False
+        If `True`, return the chunks iterator directly.
+
     debug: bool, default False
         Verbosity toggle.
 
@@ -1057,43 +1061,58 @@ def get_pipe_data(
     A `pd.DataFrame` of the pipe's data.
 
     """
-    import json
-    from meerschaum.utils.misc import parse_df_datetimes, to_pandas_dtype
+    import functools
     from meerschaum.utils.packages import import_pandas
-    from meerschaum.utils.dtypes import (
-        attempt_cast_to_numeric,
-        attempt_cast_to_uuid,
-        attempt_cast_to_bytes,
-        attempt_cast_to_geometry,
-        are_dtypes_equal,
-    )
+    from meerschaum.utils.dtypes import to_pandas_dtype, are_dtypes_equal
     from meerschaum.utils.dtypes.sql import get_pd_type_from_db_type
     pd = import_pandas()
     is_dask = 'dask' in pd.__name__
 
     cols_types = pipe.get_columns_types(debug=debug) if pipe.enforce else {}
+    pipe_dtypes = pipe.get_dtypes(infer=False, debug=debug) if pipe.enforce else {}
+
+    remote_pandas_types = {
+        col: to_pandas_dtype(get_pd_type_from_db_type(typ))
+        for col, typ in cols_types.items()
+    }
+    remote_dt_cols_types = {
+        col: typ
+        for col, typ in remote_pandas_types.items()
+        if are_dtypes_equal(typ, 'datetime')
+    }
+    remote_dt_tz_aware_cols_types = {
+        col: typ
+        for col, typ in remote_dt_cols_types.items()
+        if ',' in typ or typ == 'datetime'
+    }
+    remote_dt_tz_naive_cols_types = {
+        col: typ
+        for col, typ in remote_dt_cols_types.items()
+        if col not in remote_dt_tz_aware_cols_types
+    }
+
+    configured_pandas_types = {
+        col: to_pandas_dtype(typ)
+        for col, typ in pipe_dtypes.items()
+    }
+    configured_lower_precision_dt_cols_types = {
+        col: typ
+        for col, typ in pipe_dtypes.items()
+        if (
+            are_dtypes_equal('datetime', typ)
+            and '[' in typ
+            and 'ns' not in typ
+        )
+        
+    }
+
     dtypes = {
-        **{
-            p_col: to_pandas_dtype(p_typ)
-            for p_col, p_typ in pipe.dtypes.items()
-        },
-        **{
-            col: get_pd_type_from_db_type(typ)
-            for col, typ in cols_types.items()
-        }
+        **remote_pandas_types,
+        **configured_pandas_types,
+        **remote_dt_tz_aware_cols_types,
+        **remote_dt_tz_naive_cols_types,
+        **configured_lower_precision_dt_cols_types
     } if pipe.enforce else {}
-    if dtypes:
-        if self.flavor == 'sqlite':
-            if not pipe.columns.get('datetime', None):
-                _dt = pipe.guess_datetime()
-            else:
-                _dt = pipe.get_columns('datetime')
-
-            if _dt:
-                dt_type = dtypes.get(_dt, 'object').lower()
-                if 'datetime' not in dt_type:
-                    if 'int' not in dt_type:
-                        dtypes[_dt] = 'datetime64[ns, UTC]'
 
     existing_cols = cols_types.keys()
     select_columns = (
@@ -1110,13 +1129,20 @@ def get_pipe_data(
             and col not in (omit_columns or [])
         ]
     ) if pipe.enforce else select_columns
+
     if select_columns:
         dtypes = {col: typ for col, typ in dtypes.items() if col in select_columns}
+
     dtypes = {
-        col: to_pandas_dtype(typ)
+        col: typ
         for col, typ in dtypes.items()
-        if col in select_columns and col not in (omit_columns or [])
+        if col in (select_columns or [col]) and col not in (omit_columns or [])
     } if pipe.enforce else {}
+
+    if debug:
+        dprint(f"[{self}] `read()` dtypes:")
+        mrsm.pprint(dtypes)
+
     query = self.get_pipe_data_query(
         pipe,
         select_columns=select_columns,
@@ -1132,91 +1158,25 @@ def get_pipe_data(
         **kw
     )
 
+    read_kwargs = {}
     if is_dask:
         index_col = pipe.columns.get('datetime', None)
-        kw['index_col'] = index_col
+        read_kwargs['index_col'] = index_col
 
-    numeric_columns = [
-        col
-        for col, typ in pipe.dtypes.items()
-        if typ.startswith('numeric') and col in dtypes
-    ]
-    uuid_columns = [
-        col
-        for col, typ in pipe.dtypes.items()
-        if typ == 'uuid' and col in dtypes
-    ]
-    bytes_columns = [
-        col
-        for col, typ in pipe.dtypes.items()
-        if typ == 'bytes' and col in dtypes
-    ]
-    geometry_columns = [
-        col
-        for col, typ in pipe.dtypes.items()
-        if typ.startswith('geometry') and col in dtypes
-    ]
-
-    kw['coerce_float'] = kw.get('coerce_float', (len(numeric_columns) == 0))
-
-    df = self.read(
+    chunks = self.read(
         query,
+        chunksize=chunksize,
+        as_iterator=True,
+        coerce_float=False,
         dtype=dtypes,
         debug=debug,
-        **kw
+        **read_kwargs
     )
-    for col in numeric_columns:
-        if col not in df.columns:
-            continue
-        df[col] = df[col].apply(attempt_cast_to_numeric)
 
-    for col in uuid_columns:
-        if col not in df.columns:
-            continue
-        df[col] = df[col].apply(attempt_cast_to_uuid)
-
-    for col in bytes_columns:
-        if col not in df.columns:
-            continue
-        df[col] = df[col].apply(attempt_cast_to_bytes)
+    if as_iterator:
+        return chunks
 
-    for col in geometry_columns:
-        if col not in df.columns:
-            continue
-        df[col] = df[col].apply(attempt_cast_to_geometry)
-
-    if self.flavor == 'sqlite':
-        ignore_dt_cols = [
-            col
-            for col, dtype in pipe.dtypes.items()
-            if not are_dtypes_equal(str(dtype), 'datetime')
-        ]
-        ### NOTE: We have to consume the iterator here to ensure that datetimes are parsed correctly
-        df = (
-            parse_df_datetimes(
-                df,
-                ignore_cols=ignore_dt_cols,
-                chunksize=kw.get('chunksize', None),
-                strip_timezone=(pipe.tzinfo is None),
-                debug=debug,
-            ) if isinstance(df, pd.DataFrame) else (
-                [
-                    parse_df_datetimes(
-                        c,
-                        ignore_cols=ignore_dt_cols,
-                        chunksize=kw.get('chunksize', None),
-                        strip_timezone=(pipe.tzinfo is None),
-                        debug=debug,
-                    )
-                    for c in df
-                ]
-            )
-        )
-        for col, typ in dtypes.items():
-            if typ != 'json':
-                continue
-            df[col] = df[col].apply(lambda x: json.loads(x) if x is not None else x)
-    return df
+    return pd.concat(chunks)
 
 
 def get_pipe_data_query(
@@ -1419,7 +1379,7 @@ def get_pipe_data_query(
             if k in existing_cols or skip_existing_cols_check
         }
         if valid_params:
-            where += build_where(valid_params, self).replace(
+            where += '    ' + build_where(valid_params, self).lstrip().replace(
                 'WHERE', ('    AND' if is_dt_bound else "    ")
             )
 
@@ -1549,13 +1509,7 @@ def create_pipe_table_from_df(
     """
     Create a pipe's table from its configured dtypes and an incoming dataframe.
     """
-    from meerschaum.utils.dataframe import (
-        get_json_cols,
-        get_numeric_cols,
-        get_uuid_cols,
-        get_datetime_cols,
-        get_bytes_cols,
-    )
+    from meerschaum.utils.dataframe import get_special_cols
     from meerschaum.utils.sql import (
         get_create_table_queries,
         sql_item_name,
@@ -1584,30 +1538,7 @@ def create_pipe_table_from_df(
             for col_ix, col in pipe.columns.items()
             if col and col_ix != 'primary'
         },
-        **{
-            col: 'uuid'
-            for col in get_uuid_cols(df)
-        },
-        **{
-            col: 'json'
-            for col in get_json_cols(df)
-        },
-        **{
-            col: 'numeric'
-            for col in get_numeric_cols(df)
-        },
-        **{
-            col: 'bytes'
-            for col in get_bytes_cols(df)
-        },
-        **{
-            col: 'datetime64[ns, UTC]'
-            for col in get_datetime_cols(df, timezone_aware=True, timezone_naive=False)
-        },
-        **{
-            col: 'datetime64[ns]'
-            for col in get_datetime_cols(df, timezone_aware=False, timezone_naive=True)
-        },
+        **get_special_cols(df),
         **pipe.dtypes
     }
     autoincrement = (
@@ -1648,8 +1579,8 @@ def sync_pipe(
     self,
     pipe: mrsm.Pipe,
     df: Union[pd.DataFrame, str, Dict[Any, Any], None] = None,
-    begin: Optional[datetime] = None,
-    end: Optional[datetime] = None,
+    begin: Union[datetime, int, None] = None,
+    end: Union[datetime, int, None] = None,
     chunksize: Optional[int] = -1,
     check_existing: bool = True,
     blocking: bool = True,
@@ -1669,11 +1600,11 @@ def sync_pipe(
         An optional DataFrame or equivalent to sync into the pipe.
         Defaults to `None`.
 
-    begin: Optional[datetime], default None
+    begin: Union[datetime, int, None], default None
         Optionally specify the earliest datetime to search for data.
         Defaults to `None`.
 
-    end: Optional[datetime], default None
+    end: Union[datetime, int, None], default None
         Optionally specify the latest datetime to search for data.
         Defaults to `None`.
 
@@ -1759,18 +1690,16 @@ def sync_pipe(
             _ = pipe.__dict__.pop('_columns_types', None)
             if not self.exec_queries(alter_cols_queries, debug=debug):
                 warn(f"Failed to alter columns for {pipe}.")
-            else:
-                _ = pipe.infer_dtypes(persist=True)
 
     ### NOTE: Oracle SQL < 23c (2023) and SQLite does not support booleans,
     ### so infer bools and persist them to `dtypes`.
     if self.flavor in ('oracle', 'sqlite', 'mysql', 'mariadb'):
-        pipe_dtypes = pipe.dtypes
+        pipe_dtypes = pipe.get_dtypes(infer=False, debug=debug)
         new_bool_cols = {
             col: 'bool[pyarrow]'
             for col, typ in df.dtypes.items()
             if col not in pipe_dtypes
-            and are_dtypes_equal(str(typ), 'bool')
+                and are_dtypes_equal(str(typ), 'bool')
         }
         pipe_dtypes.update(new_bool_cols)
         pipe.dtypes = pipe_dtypes
@@ -1833,10 +1762,12 @@ def sync_pipe(
         )
     )
     if autoincrement and autoincrement not in pipe.parameters:
-        pipe.parameters['autoincrement'] = autoincrement
-        edit_success, edit_msg = pipe.edit(debug=debug)
-        if not edit_success:
-            return edit_success, edit_msg
+        update_success, update_msg = pipe.update_parameters(
+            {'autoincrement': autoincrement},
+            debug=debug,
+        )
+        if not update_success:
+            return update_success, update_msg
 
     def _check_pk(_df_to_clear):
         if _df_to_clear is None:
@@ -1969,7 +1900,11 @@ def sync_pipe(
             if col and col in existing_cols
         ] if not primary_key or self.flavor == 'oracle' else (
             [dt_col, primary_key]
-            if self.flavor == 'timescaledb' and dt_col and dt_col in update_df.columns
+            if (
+                self.flavor in ('timescaledb', 'timescaledb-ha')
+                and dt_col
+                and dt_col in update_df.columns
+            )
             else [primary_key]
         )
         update_queries = get_update_queries(
@@ -2779,7 +2714,6 @@ def pipe_exists(
         debug=debug,
     )
     if debug:
-        from meerschaum.utils.debug import dprint
         dprint(f"{pipe} " + ('exists.' if exists else 'does not exist.'))
     return exists
 
@@ -2833,7 +2767,6 @@ def get_pipe_rowcount(
             error(msg)
             return None
 
-
     flavor = self.flavor if not remote else pipe.connector.flavor
     conn = self if not remote else pipe.connector
     _pipe_name = sql_item_name(pipe.target, flavor, self.get_pipe_schema(pipe))
@@ -3117,11 +3050,17 @@ def get_pipe_columns_types(
             debug=debug,
         )
 
+    if debug:
+        dprint(f"Fetching columns_types for {pipe} with via SQLAlchemy table.")
+
     table_columns = {}
     try:
         pipe_table = self.get_pipe_table(pipe, debug=debug)
         if pipe_table is None:
             return {}
+        if debug:
+            dprint(f"Found columns:")
+            mrsm.pprint(dict(pipe_table.columns))
         for col in pipe_table.columns:
             table_columns[str(col.name)] = str(col.type)
     except Exception as e:
@@ -3313,10 +3252,9 @@ def get_alter_columns_queries(
     -------
     A list of the `ALTER TABLE` SQL query or queries to be executed on the provided connector.
     """
-    if not pipe.exists(debug=debug):
+    if not pipe.exists(debug=debug) or pipe.static:
         return []
-    if pipe.static:
-        return
+
     from meerschaum.utils.sql import (
         sql_item_name,
         get_table_cols_types,
@@ -3362,7 +3300,8 @@ def get_alter_columns_queries(
             debug=debug,
         ).items()
     }
-    pipe_bool_cols = [col for col, typ in pipe.dtypes.items() if are_dtypes_equal(str(typ), 'bool')]
+    pipe_dtypes = pipe.dtypes
+    pipe_bool_cols = [col for col, typ in pipe_dtypes.items() if are_dtypes_equal(str(typ), 'bool')]
     pd_db_df_aliases = {
         'int': 'bool',
         'float': 'bool',
@@ -3370,7 +3309,10 @@ def get_alter_columns_queries(
         'guid': 'object',
     }
     if self.flavor == 'oracle':
-        pd_db_df_aliases['int'] = 'numeric'
+        pd_db_df_aliases.update({
+            'int': 'numeric',
+            'date': 'datetime',
+        })
 
     altered_cols = {
         col: (db_cols_types.get(col, 'object'), typ)
@@ -3379,6 +3321,10 @@ def get_alter_columns_queries(
         and not are_dtypes_equal(db_cols_types.get(col, 'object'), 'string')
     }
 
+    if debug and altered_cols:
+        dprint(f"Columns to be altered:")
+        mrsm.pprint(altered_cols)
+
     ### NOTE: Sometimes bools are coerced into ints or floats.
     altered_cols_to_ignore = set()
     for col, (db_typ, df_typ) in altered_cols.items():
@@ -3405,21 +3351,29 @@ def get_alter_columns_queries(
         if db_is_bool_compatible and df_is_bool_compatible:
             altered_cols_to_ignore.add(bool_col)
 
+    if debug and altered_cols_to_ignore:
+        dprint(f"Ignoring the following altered columns (false positives).")
+        mrsm.pprint(altered_cols_to_ignore)
+
     for col in altered_cols_to_ignore:
         _ = altered_cols.pop(col, None)
+
     if not altered_cols:
         return []
 
     if numeric_cols:
-        pipe.dtypes.update({col: 'numeric' for col in numeric_cols})
-        edit_success, edit_msg = pipe.edit(debug=debug)
-        if not edit_success:
-            warn(
-                f"Failed to update dtypes for numeric columns {items_str(numeric_cols)}:\n"
-                + f"{edit_msg}"
-            )
+        explicit_pipe_dtypes = pipe.get_dtypes(infer=False, debug=debug)
+        explicit_pipe_dtypes.update({col: 'numeric' for col in numeric_cols})
+        pipe.dtypes = explicit_pipe_dtypes
+        if not pipe.temporary:
+            edit_success, edit_msg = pipe.edit(debug=debug)
+            if not edit_success:
+                warn(
+                    f"Failed to update dtypes for numeric columns {items_str(numeric_cols)}:\n"
+                    + f"{edit_msg}"
+                )
     else:
-        numeric_cols.extend([col for col, typ in pipe.dtypes.items() if typ.startswith('numeric')])
+        numeric_cols.extend([col for col, typ in pipe_dtypes.items() if typ.startswith('numeric')])
 
     numeric_type = get_db_type_from_pd_type('numeric', self.flavor, as_sqlalchemy=False)
     text_type = get_db_type_from_pd_type('str', self.flavor, as_sqlalchemy=False)
@@ -3627,20 +3581,18 @@ def get_to_sql_dtype(
     >>> get_to_sql_dtype(pipe, df)
     {'a': <class 'sqlalchemy.sql.sqltypes.JSON'>}
     """
-    from meerschaum.utils.dataframe import get_json_cols, get_numeric_cols, get_uuid_cols
+    from meerschaum.utils.dataframe import get_special_cols
     from meerschaum.utils.dtypes.sql import get_db_type_from_pd_type
     df_dtypes = {
         col: str(typ)
         for col, typ in df.dtypes.items()
     }
-    json_cols = get_json_cols(df)
-    numeric_cols = get_numeric_cols(df)
-    uuid_cols = get_uuid_cols(df)
-    df_dtypes.update({col: 'json' for col in json_cols})
-    df_dtypes.update({col: 'numeric' for col in numeric_cols})
-    df_dtypes.update({col: 'uuid' for col in uuid_cols})
+    special_cols = get_special_cols(df)
+    df_dtypes.update(special_cols)
+
     if update_dtypes:
         df_dtypes.update(pipe.dtypes)
+
     return {
         col: get_db_type_from_pd_type(typ, self.flavor, as_sqlalchemy=True)
         for col, typ in df_dtypes.items()
@@ -3881,13 +3833,15 @@ def get_pipe_schema(self, pipe: mrsm.Pipe) -> Union[str, None]:
     -------
     A schema string or `None` if nothing is configured.
     """
+    if self.flavor == 'sqlite':
+        return self.schema
     return pipe.parameters.get('schema', self.schema)
 
 
 @staticmethod
 def get_temporary_target(
     target: str,
-    transact_id: Optional[str, None] = None,
+    transact_id: Optional[str] = None,
     label: Optional[str] = None,
     separator: Optional[str] = None,
 ) -> str:
@@ -3909,3 +3863,15 @@ def get_temporary_target(
         + transact_id
         + ((separator + label) if label else '')
     )
+
+
+def _enforce_pipe_dtypes_chunks_hook(
+    pipe: mrsm.Pipe,
+    chunk_df: 'pd.DataFrame',
+    debug: bool = False,
+    **kwargs
+) -> 'pd.DataFrame':
+    """
+    Enforce a pipe's dtypes on each chunk.
+    """
+    return pipe.enforce_dtypes(chunk_df, debug=debug)

meerschaum/connectors/sql/_plugins.py

@@ -13,6 +13,35 @@ import json
 import meerschaum as mrsm
 from meerschaum.utils.typing import Optional, Any, List, SuccessTuple, Dict
 
+
+def get_plugins_pipe(self) -> mrsm.Pipe:
+    """
+    Return the internal metadata plugins pipe.
+    """
+    users_pipe = self.get_users_pipe()
+    user_id_dtype = users_pipe.dtypes.get('user_id', 'int')
+    return mrsm.Pipe(
+        'mrsm', 'plugins',
+        instance=self,
+        temporary=True,
+        static=True,
+        null_indices=False,
+        columns={
+            'primary': 'plugin_id',
+            'user_id': 'user_id',    
+        },
+        dtypes={
+            'plugin_name': 'string',
+            'user_id': user_id_dtype,
+            'attributes': 'json',
+            'version': 'string',
+        },
+        indices={
+            'unique': 'plugin_name',
+        },
+    )
+
+
 def register_plugin(
     self,
     plugin: 'mrsm.core.Plugin',