MindsDB 24.6.1.1__tar.gz → 24.6.2.0__tar.gz

{MindsDB-24.6.1.1 → MindsDB-24.6.2.0/MindsDB.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: MindsDB
-Version: 24.6.1.1
+Version: 24.6.2.0
 Summary: MindsDB's AI SQL Server enables developers to build AI tools that need access to real-time data to perform their tasks
 Home-page: https://github.com/mindsdb/mindsdb
 Download-URL: https://pypi.org/project/mindsdb/

{MindsDB-24.6.1.1 → MindsDB-24.6.2.0}/MindsDB.egg-info/SOURCES.txt

@@ -1593,6 +1593,7 @@ mindsdb/integrations/libs/ml_handler_process/__init__.py
 mindsdb/integrations/libs/ml_handler_process/create_engine_process.py
 mindsdb/integrations/libs/ml_handler_process/create_validation_process.py
 mindsdb/integrations/libs/ml_handler_process/describe_process.py
+mindsdb/integrations/libs/ml_handler_process/func_call_process.py
 mindsdb/integrations/libs/ml_handler_process/handlers_cacher.py
 mindsdb/integrations/libs/ml_handler_process/learn_process.py
 mindsdb/integrations/libs/ml_handler_process/predict_process.py

{MindsDB-24.6.1.1/MindsDB.egg-info → MindsDB-24.6.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: MindsDB
-Version: 24.6.1.1
+Version: 24.6.2.0
 Summary: MindsDB's AI SQL Server enables developers to build AI tools that need access to real-time data to perform their tasks
 Home-page: https://github.com/mindsdb/mindsdb
 Download-URL: https://pypi.org/project/mindsdb/

{MindsDB-24.6.1.1 → MindsDB-24.6.2.0}/mindsdb/__about__.py

@@ -1,6 +1,6 @@
 __title__ = 'MindsDB'
 __package_name__ = 'mindsdb'
-__version__ = '24.6.1.1'
+__version__ = '24.6.2.0'
 __description__ = "MindsDB's AI SQL Server enables developers to build AI tools that need access to real-time data to perform their tasks"
 __email__ = "jorge@mindsdb.com"
 __author__ = 'MindsDB Inc'

{MindsDB-24.6.1.1 → MindsDB-24.6.2.0}/mindsdb/api/executor/controllers/session_controller.py

@@ -15,6 +15,8 @@ from mindsdb.interfaces.model.model_controller import ModelController
 from mindsdb.interfaces.database.database import DatabaseController
 from mindsdb.interfaces.database.integrations import integration_controller
 from mindsdb.interfaces.skills.skills_controller import SkillsController
+from mindsdb.interfaces.functions.controller import BYOMFunctionsController
+
 from mindsdb.utilities import log
 
 logger = log.getLogger(__name__)
@@ -41,6 +43,7 @@ class SessionController:
         self.integration_controller = integration_controller
         self.database_controller = DatabaseController()
         self.skills_controller = SkillsController()
+        self.function_controller = BYOMFunctionsController(self)
 
         # to prevent circular imports
         from mindsdb.interfaces.knowledge_base.controller import KnowledgeBaseController

{MindsDB-24.6.1.1 → MindsDB-24.6.2.0}/mindsdb/api/executor/datahub/datanodes/project_datanode.py

@@ -131,7 +131,7 @@ class ProjectDataNode(DataNode):
                     raise Exception(f"Cant execute view query: {view_meta['query_ast']}")
                 df = result['result']
 
-                df = query_df(df, query)
+                df = query_df(df, query, session=session)
 
                 columns_info = [
                     {

{MindsDB-24.6.1.1 → MindsDB-24.6.2.0}/mindsdb/api/executor/sql_query/steps/project_step.py

@@ -81,6 +81,6 @@ class ProjectStepCall(BaseStepCall):
                 targets.append(target)
         query.targets = targets
 
-        res = query_df(df, query)
+        res = query_df(df, query, session=self.session)
 
         return ResultSet().from_df_cols(res, col_names, strict=False)

{MindsDB-24.6.1.1 → MindsDB-24.6.2.0}/mindsdb/api/executor/sql_query/steps/subselect_step.py

@@ -51,7 +51,7 @@ class SubSelectStepCall(BaseStepCall):
                     result.add_column(Column(col_name))
 
         df = result.to_df()
-        res = query_df(df, query)
+        res = query_df(df, query, session=self.session)
 
         result2 = ResultSet()
         # get database from first column
@@ -124,7 +124,7 @@ class QueryStepCall(BaseStepCall):
         query.where = query_context_controller.remove_lasts(query.where)
 
         query.from_table = Identifier('df_table')
-        res = query_df(df, query)
+        res = query_df(df, query, session=self.session)
 
         data = ResultSet().from_df_cols(res, col_names, strict=False)
 

{MindsDB-24.6.1.1 → MindsDB-24.6.2.0}/mindsdb/api/executor/utilities/sql.py

@@ -52,7 +52,7 @@ def get_query_models(query: ASTNode, default_database: str = None) -> List[tuple
     return _get_query_tables(query, resolve_model_identifier, default_database)
 
 
-def query_df_with_type_infer_fallback(query_str: str, dataframes: dict):
+def query_df_with_type_infer_fallback(query_str: str, dataframes: dict, user_functions=None):
     ''' Duckdb need to infer column types if column.dtype == object. By default it take 1000 rows,
         but that may be not sufficient for some cases. This func try to run query multiple times
         increasing butch size for type infer
@@ -60,6 +60,7 @@ def query_df_with_type_infer_fallback(query_str: str, dataframes: dict):
         Args:
             query_str (str): query to execute
             dataframes (dict): dataframes
+            user_functions: functions controller which register new functions in connection
 
         Returns:
             pandas.DataFrame
@@ -70,6 +71,9 @@ def query_df_with_type_infer_fallback(query_str: str, dataframes: dict):
         locals()[name] = value
 
     con = duckdb.connect(database=':memory:')
+    if user_functions:
+        user_functions.register(con)
+
     for sample_size in [1000, 10000, 1000000]:
         try:
             con.execute(f'set global pandas_analyze_sample={sample_size};')
@@ -113,6 +117,11 @@ def query_df(df, query, session=None):
 
     json_columns = set()
 
+    if session is not None:
+        user_functions = session.function_controller.create_function_set()
+    else:
+        user_functions = None
+
     def adapt_query(node, is_table, **kwargs):
         if is_table:
             return
@@ -128,13 +137,16 @@ def query_df(df, query, session=None):
                 else:
                     cur_db = None
                 return Constant(cur_db)
-            if fnc_name == 'truncate':
+            elif fnc_name == 'truncate':
                 # replace mysql 'truncate' function to duckdb 'round'
                 node.op = 'round'
                 if len(node.args) == 1:
                     node.args.append(0)
-            if fnc_name == 'json_extract':
+            elif fnc_name == 'json_extract':
                 json_columns.add(node.args[0].parts[-1])
+            else:
+                if user_functions is not None:
+                    user_functions.check_function(node)
 
     query_traversal(query_ast, adapt_query)
 
@@ -169,7 +181,7 @@ def query_df(df, query, session=None):
             if 'CONNECTION_DATA' in df.columns:
                 df = df.astype({'CONNECTION_DATA': 'string'})
 
-    result_df, description = query_df_with_type_infer_fallback(query_str, {'df': df})
+    result_df, description = query_df_with_type_infer_fallback(query_str, {'df': df}, user_functions=user_functions)
     result_df = result_df.replace({np.nan: None})
 
     new_column_names = {}

{MindsDB-24.6.1.1 → MindsDB-24.6.2.0}/mindsdb/integrations/handlers/byom_handler/byom_handler.py

@@ -37,7 +37,7 @@ import mindsdb.utilities.profiler as profiler
 
 from .proc_wrapper import (
     pd_decode, pd_encode, encode, decode, BYOM_METHOD,
-    import_string, find_model_class
+    import_string, find_model_class, get_methods_info
 )
 from .__about__ import __version__
 
@@ -281,7 +281,9 @@ class BYOMHandler(BaseMLEngine):
 
         model_proxy = self._get_model_proxy()
         try:
-            model_proxy.check()
+            methods = model_proxy.check()
+            self.engine_storage.json_set('methods', methods)
+
         except Exception as e:
             model_proxy.remove_venv()
             raise e
@@ -332,11 +334,20 @@ class BYOMHandler(BaseMLEngine):
 
         model_proxy = self._get_model_proxy(new_version)
         try:
-            model_proxy.check()
+            methods = model_proxy.check()
+            self.engine_storage.json_set('methods', methods)
+
         except Exception as e:
             model_proxy.remove_venv()
             raise e
 
+    def function_list(self):
+        return self.engine_storage.json_get('methods')
+
+    def function_call(self, name, args):
+        mp = self._get_model_proxy()
+        return mp.func_call(name, args)
+
     def finetune(self, df: Optional[pd.DataFrame] = None, args: Optional[Dict] = None) -> None:
         using_args = args.get('using', {})
         engine_version = using_args.get('engine_version')
@@ -432,8 +443,14 @@ class ModelWrapperUnsafe:
             return self.model_instance.describe(attribute)
         return pd.DataFrame()
 
+    def func_call(self, func_name, args):
+
+        func = getattr(self.model_instance, func_name)
+        return func(*args)
+
     def check(self):
-        pass
+        methods = get_methods_info(self.model_instance)
+        return methods
 
 
 class ModelWrapperSafe:
@@ -639,3 +656,13 @@ class ModelWrapperSafe:
         enc_df = self._run_command(params)
         df = pd_decode(enc_df)
         return df
+
+    def func_call(self, func_name, args):
+        params = {
+            'method': BYOM_METHOD.FUNC_CALL.value,
+            'code': self.code,
+            'func_name': func_name,
+            'args': args,
+        }
+        result = self._run_command(params)
+        return result

{MindsDB-24.6.1.1 → MindsDB-24.6.2.0}/mindsdb/integrations/handlers/byom_handler/proc_wrapper.py

@@ -33,6 +33,7 @@ class BYOM_METHOD(Enum):
     PREDICT = 3
     FINETUNE = 4
     DESCRIBE = 5
+    FUNC_CALL = 6
 
 
 def pd_encode(df):
@@ -90,6 +91,27 @@ def find_model_class(module):
         ]
         if 'predict' in funcs and 'train' in funcs:
             return klass
+    raise RuntimeError('Unable to find model class (has to have `train` and `predict` methods)')
+
+
+def get_methods_info(model):
+    # get all methods and their types
+    methods = {}
+    for method_name in dir(model):
+        if method_name.startswith('__'):
+            continue
+
+        method = getattr(model, method_name)
+        sig = inspect.signature(method)
+        input_params = [
+            {'name': name, 'type': param.annotation.__name__}
+            for name, param in sig.parameters.items()
+        ]
+        methods[method_name] = {
+            'input_params': input_params,
+            'output_type': sig.return_annotation.__name__
+        }
+    return methods
 
 
 def main():
@@ -108,13 +130,15 @@ def main():
     if method == BYOM_METHOD.CHECK:
         model = model_class()
 
-        if not hasattr(model, 'train'):
+        methods = get_methods_info(model)
+
+        if 'train' not in methods:
             raise RuntimeError('Model class has to have "train" method')
 
-        if not hasattr(model, 'predict'):
+        if 'predict' not in methods:
             raise RuntimeError('Model class has to have "predict" method')
 
-        return_output(True)
+        return_output(methods)
 
     if method == BYOM_METHOD.TRAIN:
         df = pd_decode(params['df'])
@@ -176,6 +200,14 @@ def main():
             return_output(pd_encode(pd.DataFrame()))
         return_output(pd_encode(df))
 
+    elif method == BYOM_METHOD.FUNC_CALL:
+        model = model_class()
+        func_name = params['func_name']
+        args = params['args']
+
+        func = getattr(model, func_name)
+        return return_output(func(*args))
+
     raise NotImplementedError(method)
 
 

{MindsDB-24.6.1.1 → MindsDB-24.6.2.0}/mindsdb/integrations/handlers/postgres_handler/postgres_handler.py

@@ -1,3 +1,6 @@
+import time
+import json
+
 import pandas as pd
 import psycopg
 from psycopg.postgres import types
@@ -19,6 +22,8 @@ import mindsdb.utilities.profiler as profiler
 
 logger = log.getLogger(__name__)
 
+SUBSCRIBE_SLEEP_INTERVAL = 1
+
 
 class PostgresHandler(DatabaseHandler):
     """
@@ -42,20 +47,7 @@ class PostgresHandler(DatabaseHandler):
         if self.is_connected:
             self.disconnect()
 
-    @profiler.profile()
-    def connect(self):
-        """
-        Establishes a connection to a PostgreSQL database.
-
-        Raises:
-            psycopg.Error: If an error occurs while connecting to the PostgreSQL database.
-
-        Returns:
-            psycopg.Connection: A connection object to the PostgreSQL database.
-        """
-        if self.is_connected:
-            return self.connection
-
+    def _make_connection_args(self):
         config = {
             'host': self.connection_args.get('host'),
             'port': self.connection_args.get('port'),
@@ -70,7 +62,23 @@ class PostgresHandler(DatabaseHandler):
         # If schema is not provided set public as default one
         if self.connection_args.get('schema'):
             config['options'] = f'-c search_path={self.connection_args.get("schema")},public'
+        return config
+
+    @profiler.profile()
+    def connect(self):
+        """
+        Establishes a connection to a PostgreSQL database.
+
+        Raises:
+            psycopg.Error: If an error occurs while connecting to the PostgreSQL database.
+
+        Returns:
+            psycopg.Connection: A connection object to the PostgreSQL database.
+        """
+        if self.is_connected:
+            return self.connection
 
+        config = self._make_connection_args()
         try:
             self.connection = psycopg.connect(**config, connect_timeout=10)
             self.is_connected = True
@@ -289,3 +297,89 @@ class PostgresHandler(DatabaseHandler):
                 table_name = '{table_name}'
         """
         return self.native_query(query)
+
+    def subscribe(self, stop_event, callback, table_name, columns=None, **kwargs):
+
+        config = self._make_connection_args()
+        config['autocommit'] = True
+
+        conn = psycopg.connect(connect_timeout=10, **config)
+
+        # create db trigger
+        trigger_name = f'mdb_notify_{table_name}'
+
+        before, after = '', ''
+
+        if columns:
+            # check column exist
+            conn.execute(f'select {",".join(columns)} from {table_name} limit 0')
+
+            columns = set(columns)
+            trigger_name += '_' + '_'.join(columns)
+
+            news, olds = [], []
+            for column in columns:
+                news.append(f'NEW.{column}')
+                olds.append(f'OLD.{column}')
+
+            before = f'IF ({", ".join(news)}) IS DISTINCT FROM ({", ".join(olds)}) then\n'
+            after = '\nEND IF;'
+        else:
+            columns = set()
+
+        func_code = f'''
+             CREATE OR REPLACE FUNCTION {trigger_name}()
+               RETURNS trigger AS $$
+             DECLARE
+             BEGIN
+               {before}
+               PERFORM pg_notify( '{trigger_name}', row_to_json(NEW)::text);
+               {after}
+               RETURN NEW;
+             END;
+             $$ LANGUAGE plpgsql;
+         '''
+        conn.execute(func_code)
+
+        # for after update - new and old have the same values
+        conn.execute(f'''
+             CREATE OR REPLACE TRIGGER {trigger_name}
+               BEFORE INSERT OR UPDATE ON {table_name}
+               FOR EACH ROW
+               EXECUTE PROCEDURE {trigger_name}();
+        ''')
+        conn.commit()
+
+        # start listen
+        conn.execute(f"LISTEN {trigger_name};")
+
+        def process_event(event):
+            try:
+                row = json.loads(event.payload)
+            except json.JSONDecoder:
+                return
+
+            # check column in input data
+            if not columns or columns.intersection(row.keys()):
+                callback(row)
+
+        try:
+            conn.add_notify_handler(process_event)
+
+            while True:
+                if stop_event.is_set():
+                    # exit trigger
+                    return
+
+                # trigger getting updates
+                # https://www.psycopg.org/psycopg3/docs/advanced/async.html#asynchronous-notifications
+                conn.execute("SELECT 1").fetchone()
+
+                time.sleep(SUBSCRIBE_SLEEP_INTERVAL)
+
+        finally:
+            conn.execute(f'drop TRIGGER {trigger_name} on {table_name}')
+            conn.execute(f'drop FUNCTION {trigger_name}')
+            conn.commit()
+
+            conn.close()

{MindsDB-24.6.1.1 → MindsDB-24.6.2.0}/mindsdb/integrations/handlers/snowflake_handler/snowflake_handler.py

@@ -1,17 +1,16 @@
-from pandas import DataFrame, concat
+from pandas import DataFrame
 from snowflake import connector
 from snowflake.sqlalchemy import snowdialect
 
-from mindsdb_sql.render.sqlalchemy_render import SqlalchemyRender
+from mindsdb.utilities import log
 from mindsdb_sql.parser.ast.base import ASTNode
-
 from mindsdb.integrations.libs.base import DatabaseHandler
+from mindsdb_sql.render.sqlalchemy_render import SqlalchemyRender
 from mindsdb.integrations.libs.response import (
     HandlerStatusResponse as StatusResponse,
     HandlerResponse as Response,
     RESPONSE_TYPE
 )
-from mindsdb.utilities import log
 
 
 logger = log.getLogger(__name__)
@@ -176,23 +175,13 @@ class SnowflakeHandler(DatabaseHandler):
             Response: A response object containing the list of tables and views, formatted as per the `Response` class.
         """
 
-        query = "SHOW TABLES;"
-        result_tables = self.native_query(query)
-        if result_tables.resp_type == RESPONSE_TYPE.TABLE:
-            result_tables.data_frame = result_tables.data_frame.rename(columns={'name': 'table_name'})[['table_name']]
-        elif result_tables.resp_type == RESPONSE_TYPE.OK:
-            result_tables.data_frame = DataFrame(columns=['table_name'])
-
-        query = "SHOW VIEWS;"
-        result_views = self.native_query(query)
-        if result_views.resp_type == RESPONSE_TYPE.TABLE:
-            result_views.data_frame = result_views.data_frame.rename(columns={'name': 'table_name'})[['table_name']]
-        elif result_views.resp_type == RESPONSE_TYPE.OK:
-            result_views.data_frame = DataFrame(columns=['table_name'])
-
-        result = Response(RESPONSE_TYPE.TABLE)
-        result.data_frame = concat([result_tables.data_frame, result_views.data_frame], ignore_index=True)
-        return result
+        query = """
+            SELECT TABLE_NAME, TABLE_SCHEMA, TABLE_TYPE
+            FROM INFORMATION_SCHEMA.TABLES
+            WHERE TABLE_TYPE IN ('BASE TABLE', 'VIEW')
+            AND TABLE_SCHEMA <> 'INFORMATION_SCHEMA'
+        """
+        return self.native_query(query)
 
     def get_columns(self, table_name) -> Response:
         """

{MindsDB-24.6.1.1 → MindsDB-24.6.2.0}/mindsdb/integrations/libs/ml_exec_base.py

@@ -174,6 +174,25 @@ class BaseMLEngineExec:
             result = task.result()
         return result
 
+    def function_call(self, func_name, args):
+        with self._catch_exception():
+            task = self.base_ml_executor.apply_async(
+                task_type=ML_TASK_TYPE.FUNC_CALL,
+                model_id=0,     # can not be None
+                payload={
+                    'context': ctx.dump(),
+                    'name': func_name,
+                    'args': args,
+                    'handler_meta': {
+                        'module_path': self.handler_module.__package__,
+                        'engine': self.engine,
+                        'integration_id': self.integration_id
+                    },
+                }
+            )
+            result = task.result()
+        return result
+
     @profiler.profile()
     @mark_process(name='predict')
     def predict(self, model_name: str, df: pd.DataFrame, pred_format: str = 'dict',

{MindsDB-24.6.1.1 → MindsDB-24.6.2.0}/mindsdb/integrations/libs/ml_handler_process/__init__.py

@@ -5,3 +5,4 @@ from mindsdb.integrations.libs.ml_handler_process.describe_process import descri
 from mindsdb.integrations.libs.ml_handler_process.predict_process import predict_process
 from mindsdb.integrations.libs.ml_handler_process.update_process import update_process
 from mindsdb.integrations.libs.ml_handler_process.learn_process import learn_process
+from mindsdb.integrations.libs.ml_handler_process.func_call_process import func_call_process

MindsDB-24.6.2.0/mindsdb/integrations/libs/ml_handler_process/func_call_process.py

@@ -0,0 +1,26 @@
+import importlib
+
+from mindsdb.interfaces.storage.model_fs import HandlerStorage
+
+
+def func_call_process(name: str, args: dict, integration_id: int, module_path: str) -> None:
+    module = importlib.import_module(module_path)
+
+    if module.import_error is not None:
+        raise module.import_error
+
+    result = None
+
+    if hasattr(module.Handler, 'function_call'):
+        engine_storage = HandlerStorage(integration_id)
+        try:
+            result = module.Handler(
+                engine_storage=engine_storage,
+                model_storage=None
+            ).function_call(name, args)
+        except NotImplementedError:
+            return None
+        except Exception as e:
+            raise e
+
+    return result

{MindsDB-24.6.1.1 → MindsDB-24.6.2.0}/mindsdb/integrations/libs/process_cache.py

@@ -17,7 +17,8 @@ from mindsdb.integrations.libs.ml_handler_process import (
     describe_process,
     create_engine_process,
     update_engine_process,
-    create_validation_process
+    create_validation_process,
+    func_call_process
 )
 
 
@@ -323,6 +324,14 @@ class ProcessCache:
                 'model_id': model_id,
                 'module_path': handler_module_path
             }
+        elif task_type == ML_TASK_TYPE.FUNC_CALL:
+            func = func_call_process
+            kwargs = {
+                'name': payload['name'],
+                'args': payload['args'],
+                'integration_id': integration_id,
+                'module_path': handler_module_path
+            }
         else:
             raise Exception(f'Unknown ML task type: {task_type}')
 

{MindsDB-24.6.1.1 → MindsDB-24.6.2.0}/mindsdb/integrations/utilities/rag/retrievers/multi_vector_retriever.py

@@ -1,4 +1,4 @@
-from typing import List
+from typing import List, Tuple
 import uuid
 
 from langchain.retrievers.multi_vector import MultiVectorRetriever as LangChainMultiVectorRetriever
@@ -28,7 +28,7 @@ class MultiVectorRetriever(BaseRetriever):
         self.max_concurrency = config.max_concurrency
         self.mode = config.multi_retriever_mode
 
-    def _generate_id_and_split_document(self, doc: Document) -> tuple[str, list[Document]]:
+    def _generate_id_and_split_document(self, doc: Document) -> Tuple[str, List[Document]]:
         """
         Generate a unique id for the document and split it into sub-documents.
         :param doc:
@@ -40,7 +40,7 @@ class MultiVectorRetriever(BaseRetriever):
             sub_doc.metadata[self.id_key] = doc_id
         return doc_id, sub_docs
 
-    def _split_documents(self) -> tuple[list[Document], list[str]]:
+    def _split_documents(self) -> Tuple[List[Document], List[str]]:
         """
         Split the documents into sub-documents and generate unique ids for each document.
         :return:
@@ -51,7 +51,7 @@ class MultiVectorRetriever(BaseRetriever):
         return split_docs, list(doc_ids)
 
     def _create_retriever_and_vs_operator(self, docs: List[Document]) \
-            -> tuple[LangChainMultiVectorRetriever, VectorStoreOperator]:
+            -> Tuple[LangChainMultiVectorRetriever, VectorStoreOperator]:
         vstore_operator = VectorStoreOperator(
             vector_store=self.vectorstore,
             documents=docs,

{MindsDB-24.6.1.1 → MindsDB-24.6.2.0}/mindsdb/interfaces/triggers/triggers_controller.py

@@ -42,7 +42,10 @@ class TriggersController:
             raise Exception(f'Handler {db_integration["engine"]} does''t support subscription')
 
         df = db_handler.get_tables().data_frame
-        tables = list(df[df.columns[0]])
+        column = 'table_name'
+        if column not in df.columns:
+            column = df.columns[0]
+        tables = list(df[column])
 
         # check only if tables are visible
         if len(tables) > 0 and table_name not in tables:

{MindsDB-24.6.1.1 → MindsDB-24.6.2.0}/mindsdb/utilities/ml_task_queue/const.py

@@ -15,6 +15,7 @@ class ML_TASK_TYPE(Enum):
     CREATE_ENGINE = b'create_engine'
     UPDATE_ENGINE = b'update_engine'
     UPDATE = b'update'
+    FUNC_CALL = b'func_call'
 
 
 class ML_TASK_STATUS(Enum):