MindsDB 25.4.3.2__py3-none-any.whl → 25.4.5.0__py3-none-any.whl

mindsdb/api/executor/datahub/datanodes/system_tables.py

@@ -1,5 +1,5 @@
 from typing import Optional, Literal
-from dataclasses import dataclass, astuple, fields
+from dataclasses import dataclass, fields
 
 import pandas as pd
 from mindsdb_sql_parser.ast.base import ASTNode
@@ -7,11 +7,10 @@ from mindsdb_sql_parser.ast.base import ASTNode
 from mindsdb.utilities import log
 from mindsdb.utilities.config import config
 from mindsdb.integrations.utilities.sql_utils import extract_comparison_conditions
-from mindsdb.api.mysql.mysql_proxy.libs.constants.mysql import MYSQL_DATA_TYPE
-from mindsdb.api.executor.datahub.classes.tables_row import (
-    TABLES_ROW_TYPE,
-    TablesRow,
-)
+from mindsdb.integrations.libs.response import INF_SCHEMA_COLUMNS_NAMES
+from mindsdb.api.mysql.mysql_proxy.libs.constants.mysql import MYSQL_DATA_TYPE, MYSQL_DATA_TYPE_COLUMNS_DEFAULT
+from mindsdb.api.executor.datahub.classes.tables_row import TABLES_ROW_TYPE, TablesRow
+
 
 logger = log.getLogger(__name__)
 
@@ -165,11 +164,36 @@ class TablesTable(Table):
         return df
 
 
-@dataclass
+def infer_mysql_type(original_type: str) -> MYSQL_DATA_TYPE:
+    """Infer MySQL data type from original type string from a database.
+
+    Args:
+        original_type (str): The original type string from a database.
+
+    Returns:
+        MYSQL_DATA_TYPE: The inferred MySQL data type.
+    """
+    match original_type.lower():
+        case 'double precision' | 'real' | 'numeric' | 'float':
+            data_type = MYSQL_DATA_TYPE.FLOAT
+        case 'integer' | 'smallint' | 'int' | 'bigint':
+            data_type = MYSQL_DATA_TYPE.BIGINT
+        case 'timestamp without time zone' | 'timestamp with time zone' | 'date' | 'timestamp':
+            data_type = MYSQL_DATA_TYPE.DATETIME
+        case _:
+            data_type = MYSQL_DATA_TYPE.VARCHAR
+    return data_type
+
+
+@dataclass(slots=True, kw_only=True)
 class ColumnsTableRow:
-    """Represents a row in the COLUMNS table.
-    Fields description: https://dev.mysql.com/doc/refman/8.4/en/information-schema-columns-table.html
-    NOTE: attrs order matter, don't change it.
+    """Represents a row in the MindsDB's internal INFORMATION_SCHEMA.COLUMNS table.
+    This class follows the MySQL-compatible COLUMNS table structure.
+
+    Detailed field descriptions can be found in MySQL documentation:
+    https://dev.mysql.com/doc/refman/8.4/en/information-schema-columns-table.html
+
+    NOTE: The order of attributes is significant and matches the MySQL column order.
     """
     TABLE_CATALOG: Literal['def'] = 'def'
     TABLE_SCHEMA: Optional[str] = None
@@ -192,73 +216,81 @@ class ColumnsTableRow:
     PRIVILEGES: str = 'select'
     COLUMN_COMMENT: Optional[str] = None
     GENERATION_EXPRESSION: Optional[str] = None
+    SRS_ID: Optional[str] = None
+    # MindsDB's specific columns:
+    ORIGINAL_TYPE: Optional[str] = None
+
+    @classmethod
+    def from_is_columns_row(cls, table_schema: str, table_name: str, row: pd.Series) -> 'ColumnsTableRow':
+        """Transform row from response of `handler.get_columns(...)` to internal information_schema.columns row.
+
+        Args:
+            table_schema (str): The name of the schema of the table which columns are described.
+            table_name (str): The name of the table which columns are described.
+            row (pd.Series): A row from the response of `handler.get_columns(...)`.
+
+        Returns:
+            ColumnsTableRow: A row in the MindsDB's internal INFORMATION_SCHEMA.COLUMNS table.
+        """
+        original_type: str = row[INF_SCHEMA_COLUMNS_NAMES.DATA_TYPE] or ''
+        data_type: MYSQL_DATA_TYPE | None = row[INF_SCHEMA_COLUMNS_NAMES.MYSQL_DATA_TYPE]
+        if isinstance(data_type, MYSQL_DATA_TYPE) is False:
+            data_type = infer_mysql_type(original_type)
+
+        # region set default values depend on type
+        defaults = MYSQL_DATA_TYPE_COLUMNS_DEFAULT.get(data_type)
+        if defaults is not None:
+            for key, value in defaults.items():
+                if key in row and row[key] is None:
+                    row[key] = value
+
+        # region determine COLUMN_TYPE - it is text representation of DATA_TYPE with additioan attributes
+        match data_type:
+            case MYSQL_DATA_TYPE.DECIMAL:
+                column_type = f'decimal({row[INF_SCHEMA_COLUMNS_NAMES.NUMERIC_PRECISION]},{INF_SCHEMA_COLUMNS_NAMES.NUMERIC_SCALE})'
+            case MYSQL_DATA_TYPE.VARCHAR:
+                column_type = f'varchar({row[INF_SCHEMA_COLUMNS_NAMES.CHARACTER_MAXIMUM_LENGTH]})'
+            case MYSQL_DATA_TYPE.VARBINARY:
+                column_type = f'varbinary({row[INF_SCHEMA_COLUMNS_NAMES.CHARACTER_MAXIMUM_LENGTH]})'
+            case MYSQL_DATA_TYPE.BIT | MYSQL_DATA_TYPE.BINARY | MYSQL_DATA_TYPE.CHAR:
+                column_type = f'{data_type.value.lower()}(1)'
+            case MYSQL_DATA_TYPE.BOOL | MYSQL_DATA_TYPE.BOOLEAN:
+                column_type = 'tinyint(1)'
+            case _:
+                column_type = data_type.value.lower()
+        # endregion
+
+        # BOOLean types had 'tinyint' DATA_TYPE in MySQL
+        if data_type in (MYSQL_DATA_TYPE.BOOL, MYSQL_DATA_TYPE.BOOLEAN):
+            data_type = 'tinyint'
+        else:
+            data_type = data_type.value.lower()
+
+        return cls(
+            TABLE_SCHEMA=table_schema,
+            TABLE_NAME=table_name,
+            COLUMN_NAME=row[INF_SCHEMA_COLUMNS_NAMES.COLUMN_NAME],
+            ORDINAL_POSITION=row[INF_SCHEMA_COLUMNS_NAMES.ORDINAL_POSITION],
+            COLUMN_DEFAULT=row[INF_SCHEMA_COLUMNS_NAMES.COLUMN_DEFAULT],
+            IS_NULLABLE=row[INF_SCHEMA_COLUMNS_NAMES.IS_NULLABLE],
+            DATA_TYPE=data_type,
+            CHARACTER_MAXIMUM_LENGTH=row[INF_SCHEMA_COLUMNS_NAMES.CHARACTER_MAXIMUM_LENGTH],
+            CHARACTER_OCTET_LENGTH=row[INF_SCHEMA_COLUMNS_NAMES.CHARACTER_OCTET_LENGTH],
+            NUMERIC_PRECISION=row[INF_SCHEMA_COLUMNS_NAMES.NUMERIC_PRECISION],
+            NUMERIC_SCALE=row[INF_SCHEMA_COLUMNS_NAMES.NUMERIC_SCALE],
+            DATETIME_PRECISION=row[INF_SCHEMA_COLUMNS_NAMES.DATETIME_PRECISION],
+            CHARACTER_SET_NAME=row[INF_SCHEMA_COLUMNS_NAMES.CHARACTER_SET_NAME],
+            COLLATION_NAME=row[INF_SCHEMA_COLUMNS_NAMES.COLLATION_NAME],
+            COLUMN_TYPE=column_type,
+            ORIGINAL_TYPE=original_type
+        )
 
     def __post_init__(self):
-        # region check mandatory fields
+        """Check if all mandatory fields are filled.
+        """
         mandatory_fields = ['TABLE_SCHEMA', 'TABLE_NAME', 'COLUMN_NAME']
         if any(getattr(self, field_name) is None for field_name in mandatory_fields):
             raise ValueError('One of mandatory fields is missed when creating ColumnsTableRow')
-        # endregion
-
-        # region set default values depend on type
-        defaults = {
-            'COLUMN_TYPE': self.DATA_TYPE
-        }
-        if MYSQL_DATA_TYPE(self.DATA_TYPE) in (
-            MYSQL_DATA_TYPE.TIMESTAMP,
-            MYSQL_DATA_TYPE.DATETIME,
-            MYSQL_DATA_TYPE.DATE
-        ):
-            defaults = {
-                'DATETIME_PRECISION': 0,
-                'COLUMN_TYPE': self.DATA_TYPE
-            }
-        elif MYSQL_DATA_TYPE(self.DATA_TYPE) in (
-            MYSQL_DATA_TYPE.FLOAT,
-            MYSQL_DATA_TYPE.DOUBLE,
-            MYSQL_DATA_TYPE.DECIMAL
-        ):
-            defaults = {
-                'NUMERIC_PRECISION': 12,
-                'NUMERIC_SCALE': 0,
-                'COLUMN_TYPE': self.DATA_TYPE
-            }
-        elif MYSQL_DATA_TYPE(self.DATA_TYPE) in (
-            MYSQL_DATA_TYPE.TINYINT,
-            MYSQL_DATA_TYPE.SMALLINT,
-            MYSQL_DATA_TYPE.MEDIUMINT,
-            MYSQL_DATA_TYPE.INT,
-            MYSQL_DATA_TYPE.BIGINT
-        ):
-            defaults = {
-                'NUMERIC_PRECISION': 20,
-                'NUMERIC_SCALE': 0,
-                'COLUMN_TYPE': self.DATA_TYPE
-            }
-        elif MYSQL_DATA_TYPE(self.DATA_TYPE) is MYSQL_DATA_TYPE.VARCHAR:
-            defaults = {
-                'CHARACTER_MAXIMUM_LENGTH': 1024,
-                'CHARACTER_OCTET_LENGTH': 3072,
-                'CHARACTER_SET_NAME': 'utf8',
-                'COLLATION_NAME': 'utf8_bin',
-                'COLUMN_TYPE': 'varchar(1024)'
-            }
-        else:
-            # show as MYSQL_DATA_TYPE.TEXT:
-            defaults = {
-                'CHARACTER_MAXIMUM_LENGTH': 65535,      # from https://bugs.mysql.com/bug.php?id=90685
-                'CHARACTER_OCTET_LENGTH': 65535,        #
-                'CHARACTER_SET_NAME': 'utf8',
-                'COLLATION_NAME': 'utf8_bin',
-                'COLUMN_TYPE': 'text'
-            }
-
-        for key, value in defaults.items():
-            setattr(self, key, value)
-
-        self.DATA_TYPE = self.DATA_TYPE.lower()
-        self.COLUMN_TYPE = self.COLUMN_TYPE.lower()
-        # endregion
 
 
 class ColumnsTable(Table):
@@ -266,9 +298,7 @@ class ColumnsTable(Table):
     columns = [field.name for field in fields(ColumnsTableRow)]
 
     @classmethod
-    def get_data(cls, inf_schema=None, query: ASTNode = None, **kwargs):
-        result = []
-
+    def get_data(cls, inf_schema=None, query: ASTNode = None, **kwargs) -> pd.DataFrame:
         databases, tables_names = _get_scope(query)
 
         if databases is None:
@@ -278,6 +308,7 @@ class ColumnsTable(Table):
                 'files'
             ]
 
+        result = []
         for db_name in databases:
             tables = {}
             if db_name == 'information_schema':
@@ -293,43 +324,19 @@ class ColumnsTable(Table):
                 if tables_names is None:
                     tables_names = [t.TABLE_NAME for t in dn.get_tables()]
                 for table_name in tables_names:
-                    tables[table_name] = dn.get_table_columns(table_name)
-
-            for table_name, table_columns in tables.items():
-                for i, column in enumerate(table_columns):
-                    column_name = column['name']
-                    column_type = column.get('type', 'text')
-
-                    # region infer type
-                    if isinstance(column_type, MYSQL_DATA_TYPE) is False:
-                        if column_type in ('double precision', 'real', 'numeric', 'float'):
-                            column_type = MYSQL_DATA_TYPE.FLOAT
-                        elif column_type in ('integer', 'smallint', 'int', 'bigint'):
-                            column_type = MYSQL_DATA_TYPE.BIGINT
-                        elif column_type in (
-                            'timestamp without time zone',
-                            'timestamp with time zone',
-                            'date', 'timestamp'
-                        ):
-                            column_type = MYSQL_DATA_TYPE.DATETIME
-                        else:
-                            column_type = MYSQL_DATA_TYPE.VARCHAR
-                    # endregion
-
-                    column_row = astuple(
-                        ColumnsTableRow(
-                            TABLE_SCHEMA=db_name,
-                            TABLE_NAME=table_name,
-                            COLUMN_NAME=column_name,
-                            DATA_TYPE=column_type.value,
-                            ORDINAL_POSITION=i
+                    tables[table_name] = dn.get_table_columns_df(table_name)
+
+            for table_name, table_columns_df in tables.items():
+                for _, row in table_columns_df.iterrows():
+                    result.append(
+                        ColumnsTableRow.from_is_columns_row(
+                            table_schema=db_name,
+                            table_name=table_name,
+                            row=row
                         )
                     )
 
-                    result.append(column_row)
-
-        df = pd.DataFrame(result, columns=cls.columns)
-        return df
+        return pd.DataFrame(result, columns=cls.columns)
 
 
 class EventsTable(Table):

mindsdb/api/executor/planner/query_plan.py

@@ -3,6 +3,7 @@ class QueryPlan:
     def __init__(self, steps=None, **kwargs):
         self.steps = []
         self.is_resumable = False
+        self.is_async = False
 
         if steps:
             for step in steps:

mindsdb/api/executor/planner/query_planner.py

@@ -656,9 +656,18 @@ class QueryPlanner:
             # plan sub-select first
             last_step = self.plan_select(query.from_select, integration=integration_name)
 
+            # possible knowledge base parameters
+            select = query.from_select
+            params = {}
+            if isinstance(select, Select) and select.using is not None:
+                for k, v in select.using.items():
+                    if k.startswith('kb_'):
+                        params[k] = v
+
             self.plan.add_step(InsertToTable(
                 table=table,
                 dataframe=last_step,
+                params=params,
             ))
         else:
             self.plan.add_step(InsertToTable(
@@ -762,7 +771,7 @@ class QueryPlanner:
         elif from_table is None:
             # one line select
             step = QueryStep(query, from_table=pd.DataFrame([None]))
-            self.plan.add_step(step)
+            return self.plan.add_step(step)
         else:
             raise PlanningException(f'Unsupported from_table {type(from_table)}')
 
@@ -838,6 +847,7 @@ class QueryPlanner:
         # handle fetchdataframe partitioning
         steps_out = []
 
+        step = None
         partition_step = None
         for step in plan.steps:
             if isinstance(step, FetchDataframeStep) and step.params is not None:
@@ -889,6 +899,10 @@ class QueryPlanner:
                     continue
 
             steps_out.append(step)
+
+        if plan.is_resumable and isinstance(step, InsertToTable):
+            plan.is_async = True
+
         plan.steps = steps_out
         return plan
 

mindsdb/api/executor/planner/steps.py

@@ -200,7 +200,7 @@ class MultipleSteps(PlanStep):
 
 
 class SaveToTable(PlanStep):
-    def __init__(self, table, dataframe, is_replace=False, *args, **kwargs):
+    def __init__(self, table, dataframe, is_replace=False, params=None, *args, **kwargs):
         """
             Creates table if not exists and fills it with content of dataframe
             is_replace - to drop table beforehand
@@ -209,15 +209,21 @@ class SaveToTable(PlanStep):
         self.table = table
         self.dataframe = dataframe
         self.is_replace = is_replace
+        if params is None:
+            params = {}
+        self.params = params
 
 
 class InsertToTable(PlanStep):
-    def __init__(self, table, dataframe=None, query=None, *args, **kwargs):
+    def __init__(self, table, dataframe=None, query=None, params=None, *args, **kwargs):
         """Fills table with content of dataframe"""
         super().__init__(*args, **kwargs)
         self.table = table
         self.dataframe = dataframe
         self.query = query
+        if params is None:
+            params = {}
+        self.params = params
 
 
 class CreateTableStep(PlanStep):

mindsdb/api/executor/sql_query/sql_query.py

@@ -12,7 +12,9 @@ import inspect
 from textwrap import dedent
 from typing import Union, Dict
 
+import pandas as pd
 from mindsdb_sql_parser import parse_sql, ASTNode
+
 from mindsdb.api.executor.planner.steps import (
     ApplyTimeseriesPredictorStep,
     ApplyPredictorRowStep,
@@ -47,9 +49,16 @@ class SQLQuery:
     step_handlers = {}
 
     def __init__(self, sql: Union[ASTNode, str], session, execute: bool = True,
-                 database: str = None, query_id: int = None):
+                 database: str = None, query_id: int = None, stop_event=None):
         self.session = session
 
+        self.query_id = query_id
+        if self.query_id is not None:
+            # get sql and database from resumed query
+            run_query = query_context_controller.get_query(self.query_id)
+            sql = run_query.sql
+            database = run_query.database
+
         if database is not None:
             self.database = database
         else:
@@ -69,12 +78,7 @@ class SQLQuery:
 
         self.outer_query = None
         self.run_query = None
-        self.query_id = query_id
-        if query_id is not None:
-            # resume query
-            run_query = query_context_controller.get_query(self.query_id)
-            run_query.clear_error()
-            sql = run_query.sql
+        self.stop_event = stop_event
 
         if isinstance(sql, str):
             self.query = parse_sql(sql)
@@ -240,7 +244,19 @@ class SQLQuery:
             if self.query_id is not None:
                 self.run_query = query_context_controller.get_query(self.query_id)
             else:
-                self.run_query = query_context_controller.create_query(self.context['query_str'])
+                self.run_query = query_context_controller.create_query(self.context['query_str'], database=self.database)
+
+            if self.planner.plan.is_async and ctx.task_id is None:
+                # add to task
+                self.run_query.add_to_task()
+                # return query info
+                # columns in upper case
+                rec = {k.upper(): v for k, v in self.run_query.get_info().items()}
+                self.fetched_data = ResultSet().from_df(pd.DataFrame([rec]))
+                self.columns_list = self.fetched_data.columns
+                return
+            self.run_query.mark_as_run()
+
             ctx.run_query_id = self.run_query.record.id
 
         step_result = None

mindsdb/api/executor/sql_query/steps/apply_predictor_step.py

@@ -1,8 +1,8 @@
 import datetime as dt
 import re
 
-import dateinfer
 import pandas as pd
+import dateparser
 
 from mindsdb_sql_parser.ast import (
     BinaryOperation,
@@ -95,8 +95,8 @@ class ApplyPredictorRowStepCall(ApplyPredictorBaseCall):
         result = ResultSet()
         result.is_prediction = True
         if len(predictions) == 0:
-            columns = [col['name'] for col in project_datanode.get_table_columns(predictor_name)]
-            predictions = pd.DataFrame([], columns=columns)
+            columns_names = project_datanode.get_table_columns_names(predictor_name)
+            predictions = pd.DataFrame([], columns=columns_names)
 
         result.from_df(
             predictions,
@@ -173,10 +173,10 @@ class ApplyPredictorStepCall(ApplyPredictorBaseCall):
 
         project_datanode = self.session.datahub.get(project_name)
         if len(data) == 0:
-            cols = [col['name'] for col in project_datanode.get_table_columns(predictor_name)] + ['__mindsdb_row_id']
-            for col in cols:
+            columns_names = project_datanode.get_table_columns_names(predictor_name) + ['__mindsdb_row_id']
+            for column_name in columns_names:
                 result.add_column(Column(
-                    name=col,
+                    name=column_name,
                     database=table_name[0],
                     table_name=table_name[1],
                     table_alias=table_name[2]
@@ -262,7 +262,7 @@ class ApplyPredictorStepCall(ApplyPredictorBaseCall):
             return predictor_data
 
         def get_date_format(samples):
-            # dateinfer reads sql date 2020-04-01 as yyyy-dd-mm. workaround for in
+            # Try common formats first with explicit patterns
             for date_format, pattern in (
                 ('%Y-%m-%d', r'[\d]{4}-[\d]{2}-[\d]{2}'),
                 ('%Y-%m-%d %H:%M:%S', r'[\d]{4}-[\d]{2}-[\d]{2} [\d]{2}:[\d]{2}:[\d]{2}'),
@@ -280,7 +280,24 @@ class ApplyPredictorStepCall(ApplyPredictorBaseCall):
                     if date_format is not None:
                         return date_format
 
-            return dateinfer.infer(samples)
+            # Use dateparser as fallback and infer format
+            try:
+                # Parse the first sample to get its format
+                parsed_date = dateparser.parse(samples[0])
+                if parsed_date is None:
+                    raise ValueError("Could not parse date")
+
+                # Verify the format works for all samples
+                for sample in samples[1:]:
+                    if dateparser.parse(sample) is None:
+                        raise ValueError("Inconsistent date formats in samples")
+                # Convert to strftime format based on the input
+                if re.search(r'\d{2}:\d{2}:\d{2}', samples[0]):
+                    return '%Y-%m-%d %H:%M:%S'
+                return '%Y-%m-%d'
+            except (ValueError, AttributeError):
+                # If dateparser fails, return a basic format as last resort
+                return '%Y-%m-%d'
 
         model_types = predictor_metadata['model_types']
         if model_types.get(order_col) in ('float', 'integer'):

mindsdb/api/executor/sql_query/steps/fetch_dataframe_partition.py

@@ -182,7 +182,7 @@ class FetchDataframePartitionCall(BaseStepCall):
             thread_count = get_max_thread_count()
 
         # 3 tasks per worker during 1 batch
-        partition_size = int(run_query.batch_size / thread_count / 3)
+        partition_size = int(run_query.batch_size / thread_count)
         # min partition size
         if partition_size < 10:
             partition_size = 10
@@ -222,7 +222,9 @@ class FetchDataframePartitionCall(BaseStepCall):
                         else:
                             executor.shutdown()
                             raise e
-
+                if self.sql_query.stop_event is not None and self.sql_query.stop_event.is_set():
+                    executor.shutdown()
+                    raise RuntimeError('Query is interrupted')
                 # TODO
                 #  1. get next batch without updating track_value:
                 #    it allows to keep queue_in filled with data between fetching batches

mindsdb/api/executor/sql_query/steps/insert_step.py

@@ -95,7 +95,8 @@ class InsertToTableCall(BaseStepCall):
             table_name=table_name,
             result_set=data,
             is_replace=is_replace,
-            is_create=is_create
+            is_create=is_create,
+            params=step.params
         )
         return ResultSet(affected_rows=response.affected_rows)
 

mindsdb/api/executor/sql_query/steps/prepare_steps.py

@@ -20,15 +20,14 @@ class GetPredictorColumnsCall(BaseStepCall):
     bind = GetPredictorColumns
 
     def call(self, step):
-
         mindsdb_database_name = config.get('default_project')
 
         predictor_name = step.predictor.parts[-1]
         dn = self.session.datahub.get(mindsdb_database_name)
-        columns = [col['name'] for col in dn.get_table_columns(predictor_name)]
+        columns_names = dn.get_table_columns_names(predictor_name)
 
         data = ResultSet()
-        for column_name in columns:
+        for column_name in columns_names:
             data.add_column(Column(
                 name=column_name,
                 table_name=predictor_name,

mindsdb/api/http/namespaces/config.py

@@ -27,33 +27,41 @@ class GetConfig(Resource):
     @api_endpoint_metrics('GET', '/config')
     def get(self):
         config = Config()
-        return {
+        resp = {
             'auth': {
                 'http_auth_enabled': config['auth']['http_auth_enabled']
             }
         }
+        for key in ['default_llm', 'default_embedding_model']:
+            value = config.get(key)
+            if value is not None:
+                resp[key] = value
+        return resp
 
     @ns_conf.doc('put_config')
     @api_endpoint_metrics('PUT', '/config')
     def put(self):
         data = request.json
 
-        unknown_argumens = list(set(data.keys()) - {'auth'})
-        if len(unknown_argumens) > 0:
+        allowed_arguments = {'auth', 'default_llm', 'default_embedding_model'}
+        unknown_arguments = list(set(data.keys()) - allowed_arguments)
+        if len(unknown_arguments) > 0:
             return http_error(
                 HTTPStatus.BAD_REQUEST, 'Wrong arguments',
-                f'Unknown argumens: {unknown_argumens}'
+                f'Unknown argumens: {unknown_arguments}'
             )
 
+        nested_keys_to_validate = {'auth'}
         for key in data.keys():
-            unknown_argumens = list(
-                set(data[key].keys()) - set(Config()[key].keys())
-            )
-            if len(unknown_argumens) > 0:
-                return http_error(
-                    HTTPStatus.BAD_REQUEST, 'Wrong arguments',
-                    f'Unknown argumens: {unknown_argumens}'
+            if key in nested_keys_to_validate:
+                unknown_arguments = list(
+                    set(data[key].keys()) - set(Config()[key].keys())
                 )
+                if len(unknown_arguments) > 0:
+                    return http_error(
+                        HTTPStatus.BAD_REQUEST, 'Wrong arguments',
+                        f'Unknown argumens: {unknown_arguments}'
+                    )
 
         Config().update(data)