cornflow 1.3.4rc2__tar.gz → 1.3.5__tar.gz

{cornflow-1.3.4rc2/cornflow.egg-info → cornflow-1.3.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cornflow
-Version: 1.3.4rc2
+Version: 1.3.5
 Summary: cornflow is an open source multi-solver optimization server with a REST API built using flask.
 Home-page: https://github.com/baobabsoluciones/cornflow
 Author: baobab soluciones
@@ -14,7 +14,7 @@ Requires-Dist: alembic==1.9.2
 Requires-Dist: apispec==6.3.0
 Requires-Dist: cachetools==5.3.3
 Requires-Dist: click==8.1.7
-Requires-Dist: cornflow-client==1.3.4rc2
+Requires-Dist: cornflow-client==1.3.5
 Requires-Dist: cryptography==46.0.5
 Requires-Dist: disposable-email-domains==0.0.162
 Requires-Dist: Flask==2.3.2

{cornflow-1.3.4rc2 → cornflow-1.3.5}/cornflow/commands/auxiliar.py

@@ -87,8 +87,8 @@ def get_new_roles_to_add(extra_permissions, resources_roles_with_access):
 
     for role_id in roles_with_access:
         if role_id not in existing_roles:
-            if role_id in ALL_DEFAULT_ROLES:
-                # Create standard role with predefined name
+            if role_id in ROLES_MAP:
+                # Create role with its predefined name from ROLES_MAP
                 role_name = ROLES_MAP[role_id]
                 new_role = RoleModel(
                     {

{cornflow-1.3.4rc2 → cornflow-1.3.5}/cornflow/commands/dag.py

@@ -49,6 +49,7 @@ def register_deployed_dags_command(
                 "instance_checks_schema": schemas[dag["dag_id"]]["instance_checks"],
                 "solution_checks_schema": schemas[dag["dag_id"]]["solution_checks"],
                 "config_schema": schemas[dag["dag_id"]]["config"],
+                "kpis_schema": schemas[dag["dag_id"]]["kpis"],
             }
         )
         for dag in dag_list
@@ -92,6 +93,7 @@ def register_deployed_dags_command_test(dags: list = None, verbose: bool = False
                 "solution_schema": get_pulp_jsonschema(),
                 "instance_checks_schema": dict(),
                 "solution_checks_schema": dict(),
+                "kpis_schema": dict(),
                 "config_schema": get_empty_schema(solvers=["cbc", "PULP_CBC_CMD"]),
             }
         )
@@ -104,6 +106,7 @@ def register_deployed_dags_command_test(dags: list = None, verbose: bool = False
                 "solution_schema": dict(),
                 "instance_checks_schema": dict(),
                 "solution_checks_schema": dict(),
+                "kpis_schema": dict(),
                 "config_schema": dict(),
             }
         )

{cornflow-1.3.4rc2 → cornflow-1.3.5}/cornflow/config.py

@@ -13,6 +13,7 @@ from cornflow.shared.const import (
 from apispec import APISpec
 from apispec.ext.marshmallow import MarshmallowPlugin
 
+
 class DefaultConfig(object):
     """
     Default configuration class
@@ -110,6 +111,16 @@ class DefaultConfig(object):
     # Alarms endpoints
     ALARMS_ENDPOINTS = os.getenv("CF_ALARMS_ENDPOINT", 0)
 
+    # Execution files
+    EXECUTION_FILES = int(os.getenv("EXECUTION_FILES", 0))
+    execution_files_path = os.path.join(os.getcwd(), "execution_files")
+    EXECUTION_FILES_PATH = os.getenv("EXECUTION_FILES_PATH", execution_files_path)
+    # Cleanup frequency (in days). By default, execution files that are older than 90 days will be deleted.
+    #    If 0: no executions files will ever be deleted.
+    EXECUTION_FILES_CLEANUP_FREQUENCY = int(
+        os.getenv("EXECUTION_FILES_CLEANUP_FREQUENCY", 90)
+    )
+
     # Token duration in hours
     TOKEN_DURATION = os.getenv("TOKEN_DURATION", 24)
 

{cornflow-1.3.4rc2 → cornflow-1.3.5}/cornflow/endpoints/__init__.py

@@ -39,6 +39,8 @@ from .execution import (
     ExecutionDataEndpoint,
     ExecutionLogEndpoint,
     ExecutionRelaunchEndpoint,
+    ExecutionFilesEndpoint,
+    ExecutionFilesCleanupEndpoint
 )
 from .health import HealthEndpoint
 from .instance import (
@@ -128,6 +130,8 @@ resources = [
         endpoint="execution-relaunch",
     ),
     dict(resource=ExecutionEndpoint, urls="/execution/", endpoint="execution"),
+    dict(resource=ExecutionFilesEndpoint, urls="/execution/files/<string:idx>/", endpoint="execution-files"),
+    dict(resource=ExecutionFilesCleanupEndpoint, urls="/execution/files/cleanup/", endpoint="execution-files-cleanup"),
     dict(resource=DAGDetailEndpoint, urls="/dag/<string:idx>/", endpoint="dag"),
     dict(resource=DAGEndpointManual, urls="/dag/", endpoint="dag-manual"),
     dict(

{cornflow-1.3.4rc2 → cornflow-1.3.5}/cornflow/endpoints/data_check.py

@@ -232,6 +232,7 @@ class DataCheckInstanceEndpoint(BaseMetaResource):
             instance_id=instance.id,
             name=f"data_check_instance_{instance.name}",
             schema=instance.schema,
+            checks_and_kpis_only=True,
         )
         schema = instance.schema
 
@@ -337,6 +338,7 @@ class DataCheckCaseKPIsEndpoint(BaseMetaResource):
             instance_id=instance.id,
             name=f"data_check_case_{case.name}",
             schema=schema,
+            checks_and_kpis_only=True,
         )
         if case.solution is not None:
             validation_schema = schema

{cornflow-1.3.4rc2 → cornflow-1.3.5}/cornflow/endpoints/execution.py

@@ -4,18 +4,23 @@ or check the status of an ongoing one
 These endpoints hve different access url, but manage the same data entities
 """
 
-# Import from libraries
-from cornflow_client.airflow.api import Airflow
+# Imports from external libraries
+from datetime import datetime, timedelta, timezone
+from flask import request, current_app, make_response, send_file
+from flask_apispec import marshal_with, use_kwargs, doc
+
+import os
+import time
+import zipfile
 
+# Import from cornflow-client
+from cornflow_client.airflow.api import Airflow
 from cornflow_client.databricks.api import Databricks
 from cornflow_client.constants import INSTANCE_SCHEMA, CONFIG_SCHEMA, SOLUTION_SCHEMA
-from flask import request, current_app
-from flask_apispec import marshal_with, use_kwargs, doc
 
 # Import from internal modules
 from cornflow.endpoints.meta_resource import BaseMetaResource
 from cornflow.models import InstanceModel, DeployedWorkflow, ExecutionModel
-from cornflow.shared.const import config_orchestrator
 from cornflow.schemas.execution import (
     ExecutionDetailsEndpointResponse,
     ExecutionDetailsEndpointWithIndicatorsResponse,
@@ -28,14 +33,15 @@ from cornflow.schemas.execution import (
     QueryFiltersExecution,
     ReLaunchExecutionRequest,
     ExecutionDetailsWithIndicatorsAndLogResponse,
+    ExecutionFilesPostRequest,
 )
 from cornflow.shared.authentication import Auth, authenticate
 from cornflow.shared.compress import compressed
 from cornflow.shared.const import (
+    config_orchestrator,
+    SERVICE_ROLE,
     AIRFLOW_BACKEND,
     DATABRICKS_BACKEND,
-)
-from cornflow.shared.const import (
     AIRFLOW_ERROR_MSG,
     AIRFLOW_NOT_REACHABLE_MSG,
     DAG_PAUSED_MSG,
@@ -49,6 +55,9 @@ from cornflow.shared.const import (
     DATABRICKS_TO_STATE_MAP,
     EXEC_STATE_STOPPED,
     EXEC_STATE_QUEUED,
+    EXECUTION_FILES_STATUS_OK,
+    EXECUTION_FILES_STATUS_DELETED,
+    EXECUTION_FILES_STATUS_MESSAGE_DICT,
 )
 
 from cornflow.shared.exceptions import (
@@ -57,6 +66,7 @@ from cornflow.shared.exceptions import (
     ObjectDoesNotExist,
     InvalidData,
     EndpointNotImplemented,
+    InvalidUsage,
 )
 from cornflow.shared.validators import (
     json_schema_validate_as_string,
@@ -142,14 +152,16 @@ class ExecutionEndpoint(OrchestratorMixin):
           created by the authenticated user) and a integer with the HTTP status code
         :rtype: Tuple(dict, integer)
         """
-        executions = self.get_list(user=self.get_user(), **kwargs)
+        checks_and_kpis = kwargs.pop("checks_and_kpis", False)
+        executions = self.get_list(
+            user=self.get_user(), checks_and_kpis=checks_and_kpis, **kwargs
+        )
         current_app.logger.info(f"User {self.get_user()} gets list of executions")
 
         executions = [
             execution
             for execution in executions
             if not execution.config.get("checks_only", False)
-            and not execution.config.get("checks_and_kpis_only", False)
         ]
 
         running_executions = [
@@ -754,6 +766,190 @@ class ExecutionLogEndpoint(ExecutionDetailsEndpointBase):
         return self.get_detail(user=self.get_user(), idx=idx)
 
 
+class ExecutionFilesEndpointMixin(ExecutionDetailsEndpointBase):
+    """
+    Endpoint used to handle the execution files.
+    """
+
+    ROLES_WITH_ACCESS = [SERVICE_ROLE]
+
+    @staticmethod
+    def check_execution_files_active(func):
+        def wrapper(self, *args, **kwargs):
+            """
+            If execution files are not enabled, return an Exception
+            """
+            if not current_app.config["EXECUTION_FILES"]:
+                raise EndpointNotImplemented(
+                    "Execution files are not active for this deployment"
+                )
+            return func(self, *args, **kwargs)
+
+        return wrapper
+
+    @staticmethod
+    def _get_execution_files_path(execution_idx):
+        """
+        Generate execution files path.
+        """
+        return os.path.join(
+            current_app.config["EXECUTION_FILES_PATH"], f"{execution_idx}.zip"
+        )
+
+
+class ExecutionFilesEndpoint(ExecutionFilesEndpointMixin):
+    @doc(description="Get execution files", tags=["Executions"], inherit=False)
+    @authenticate(auth_class=Auth())
+    @ExecutionFilesEndpointMixin.check_execution_files_active
+    def get(self, idx):
+        """
+        Get the execution files for a specific execution.
+        :param str idx: ID of the execution.
+        """
+        current_app.logger.info(
+            f"User {self.get_user()} gets execution files for execution {idx}"
+        )
+        execution = self.data_model.get_one_object(user=self.get_user(), idx=idx)
+        if execution is None:
+            raise ObjectDoesNotExist(
+                log_txt=f"Error while user {self.get_user()} tries to get the files of execution {idx}. "
+                f"The execution does not exist."
+            )
+
+        execution_files_status = execution.execution_files_status
+        if execution_files_status != EXECUTION_FILES_STATUS_OK:
+            return {
+                "status": execution_files_status,
+                "error": EXECUTION_FILES_STATUS_MESSAGE_DICT[execution_files_status],
+            }, 400
+
+        zip_file_path = self._get_execution_files_path(idx)
+        if not os.path.exists(zip_file_path):
+            # Files were not found. We try indicating to the front to re-generate them.
+            execution.update({"execution_files_status": EXECUTION_FILES_STATUS_DELETED})
+            return {
+                "status": EXECUTION_FILES_STATUS_DELETED,
+                "error": EXECUTION_FILES_STATUS_MESSAGE_DICT[
+                    EXECUTION_FILES_STATUS_DELETED
+                ],
+            }, 400
+
+        # Generate response
+        response = make_response(
+            send_file(
+                zip_file_path,
+                mimetype="application/zip",
+                as_attachment=True,
+                download_name=f'{execution.name}_{time.strftime("%Y%m%d-%H%M%S")}.zip',
+            )
+        )
+        response.headers["X-Message"] = EXECUTION_FILES_STATUS_MESSAGE_DICT[
+            execution_files_status
+        ]
+        response.headers["X-Status-Code"] = "200"
+        return response
+
+    @doc(description="Save an execution's files", tags=["Executions"], inherit=False)
+    @authenticate(auth_class=Auth())
+    @ExecutionFilesEndpointMixin.check_execution_files_active
+    def post(self, idx):
+        """
+        Save the execution files for a specific execution.
+        :param str idx: ID of the execution.
+        :param kwargs: dict with status
+        """
+        current_app.logger.info(
+            f"User {self.get_user()} creates execution files for execution {idx}"
+        )
+
+        # Check request data format
+        request_data = request.values.to_dict()
+        request_data = ExecutionFilesPostRequest().load(request_data)
+
+        execution_files_status = request_data["execution_files_status"]
+
+        execution = self.data_model.get_one_object(user=self.get_user(), idx=idx)
+        if execution is None:
+            raise ObjectDoesNotExist(
+                log_txt=f"Error while user {self.get_user()} tries to save the files of execution {idx}. "
+                f"The execution does not exist."
+            )
+
+        if execution_files_status != EXECUTION_FILES_STATUS_OK:
+            execution.update({"execution_files_status": execution_files_status})
+            return {"message": "Execution files status saved correctly"}, 200
+
+        file = request.files.get("execution_file")
+        if file is None:
+            raise InvalidUsage(
+                "Execution file status was 'OK' but not file was provided."
+            )
+
+        if not file.filename.lower().endswith(".zip") or not zipfile.is_zipfile(
+            file.stream
+        ):
+            raise InvalidUsage("The execution file must be a valid .zip file")
+
+        file.stream.seek(0)
+
+        zip_file_path = self._get_execution_files_path(idx)
+
+        if not os.path.exists(current_app.config["EXECUTION_FILES_PATH"]):
+            os.makedirs(current_app.config["EXECUTION_FILES_PATH"])
+
+        file.save(zip_file_path)
+        execution.update({"execution_files_status": execution_files_status})
+
+        return {"message": "Execution files saved correctly"}, 200
+
+
+class ExecutionFilesCleanupEndpoint(ExecutionFilesEndpointMixin):
+    @doc(description="Clean old executions files", tags=["Executions"], inherit=False)
+    @authenticate(auth_class=Auth())
+    @ExecutionFilesEndpointMixin.check_execution_files_active
+    def delete(self):
+        """
+        Clean old execution files.
+        """
+        current_app.logger.info(f"User {self.get_user()} runs execution files cleanup")
+
+        execution_files_path = current_app.config["EXECUTION_FILES_PATH"]
+        cleanup_frequency = current_app.config["EXECUTION_FILES_CLEANUP_FREQUENCY"]
+        if cleanup_frequency == 0:
+            raise EndpointNotImplemented(
+                "Execution files cleanup is deactivated server-side."
+            )
+
+        if not os.path.exists(execution_files_path):
+            return {"message": "No execution files found"}, 200
+
+        nb_deleted_files = 0
+        for file in os.listdir(execution_files_path):
+            execution_id = file.replace(".zip", "")
+            full_file_path = os.path.join(execution_files_path, file)
+
+            execution = self.data_model.get_one_object(
+                user=self.get_user(), idx=execution_id
+            )
+            today = datetime.now(timezone.utc)
+            if execution is None or (
+                execution.updated_at.replace(tzinfo=timezone.utc)
+                <= today - timedelta(days=cleanup_frequency)
+            ):
+                try:
+                    os.remove(full_file_path)
+                    nb_deleted_files += 1
+                    if execution is not None:
+                        execution.update(
+                            {"execution_files_status": EXECUTION_FILES_STATUS_DELETED}
+                        )
+                except Exception as err:
+                    current_app.logger.error(
+                        f"Error deleting execution file {file}: {err}"
+                    )
+        return {"message": f"{nb_deleted_files} files were deleted."}, 200
+
+
 # region aux_functions
 
 

{cornflow-1.3.4rc2 → cornflow-1.3.5}/cornflow/endpoints/schemas.py

@@ -70,6 +70,7 @@ class SchemaDetailsEndpoint(BaseMetaResource):
                 "solution": deployed_dag.solution_schema,
                 "instance_checks": deployed_dag.instance_checks_schema,
                 "solution_checks": deployed_dag.solution_checks_schema,
+                "kpis": deployed_dag.kpis_schema,
                 "config": deployed_dag.config_schema,
                 "name": dag_name,
             }, 200

{cornflow-1.3.4rc2 → cornflow-1.3.5}/cornflow/endpoints/user_role.py

@@ -18,6 +18,10 @@ from cornflow.shared.exceptions import EndpointNotImplemented, ObjectAlreadyExis
 
 class UserRoleListEndpoint(BaseMetaResource):
     ROLES_WITH_ACCESS = [ADMIN_ROLE]
+    # Other roles can get their own roles, but not all roles
+    # This is because the admin role is the only one that can get all roles
+    # and the other roles can only get their own roles
+
     DESCRIPTION = (
         "Endpoint to get the list of roles assigned to users and create new assignments"
     )
@@ -34,16 +38,22 @@ class UserRoleListEndpoint(BaseMetaResource):
         API method to get the assigned roles to the users defined in the application.
         It requires authentication to be passed in the form of a token that has to be linked to
         an existing session (login) made by a user.
+        Admin users receive every assignment; other users receive only their own.
 
         :return: A dictionary with the response (data of the user assigned roles or an error message)
         and an integer with the HTTP status code.
         :rtype: Tuple(dict, integer)
 
         """
+        if self.is_admin():
+            current_app.logger.info(
+                f"User {self.get_user()} gets all user roles assignments"
+            )
+            return self.get_list()
         current_app.logger.info(
-            f"User {self.get_user()} gets all user roles assignments"
+            f"User {self.get_user()} gets their own user role assignments"
         )
-        return self.get_list()
+        return self.get_list(user_id=self.get_user_id())
 
     @doc(description="Creates a new role assignment", tags=["User roles"])
     @authenticate(auth_class=Auth())

cornflow-1.3.5/cornflow/migrations/versions/4729cd156460_.py

@@ -0,0 +1,38 @@
+"""empty message
+
+Revision ID: 4729cd156460
+Revises: 9cacf194fa1c
+Create Date: 2026-05-07 14:58:53.461691
+
+"""
+
+from alembic import op
+import sqlalchemy as sa
+
+
+# revision identifiers, used by Alembic.
+revision = "4729cd156460"
+down_revision = "9cacf194fa1c"
+branch_labels = None
+depends_on = None
+
+
+def upgrade():
+    with op.batch_alter_table("executions", schema=None) as batch_op:
+        batch_op.add_column(
+            sa.Column("execution_files_status", sa.SmallInteger(), nullable=True)
+        )
+
+    op.execute(
+        'update "executions" set execution_files_status = 0 where execution_files_status is null'
+    )
+
+    with op.batch_alter_table("executions", schema=None) as batch_op:
+        batch_op.alter_column(
+            "execution_files_status", existing_type=sa.SmallInteger(), nullable=False
+        )
+
+
+def downgrade():
+    with op.batch_alter_table("executions", schema=None) as batch_op:
+        batch_op.drop_column("execution_files_status")

cornflow-1.3.5/cornflow/migrations/versions/9cacf194fa1c_.py

@@ -0,0 +1,40 @@
+"""
+Add kpis_schema to deployed_workflows, add checks_and_kpis_only to execution
+
+Revision ID: 9cacf194fa1c
+Revises: 509d280698e4
+Create Date: 2026-04-13 09:44:59.661880
+
+"""
+
+from alembic import op
+import sqlalchemy as sa
+from sqlalchemy.dialects import postgresql
+
+# revision identifiers, used by Alembic.
+revision = "9cacf194fa1c"
+down_revision = "509d280698e4"
+branch_labels = None
+depends_on = None
+
+
+def upgrade():
+    with op.batch_alter_table("deployed_workflows", schema=None) as batch_op:
+        batch_op.add_column(
+            sa.Column(
+                "kpis_schema", postgresql.JSON(astext_type=sa.Text()), nullable=True
+            )
+        )
+
+    with op.batch_alter_table("executions", schema=None) as batch_op:
+        batch_op.add_column(
+            sa.Column("checks_and_kpis_only", sa.Boolean(), nullable=True)
+        )
+
+
+def downgrade():
+    with op.batch_alter_table("executions", schema=None) as batch_op:
+        batch_op.drop_column("checks_and_kpis_only")
+
+    with op.batch_alter_table("deployed_workflows", schema=None) as batch_op:
+        batch_op.drop_column("kpis_schema")

{cornflow-1.3.4rc2 → cornflow-1.3.5}/cornflow/models/dag.py

@@ -7,6 +7,7 @@ from cornflow_client.constants import (
     SOLUTION_SCHEMA,
     INSTANCE_CHECKS_SCHEMA,
     SOLUTION_CHECKS_SCHEMA,
+    KPIS_SCHEMA,
 )
 from sqlalchemy.dialects.postgresql import TEXT, JSON
 
@@ -29,6 +30,7 @@ class DeployedWorkflow(TraceAttributesModel):
     config_schema = db.Column(JSON, nullable=True)
     instance_checks_schema = db.Column(JSON, nullable=True)
     solution_checks_schema = db.Column(JSON, nullable=True)
+    kpis_schema = db.Column(JSON, nullable=True)
 
     dag_permissions = db.relationship(
         "PermissionsDAG",
@@ -46,6 +48,7 @@ class DeployedWorkflow(TraceAttributesModel):
         self.instance_checks_schema = data.get("instance_checks_schema", None)
         self.solution_checks_schema = data.get("solution_checks_schema", None)
         self.config_schema = data.get("config_schema", None)
+        self.kpis_schema = data.get("kpis_schema", None)
 
     def __repr__(self):
         return f"<DAG {self.id}>"
@@ -70,7 +73,8 @@ class DeployedWorkflow(TraceAttributesModel):
             jsonschema = item.instance_checks_schema
         elif schema == SOLUTION_CHECKS_SCHEMA:
             jsonschema = item.solution_checks_schema
-        # schema == CONFIG_SCHEMA
+        elif schema == KPIS_SCHEMA:
+            jsonschema = item.kpis_schema
         else:
             jsonschema = item.config_schema
 

{cornflow-1.3.4rc2 → cornflow-1.3.5}/cornflow/models/execution.py

@@ -3,13 +3,22 @@ Model for the executions
 """
 
 # Import from libraries
+from flask import current_app
 import hashlib
 from sqlalchemy.dialects.postgresql import JSON, TEXT
+from sqlalchemy import desc, or_
+from sqlalchemy.sql.expression import false
 
 # Imports from internal modules
 from cornflow.models.base_data_model import BaseDataModel
 from cornflow.shared import db
-from cornflow.shared.const import DEFAULT_EXECUTION_CODE, EXECUTION_STATE_MESSAGE_DICT
+from cornflow.shared.const import (
+    DEFAULT_EXECUTION_CODE,
+    EXECUTION_STATE_MESSAGE_DICT,
+    EXECUTION_FILES_STATUS_NOT_GENERATED,
+    EXECUTION_FILES_STATUS_OK,
+    EXECUTION_FILES_STATUS_NOT_UP_TO_DATE,
+)
 
 
 class ExecutionModel(BaseDataModel):
@@ -70,6 +79,10 @@ class ExecutionModel(BaseDataModel):
     )
     kpis = db.Column(JSON, nullable=True)
     last_run_checks_and_kpis = db.Column(db.Boolean, nullable=True)
+    checks_and_kpis_only = db.Column(db.Boolean, nullable=True)
+    execution_files_status = db.Column(
+        db.SmallInteger, default=EXECUTION_FILES_STATUS_NOT_GENERATED, nullable=False
+    )
 
     def __init__(self, data):
         super().__init__(data)
@@ -92,6 +105,10 @@ class ExecutionModel(BaseDataModel):
         self.log_json = data.get("log_json")
         self.kpis = data.get("kpis")
         self.last_run_checks_and_kpis = data.get("last_run_checks_and_kpis", False)
+        self.checks_and_kpis_only = data.get("checks_and_kpis_only", False)
+        self.execution_files_status = data.get(
+            "execution_files_status", EXECUTION_FILES_STATUS_NOT_GENERATED
+        )
 
     def update(self, data):
         """
@@ -101,10 +118,12 @@ class ExecutionModel(BaseDataModel):
         :return: None
         :rtype: None
         """
-        # Delete the checks and KPIs if the data has been modified since they are probably not valid anymore
+        # Delete the checks and KPIs if the data has been modified since they are probably not valid anymore.
         if "data" in data.keys():
             self.checks = None
             self.kpis = None
+            if self.execution_files_status == EXECUTION_FILES_STATUS_OK:
+                self.execution_files_status = EXECUTION_FILES_STATUS_NOT_UP_TO_DATE
         super().update(data)
 
     def update_config(self, config: dict):
@@ -142,6 +161,55 @@ class ExecutionModel(BaseDataModel):
         self.log_text = txt
         super().update({})
 
+    @classmethod
+    def get_all_objects(
+        cls,
+        user,
+        schema=None,
+        creation_date_gte=None,
+        creation_date_lte=None,
+        checks_and_kpis=False,
+        offset=0,
+        limit=10,
+    ):
+        """
+        Query to get all objects from a user
+        :param UserModel user: User object.
+        :param string schema: data_schema to filter (dag)
+        :param string creation_date_gte: created_at needs to be larger or equal to this
+        :param string creation_date_lte: created_at needs to be smaller or equal to this
+        :param int offset: query offset for pagination
+        :param bool checks_and_kpis: include checks and kpis executions
+        :param int limit: query size limit
+        :return: The objects
+        :rtype: list(:class:`BaseDataModel`)
+        """
+        query = cls.query.filter(cls.deleted_at == None)
+        user_access = int(current_app.config["USER_ACCESS_ALL_OBJECTS"])
+        if (
+            user is not None
+            and not user.is_admin()
+            and not user.is_service_user()
+            and user_access == 0
+        ):
+            query = query.filter(cls.user_id == user.id)
+
+        if schema:
+            query = query.filter(cls.schema == schema)
+        if creation_date_gte:
+            query = query.filter(cls.created_at >= creation_date_gte)
+        if creation_date_lte:
+            query = query.filter(cls.created_at <= creation_date_lte)
+        if not checks_and_kpis:
+            query = query.filter(
+                or_(
+                    cls.checks_and_kpis_only == false(),
+                    cls.checks_and_kpis_only.is_(None),
+                )
+            )
+
+        return query.order_by(desc(cls.created_at)).offset(offset).limit(limit).all()
+
     def __repr__(self):
         """
         Method to represent the class :class:`ExecutionModel`

{cornflow-1.3.4rc2 → cornflow-1.3.5}/cornflow/schemas/dag.py

@@ -11,6 +11,7 @@ class DeployedDAGSchema(Schema):
     config_schema = fields.Raw(required=True, allow_none=False)
     instance_checks_schema = fields.Raw(required=True, allow_none=False)
     solution_checks_schema = fields.Raw(required=True, allow_none=False)
+    kpis_schema = fields.Raw(required=True, allow_none=False)
 
 
 class DeployedDAGEditSchema(Schema):
@@ -20,3 +21,4 @@ class DeployedDAGEditSchema(Schema):
     config_schema = fields.Raw(required=False)
     instance_checks_schema = fields.Raw(required=True, allow_none=False)
     solution_checks_schema = fields.Raw(required=True, allow_none=False)
+    kpis_schema = fields.Raw(required=True, allow_none=False)