MindsDB 25.8.3.0__py3-none-any.whl → 25.9.1.1__py3-none-any.whl

mindsdb/api/mongo/responders/aggregate.py

@@ -1,90 +0,0 @@
-from bson.int64 import Int64
-
-from mindsdb_sql_parser.ast import Identifier, Insert, CreateTable
-
-from mindsdb.api.mongo.classes import Responder
-import mindsdb.api.mongo.functions as helpers
-from mindsdb.api.mongo.responders.find import find_to_ast
-from mindsdb.api.mongo.classes.query_sql import run_sql_command
-from mindsdb.utilities.config import config
-
-
-def aggregate_to_ast(query, database):
-    collection = query['aggregate']
-
-    save_table = None
-    is_append = False
-    first_step = query['pipeline'][0]
-    if '$match' in first_step:
-        # convert to find
-        find_query = {
-            'find': collection,
-            'filter': first_step['$match'],
-        }
-        for step in query['pipeline'][1:]:
-            if '$project' in step:
-                find_query['projection'] = step['$project']
-            if '$sort' in step:
-                find_query['sort'] = step['$sort']
-            if '$skip' in step:
-                find_query['skip'] = step['$skip']
-            if '$limit' in step:
-                find_query['limit'] = step['$limit']
-
-            if '$out' in step:
-                target = step['$out']
-                if isinstance(target, str):
-                    save_table = Identifier(target)
-                else:
-                    save_table = Identifier(parts=[target['db'], target['coll']])
-                    if target.get('append'):
-                        is_append = True
-
-            # TODO implement group
-        ast_query = find_to_ast(find_query, database)
-        if save_table is not None:
-            if is_append:
-                ast_query = Insert(save_table, from_select=ast_query)
-            else:
-                ast_query = CreateTable(save_table, from_select=ast_query, is_replace=True)
-
-    else:
-        raise NotImplementedError
-
-    return ast_query
-
-
-class Responce(Responder):
-    when = {'aggregate': helpers.is_true}
-
-    def result(self, query, request_env, mindsdb_env, session):
-        db = query['$db']
-        collection = query['aggregate']
-
-        first_step = query['pipeline'][0]
-        if '$match' in first_step:
-            ast_query = aggregate_to_ast(query, request_env.get('database', config.get('default_project')))
-
-            data = run_sql_command(request_env, ast_query)
-
-        elif '$collStats' in first_step:
-            raise ValueError(
-                "To describe model use:"
-                " db.runCommand({describe: 'model_name.attribute'})"
-            )
-
-        else:
-            raise NotImplementedError
-
-        cursor = {
-            'id': Int64(0),
-            'ns': f"{db}.$cmd.{collection}",
-            'firstBatch': data
-        }
-        return {
-            'cursor': cursor,
-            'ok': 1
-        }
-
-
-responder = Responce()

mindsdb/api/mongo/responders/buildinfo.py

@@ -1,17 +0,0 @@
-from mindsdb.api.mongo.classes import Responder
-
-
-class Responce(Responder):
-    def when(self, query):
-        return (
-            'buildinfo' in query or 'buildInfo' in query
-        )
-
-    result = {
-        'version': '3.6.8',
-        'versionArray': [3, 6, 8, 0],
-        'ok': 1
-    }
-
-
-responder = Responce()

mindsdb/api/mongo/responders/coll_stats.py

@@ -1,63 +0,0 @@
-from mindsdb_sql_parser.ast import Describe, Identifier
-
-from mindsdb.api.mongo.classes import Responder
-import mindsdb.api.mongo.functions as helpers
-from mindsdb.api.mongo.classes.query_sql import run_sql_command
-from mindsdb.utilities.config import config
-
-
-class Responce(Responder):
-    when = {'collStats': helpers.is_true}
-
-    def result(self, query, request_env, mindsdb_env, session):
-        db = query['$db']
-        collection = query['collStats']
-
-        scale = query.get('scale')
-
-        if db != config.get('default_project') or collection == 'predictors' or scale is None:
-            # old behavior
-            # NOTE real answer is huge, i removed most data from it.
-            res = {
-                'ns': "db.collection",
-                'size': 1,
-                'count': 0,
-                'avgObjSize': 1,
-                'storageSize': 16384,
-                'capped': False,
-                'wiredTiger': {
-                },
-                'nindexes': 1,
-                'indexDetails': {
-                },
-                'totalIndexSize': 16384,
-                'indexSizes': {
-                    '_id_': 16384
-                },
-                'ok': 1
-            }
-
-            res['ns'] = f"{db}.{collection}"
-            if db == config.get('default_project') and collection == 'predictors':
-                res['count'] = len(mindsdb_env['model_controller'].get_models())
-        else:
-
-            ident_parts = [collection]
-            if scale is not None:
-                ident_parts.append(scale)
-
-            ast_query = Describe(Identifier(
-                parts=ident_parts
-            ))
-
-            data = run_sql_command(request_env, ast_query)
-            res = {
-                'data': data
-            }
-
-        res['ns'] = f"{db}.{collection}"
-
-        return res
-
-
-responder = Responce()

mindsdb/api/mongo/responders/company_id.py

@@ -1,25 +0,0 @@
-from mindsdb.api.mongo.classes import Responder
-from mindsdb.utilities.context import context as ctx
-
-
-class Responce(Responder):
-    def when(self, query):
-        return 'company_id' in query
-
-    def result(self, query, request_env, mindsdb_env, session):
-        company_id = query.get('company_id')
-        user_class = query.get('user_class', 0)
-        email_confirmed = query.get('email_confirmed', 1)
-        need_response = query.get('need_response', False)
-
-        ctx.company_id = company_id
-        ctx.user_class = user_class
-        ctx.email_confirmed = email_confirmed
-
-        if need_response:
-            return {'ok': 1}
-
-        return None
-
-
-responder = Responce()

mindsdb/api/mongo/responders/connection_status.py

@@ -1,22 +0,0 @@
-from mindsdb.api.mongo.classes import Responder
-import mindsdb.api.mongo.functions as helpers
-
-
-class Responce(Responder):
-    when = {'connectionStatus': helpers.is_true}
-
-    def result(self, query, request_env, mindsdb_env, session):
-        res = {
-            'authInfo': {
-                'authenticatedUsers': [],
-                'authenticatedUserRoles': []
-            },
-            'ok': 1
-        }
-        if helpers.is_true(query.get('showPrivileges')):
-            res['authInfo']['authenticatedUserPrivileges'] = []
-
-        return res
-
-
-responder = Responce()

mindsdb/api/mongo/responders/count.py

@@ -1,21 +0,0 @@
-from mindsdb.api.mongo.classes import Responder
-import mindsdb.api.mongo.functions as helpers
-
-
-class Responce(Responder):
-    when = {'count': helpers.is_true}
-
-    def result(self, query, request_env, mindsdb_env, session):
-        collection = query['count']
-
-        count = 0
-        if collection == 'predictors':
-            count = len(mindsdb_env['model_controller'].get_models())
-
-        return {
-            'n': count,
-            'ok': 1
-        }
-
-
-responder = Responce()

mindsdb/api/mongo/responders/db_stats.py

@@ -1,32 +0,0 @@
-from mindsdb.api.mongo.classes import Responder
-import mindsdb.api.mongo.functions as helpers
-from mindsdb.utilities.config import config
-
-
-class Responce(Responder):
-    when = {'dbStats': helpers.is_true}
-
-    def result(self, query, request_env, mindsdb_env, session):
-        db = query['$db']
-        collections = 0
-        if db == config.get('default_project'):
-            collections = 2 + len(mindsdb_env['model_controller'].get_models())
-        return {
-            'db': db,
-            'collections': collections,
-            'views': 0,
-            'objects': 0,
-            'avgObjSize': 0,
-            'dataSize': 0,
-            'storageSize': 0,
-            'numExtents': 0,
-            'indexes': 0,
-            'indexSize': 0,
-            'fileSize': 0,
-            'fsUsedSize': 0,
-            'fsTotalSize': 0,
-            'ok': 1
-        }
-
-
-responder = Responce()

mindsdb/api/mongo/responders/delete.py

@@ -1,105 +0,0 @@
-from mindsdb.api.mongo.classes import Responder
-import mindsdb.api.mongo.functions as helpers
-from mindsdb_sql_parser.ast import Identifier
-from mindsdb_sql_parser.ast.mindsdb import DropPredictor, DropJob, DropMLEngine
-from mindsdb.interfaces.jobs.jobs_controller import JobsController
-
-from mindsdb.api.mongo.classes.query_sql import run_sql_command
-
-
-class Responce(Responder):
-    when = {'delete': helpers.is_true}
-
-    def result(self, query, request_env, mindsdb_env, session):
-        try:
-            res = self._result(query, request_env, mindsdb_env)
-        except Exception as e:
-            res = {
-                'n': 0,
-                'writeErrors': [{
-                    'index': 0,
-                    'code': 0,
-                    'errmsg': str(e)
-                }],
-                'ok': 1
-            }
-        return res
-
-    def _result(self, query, request_env, mindsdb_env):
-        table = query['delete']
-        if table == 'predictors':
-            table = 'models'
-
-        project_name = request_env['database']
-
-        allowed_tables = ('models', 'jobs', 'ml_engines')
-        if table not in allowed_tables:
-            raise Exception(f"Only removing from this collections is supported: {', '.join(allowed_tables)}")
-
-        if len(query['deletes']) != 1:
-            raise Exception("Should be only one argument in REMOVE operation")
-
-        obj_name, obj_id = None, None
-
-        delete_filter = query['deletes'][0]['q']
-        if '_id' in delete_filter:
-            # get name of object
-            obj_id = helpers.objectid_to_int(delete_filter['_id'])
-
-        if 'name' in delete_filter:
-            obj_name = delete_filter['name']
-
-        version = None
-        if 'version' in delete_filter:
-            version = delete_filter['version']
-
-        if obj_name is None and obj_id is None:
-            raise Exception("Can't find object to delete, use filter by name or _id")
-
-        if obj_name is None:
-            if table == 'models':
-                model_id = obj_id >> 20
-                version = obj_id & (2 ** 20 - 1)
-
-                models = mindsdb_env['model_controller'].get_models(
-                    ml_handler_name=None,
-                    project_name=project_name
-                )
-                for model in models:
-                    if model['id'] == model_id:
-                        obj_name = model['name']
-                        break
-                if obj_name is None:
-                    raise Exception("Can't find model by _id")
-            elif table == 'jobs':
-                jobs_controller = JobsController()
-                for job in jobs_controller.get_list(project_name):
-                    if job['id'] == obj_id:
-                        obj_name = job['name']
-                        break
-
-        # delete model
-        if table == 'models':
-            if version is None:
-                ast_query = DropPredictor(Identifier(parts=[project_name, obj_name]))
-                run_sql_command(request_env, ast_query)
-            else:
-                # delete model version
-                ast_query = DropPredictor(Identifier(parts=[project_name, obj_name, str(version)]))
-                run_sql_command(request_env, ast_query)
-
-        elif table == 'jobs':
-            ast_query = DropJob(Identifier(parts=[project_name, obj_name]))
-            run_sql_command(request_env, ast_query)
-
-        elif table == 'ml_engines':
-            ast_query = DropMLEngine(Identifier(parts=[obj_name]))
-            run_sql_command(request_env, ast_query)
-
-        return {
-            'n': 1,
-            'ok': 1
-        }
-
-
-responder = Responce()

mindsdb/api/mongo/responders/describe.py

@@ -1,23 +0,0 @@
-from mindsdb_sql_parser.ast import Describe, Identifier
-
-from mindsdb.api.mongo.classes import Responder
-import mindsdb.api.mongo.functions as helpers
-from mindsdb.api.mongo.classes.query_sql import run_sql_command
-
-
-class Responce(Responder):
-    when = {'describe': helpers.is_true}
-
-    def result(self, query, request_env, mindsdb_env, session):
-        db = query['$db']
-        model = query['describe']
-
-        ast_query = Describe(Identifier(model))
-
-        data = run_sql_command(request_env, ast_query)
-        res = {'data': data, 'ns': f"{db}.{model}"}
-
-        return res
-
-
-responder = Responce()

mindsdb/api/mongo/responders/end_sessions.py

@@ -1,13 +0,0 @@
-from mindsdb.api.mongo.classes import Responder
-import mindsdb.api.mongo.functions as helpers
-
-
-class Responce(Responder):
-    when = {'endSessions': helpers.is_true}
-
-    result = {
-        'ok': 1
-    }
-
-
-responder = Responce()

mindsdb/api/mongo/responders/find.py

@@ -1,175 +0,0 @@
-from bson.int64 import Int64
-
-from mindsdb_sql_parser.ast import Join, Select, Identifier, Describe, Show, Constant
-import mindsdb.api.mongo.functions as helpers
-from mindsdb.api.mongo.classes import Responder
-from mindsdb.api.mongo.utilities.mongodb_ast import MongoToAst
-from mindsdb.interfaces.jobs.jobs_controller import JobsController
-
-from mindsdb.api.mongo.classes.query_sql import run_sql_command
-
-
-def find_to_ast(query, database):
-    mongoToAst = MongoToAst()
-
-    collection = [database, query['find']]
-
-    if not query.get('singleBatch') and 'collection' in query.get('filter'):
-        # JOIN mode
-
-        # upper query
-        ast_query = mongoToAst.find(
-            collection=collection,
-            projection=query.get('projection'),
-            sort=query.get('sort'),
-            limit=query.get('limit'),
-            skip=query.get('skip'),
-        )
-
-        # table_query
-        collection = query['filter']['collection']
-        filter = query['filter'].get('query', {})
-        table_select = mongoToAst.find(
-            collection=collection,
-            filter=filter,
-        )
-        table_select.parentheses = True
-        table_select.alias = Identifier(query['filter']['collection'])
-        table_select.alias.parts = [table_select.alias.parts[-1]]
-        if 'limit' in query:
-            table_select.limit = Constant(query['limit'])
-
-        modifiers = query['filter'].get('modifiers')
-        if modifiers is not None and hasattr(ast_query, 'modifiers'):
-            for modifier in modifiers:
-                table_select.modifiers.append(modifier)
-
-        # convert to join
-        right_table = ast_query.from_table
-
-        ast_join = Join(
-            left=table_select,
-            right=right_table,
-            join_type='join'
-        )
-        ast_query.from_table = ast_join
-
-    else:
-        # is single table
-        ast_query = mongoToAst.find(
-            collection=collection,
-            filter=query.get('filter'),
-            projection=query.get('projection'),
-            sort=query.get('sort'),
-            limit=query.get('limit'),
-            skip=query.get('skip'),
-        )
-        modifiers = query['filter'].get('modifiers')
-        if modifiers is not None and hasattr(ast_query, 'modifiers'):
-            for modifier in modifiers:
-                ast_query.modifiers.append(modifier)
-    return ast_query
-
-
-class Responce(Responder):
-    when = {'find': helpers.is_true}
-
-    def result(self, query, request_env, mindsdb_env, session):
-        database = request_env['database']
-        project_name = request_env['database']
-
-        if database == 'config':
-            # return nothing
-            return {
-                'cursor': {
-                    'id': Int64(0),
-                    'ns': f"{database}.$cmd.{query['find']}",
-                    'firstBatch': []
-                },
-                'ok': 1
-            }
-
-        # system queries
-        elif query['find'] == 'system.version':
-            # For studio3t
-            data = [{
-                "_id": "featureCompatibilityVersion",
-                "version": "3.6"
-            }]
-            cursor = {
-                'id': Int64(0),
-                'ns': f"system.version.$cmd.{query['find']}",
-                'firstBatch': data
-            }
-            return {
-                'cursor': cursor,
-                'ok': 1
-            }
-
-        elif query['find'] == 'ml_engines':
-            ast_query = Show('ml_engines')
-
-        else:
-            ast_query = find_to_ast(query, database)
-
-        # add _id for objects
-        table_name = None
-        obj_idx = {}
-        if isinstance(ast_query, Select) and ast_query.from_table is not None:
-            if isinstance(ast_query.from_table, Identifier):
-                table_name = ast_query.from_table.parts[-1].lower()
-
-                if table_name == 'models':
-
-                    models = mindsdb_env['model_controller'].get_models(
-                        ml_handler_name=None,
-                        project_name=project_name
-                    )
-
-                    for model in models:
-                        obj_idx[model['name']] = model['id']
-
-                    # is select from model without where
-                    if table_name in obj_idx and ast_query.where is None:
-                        # replace query to describe model
-                        ast_query = Describe(ast_query.from_table)
-                elif table_name == 'jobs':
-                    jobs_controller = JobsController()
-                    for job in jobs_controller.get_list(project_name):
-                        obj_idx[job['name']] = job['id']
-
-        data = run_sql_command(request_env, ast_query)
-
-        if table_name == 'models':
-            # for models and models_versions _id is:
-            #   - first 20 bytes is version
-            #   - next bytes is model id
-
-            for row in data:
-                model_id = obj_idx.get(row.get('NAME'))
-                if model_id is not None:
-                    obj_id = model_id << 20
-
-                    obj_id += row.get('VERSION', 0)
-
-                    row['_id'] = helpers.int_to_objectid(obj_id)
-        elif table_name == 'jobs':
-            for row in data:
-                obj_id = obj_idx.get(row.get('NAME'))
-                if obj_id is not None:
-                    row['_id'] = helpers.int_to_objectid(obj_id)
-
-        db = mindsdb_env['config']['api']['mongodb']['database']
-
-        cursor = {
-            'id': Int64(0),
-            'ns': f"{db}.$cmd.{query['find']}",
-            'firstBatch': data
-        }
-        return {
-            'cursor': cursor,
-            'ok': 1
-        }
-
-
-responder = Responce()

mindsdb/api/mongo/responders/get_cmd_line_opts.py

@@ -1,18 +0,0 @@
-from mindsdb.api.mongo.classes import Responder
-import mindsdb.api.mongo.functions as helpers
-
-
-class Responce(Responder):
-    when = {'getCmdLineOpts': helpers.is_true}
-
-    result = {
-        'argv': [
-            'mongod'
-        ],
-        'parsed': {
-        },
-        'ok': 1
-    }
-
-
-responder = Responce()

mindsdb/api/mongo/responders/get_free_monitoring_status.py

@@ -1,14 +0,0 @@
-from mindsdb.api.mongo.classes import Responder
-import mindsdb.api.mongo.functions as helpers
-
-
-class Responce(Responder):
-    when = {'getFreeMonitoringStatus': helpers.is_true}
-
-    result = {
-        'state': 'undecided',
-        'ok': 1
-    }
-
-
-responder = Responce()

mindsdb/api/mongo/responders/get_parameter.py

@@ -1,23 +0,0 @@
-from mindsdb.api.mongo.classes import Responder
-import mindsdb.api.mongo.functions as helpers
-
-
-class Responce(Responder):
-    when = {'getParameter': helpers.is_true}
-
-    def result(self, query, request_env, mindsdb_env, session):
-
-        if query['featureCompatibilityVersion']:
-            res = {
-                "featureCompatibilityVersion":
-                    {
-                        "version": "3.6"
-                    },
-                "ok": 1.0
-            }
-        else:
-            raise NotImplementedError(f'Unknown parameter {query}')
-        return res
-
-
-responder = Responce()

mindsdb/api/mongo/responders/getlog.py

@@ -1,14 +0,0 @@
-from mindsdb.api.mongo.classes import Responder
-import mindsdb.api.mongo.functions as helpers
-
-
-class Responce(Responder):
-    when = {'getLog': helpers.is_true}
-
-    result = {
-        "log": [],
-        "ok": 1
-    }
-
-
-responder = Responce()