cornflow 2.0.0a12__py3-none-any.whl → 2.0.0a14__py3-none-any.whl

cornflow/endpoints/execution.py

@@ -6,10 +6,9 @@ These endpoints hve different access url, but manage the same data entities
 
 # Import from libraries
 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
-
-# TODO AGA: Porqué el import no funcina correctamente
 from flask import request, current_app
 from flask_apispec import marshal_with, use_kwargs, doc
 
@@ -37,6 +36,9 @@ from cornflow.shared.const import (
     DATABRICKS_BACKEND,
 )
 from cornflow.shared.const import (
+    AIRFLOW_ERROR_MSG,
+    AIRFLOW_NOT_REACHABLE_MSG,
+    DAG_PAUSED_MSG,
     EXEC_STATE_RUNNING,
     EXEC_STATE_ERROR,
     EXEC_STATE_ERROR_START,
@@ -64,7 +66,7 @@ from cornflow.shared.validators import (
 
 class ExecutionEndpoint(BaseMetaResource):
     """
-    Endpoint used to create and get executions
+    Endpoint used to create a new execution or get all the executions and their information back
     """
 
     def __init__(self):
@@ -157,10 +159,10 @@ class ExecutionEndpoint(BaseMetaResource):
                 )
                 continue
 
-            if not self.orch_client.is_alive():
+            if not self.orch_client.is_alive(config=current_app.config):
                 current_app.logger.warning(
-                    "Error while the app tried to update the status of all running executions."
-                    "Airflow is not accessible."
+                    f"Error while the app tried to update the status of all running executions."
+                    f"{AIRFLOW_NOT_REACHABLE_MSG}"
                 )
                 continue
             try:
@@ -170,7 +172,7 @@ class ExecutionEndpoint(BaseMetaResource):
             except self.orch_error as err:
                 current_app.logger.warning(
                     "Error while the app tried to update the status of all running executions."
-                    f"Orchestrator responded with an error: {err}"
+                    f"{AIRFLOW_ERROR_MSG} {err}"
                 )
                 continue
 
@@ -207,6 +209,10 @@ class ExecutionEndpoint(BaseMetaResource):
             user=self.get_user(), idx=execution.instance_id
         )
 
+        if execution.schema != instance.schema:
+            execution.delete()
+            raise InvalidData(error="Instance and execution schema mismatch")
+
         current_app.logger.debug(f"The request is: {request.args.get('run')}")
         # this allows testing without  orchestrator interaction:
         if request.args.get("run", "1") == "0":
@@ -286,22 +292,21 @@ class ExecutionEndpoint(BaseMetaResource):
         if self.orch_type == AIRFLOW_BACKEND:
             info = schema_info.json()
             if info["is_paused"]:
-                err = "The dag exists but it is paused in airflow"
-                current_app.logger.error(err)
+                current_app.logger.error(DAG_PAUSED_MSG)
                 execution.update_state(EXEC_STATE_ERROR_START)
                 raise self.orch_error(
-                    error=err,
+                    error=DAG_PAUSED_MSG,
                     payload=dict(
                         message=EXECUTION_STATE_MESSAGE_DICT[EXEC_STATE_ERROR_START],
                         state=EXEC_STATE_ERROR_START,
                     ),
                     log_txt=f"Error while user {self.get_user()} tries to create an execution. "
-                    + err,
+                    + DAG_PAUSED_MSG,
                 )
         # TODO AGA: revisar si hay que hacer alguna verificación a los JOBS
 
         try:
-            # TODO AGA: Hay que genestionar la posible eliminación de execution.id como
+            # TODO AGA: Hay que gestionar la posible eliminación de execution.id como
             #   parámetro, ya que no se puede seleccionar el id en databricks
             #   revisar las consecuencias que puede tener
             response = self.orch_client.run_workflow(execution.id, orch_name=schema)
@@ -321,7 +326,8 @@ class ExecutionEndpoint(BaseMetaResource):
 
         # if we succeed, we register the run_id in the execution table:
         orch_data = response.json()
-        print("orch data is ", orch_data)
+        info = "orch data is " + str(orch_data)
+        current_app.logger.info(info)
         execution.run_id = orch_data[self.orch_const["run_id"]]
         execution.update_state(EXEC_STATE_QUEUED)
         current_app.logger.info(
@@ -446,17 +452,16 @@ class ExecutionRelaunchEndpoint(BaseMetaResource):
         info = schema_info.json()
         if self.orch_type == AIRFLOW_BACKEND:
             if info["is_paused"]:
-                err = "The dag exists but it is paused in airflow"
-                current_app.logger.error(err)
+                current_app.logger.error(AIRFLOW_NOT_REACHABLE_MSG)
                 execution.update_state(EXEC_STATE_ERROR_START)
                 raise self.orch_error(
-                    error=err,
+                    error=AIRFLOW_NOT_REACHABLE_MSG,
                     payload=dict(
                         message=EXECUTION_STATE_MESSAGE_DICT[EXEC_STATE_ERROR_START],
                         state=EXEC_STATE_ERROR_START,
                     ),
                     log_txt=f"Error while user {self.get_user()} tries to relaunch execution {idx}. "
-                    + err,
+                    + AIRFLOW_NOT_REACHABLE_MSG,
                 )
         # TODO GG: revisar si hay que hacer alguna comprobación del estilo a databricks
         try:
@@ -626,14 +631,13 @@ class ExecutionDetailsEndpoint(ExecutionDetailsEndpointBase):
                 f"The execution does not exist."
             )
 
-        if not self.orch_client.is_alive():
-            err = self.orch_const["name"] + " is not accessible"
+        if not self.orch_client.is_alive(config=current_app.config):
             raise self.orch_error(
-                error=err,
-                log_txt=f"Error while user {self.get_user()} tries to stop execution {idx}. {err}",
+                error=AIRFLOW_NOT_REACHABLE_MSG,
+                log_txt=f"Error while user {self.get_user()} tries to stop execution {idx}. {AIRFLOW_NOT_REACHABLE_MSG}",
             )
 
-        response = self.orch_client.set_dag_run_to_fail(
+        self.orch_client.set_dag_run_to_fail(
             dag_name=execution.schema, run_id=execution.run_id
         )
         # We should check if the execution has been stopped
@@ -897,7 +901,7 @@ def get_databricks(schema, execution, message="tries to create an execution"):
     """
     db_client = Databricks.from_config(current_app.config)
     schema_info = db_client.get_orch_info(schema)
-    if not db_client.is_alive():
+    if not db_client.is_alive(config=current_app.config):
         err = "Databricks is not accessible"
         current_app.logger.error(err)
         execution.update_state(EXEC_STATE_ERROR_START)

cornflow/endpoints/health.py

@@ -20,7 +20,7 @@ from cornflow.shared.const import (
     STATUS_HEALTHY,
     STATUS_UNHEALTHY,
 )
-from cornflow.shared.databricks import Databricks
+from cornflow_client.databricks.api import Databricks
 from cornflow.shared.exceptions import EndpointNotImplemented
 
 
@@ -35,11 +35,10 @@ class HealthEndpoint(BaseMetaResource):
         :rtype: dict
         :doc-author: baobab soluciones
         """
-        
+
         backend_status = self.check_backend_status()
 
         cornflow_status = STATUS_UNHEALTHY
-        
 
         if (
             UserModel.get_one_user_by_username(os.getenv("CORNFLOW_SERVICE_USER"))
@@ -75,5 +74,5 @@ class HealthEndpoint(BaseMetaResource):
         databricks_status = STATUS_UNHEALTHY
         if db_client.is_alive():
             databricks_status = STATUS_HEALTHY
-        
-        return databricks_status
+
+        return databricks_status

cornflow/endpoints/instance.py

@@ -34,7 +34,6 @@ from cornflow.shared.exceptions import InvalidUsage, InvalidData
 from cornflow.shared.validators import json_schema_validate_as_string
 
 
-
 # Initialize the schema that all endpoints are going to use
 ALLOWED_EXTENSIONS = {"mps", "lp"}
 
@@ -92,14 +91,18 @@ class InstanceEndpoint(BaseMetaResource):
         # We validate the instance data
         config = current_app.config
 
-        instance_schema = DeployedOrch.get_one_schema(config, data_schema, INSTANCE_SCHEMA)
-        instance_errors = json_schema_validate_as_string(instance_schema, kwargs["data"])
+        instance_schema = DeployedOrch.get_one_schema(
+            config, data_schema, INSTANCE_SCHEMA
+        )
+        instance_errors = json_schema_validate_as_string(
+            instance_schema, kwargs["data"]
+        )
 
         if instance_errors:
             raise InvalidData(
                 payload=dict(jsonschema_errors=instance_errors),
                 log_txt=f"Error while user {self.get_user()} tries to create an instance. "
-                        f"Instance data do not match the jsonschema.",
+                f"Instance data do not match the jsonschema.",
             )
 
         # if we're here, we validated and the data seems to fit the schema
@@ -163,14 +166,18 @@ class InstanceDetailsEndpoint(InstanceDetailsEndpointBase):
 
             config = current_app.config
 
-            instance_schema = DeployedOrch.get_one_schema(config, schema, INSTANCE_SCHEMA)
-            instance_errors = json_schema_validate_as_string(instance_schema, kwargs["data"])
+            instance_schema = DeployedOrch.get_one_schema(
+                config, schema, INSTANCE_SCHEMA
+            )
+            instance_errors = json_schema_validate_as_string(
+                instance_schema, kwargs["data"]
+            )
 
             if instance_errors:
                 raise InvalidData(
                     payload=dict(jsonschema_errors=instance_errors),
                     log_txt=f"Error while user {self.get_user()} tries to create an instance. "
-                            f"Instance data do not match the jsonschema.",
+                    f"Instance data do not match the jsonschema.",
                 )
 
         response = self.put_detail(data=kwargs, user=self.get_user(), idx=idx)
@@ -268,15 +275,35 @@ class InstanceFileEndpoint(BaseMetaResource):
         sense = 1 if minimize else -1
         try:
             _vars, problem = pulp.LpProblem.fromMPS(filename, sense=sense)
-        except:
+        except FileNotFoundError as e:
+            # Handle file not found specifically
             raise InvalidUsage(
-                error="There was an error reading the file",
-                log_txt=f"Error while user {self.get_user()} tries to create instance from mps file. "
-                f"There was an error reading the file.",
+                error=f"MPS file not found: {filename}",
+                log_txt=f"Error for user {self.get_user()}: MPS file '{filename}' not found. Details: {e}",
+                status_code=404,
+            ) from e
+        except PermissionError as e:
+            # Handle permission issues
+            raise InvalidUsage(
+                error=f"Permission denied reading MPS file: {filename}",
+                log_txt=f"Error for user {self.get_user()}: Permission denied for MPS file '{filename}'. Details: {e}",
+                status_code=403,
+            ) from e
+        except (ValueError, pulp.PulpError, OSError, IndexError) as e:
+            # Catch parsing errors, PuLP errors, and other IO errors
+            # Handle parsing, PuLP, or other OS errors
+            current_app.logger.error(
+                f"Error parsing MPS file {filename} for user {self.get_user()}: {e}",
+                exc_info=True,
             )
+            raise InvalidUsage(
+                error="Error reading or parsing the MPS file.",
+                log_txt=f"Error while user {self.get_user()} tries to create instance from MPS file {filename}. Details: {e}",
+            ) from e
+
         try:
             os.remove(filename)
-        except:
+        except FileNotFoundError:
             pass
 
         pb_data = dict(

cornflow/endpoints/meta_resource.py

@@ -1,6 +1,7 @@
 """
 This file has all the logic shared for all the resources
 """
+
 # Import from external libraries
 from flask_restful import Resource
 from flask import g, request
@@ -13,7 +14,6 @@ from cornflow.shared.const import ALL_DEFAULT_ROLES
 from cornflow.shared.exceptions import InvalidUsage, ObjectDoesNotExist, NoPermission
 
 
-
 class BaseMetaResource(Resource, MethodResource):
     """
     The base resource from all methods inherit from.
@@ -30,7 +30,6 @@ class BaseMetaResource(Resource, MethodResource):
         self.auth_class = None
         self.dependents = None
         self.unique = None
-        pass
 
     """
     METHODS USED FOR THE BASIC CRUD OPERATIONS: GET, POST, PUT, PATCH, DELETE 
@@ -121,7 +120,7 @@ class BaseMetaResource(Resource, MethodResource):
         """
         item = self.data_model.get_one_object(**kwargs)
         if item is None:
-            raise ObjectDoesNotExist("The data entity does not exist on the database")
+            raise ObjectDoesNotExist()
 
         data = dict(data)
 
@@ -144,7 +143,7 @@ class BaseMetaResource(Resource, MethodResource):
         item = self.data_model.get_one_object(**kwargs)
 
         if item is None:
-            raise ObjectDoesNotExist("The data entity does not exist on the database")
+            raise ObjectDoesNotExist()
 
         data = dict(data)
 
@@ -164,7 +163,7 @@ class BaseMetaResource(Resource, MethodResource):
         """
         item = self.data_model.get_one_object(**kwargs)
         if item is None:
-            raise ObjectDoesNotExist("The data entity does not exist on the database")
+            raise ObjectDoesNotExist()
         if self.dependents is not None:
             for element in getattr(item, self.dependents):
                 element.delete()

cornflow/schemas/execution.py

@@ -78,6 +78,7 @@ class ExecutionEditRequest(Schema):
     name = fields.Str()
     description = fields.Str()
     data = fields.Raw()
+    instance_id = fields.Str(required=False)
 
 
 class ExecutionDagRequest(Schema):

cornflow/shared/airflow.py

@@ -0,0 +1,157 @@
+""" """
+
+# Full imports
+import json
+import requests
+
+# Partial imports
+from requests.auth import HTTPBasicAuth
+from requests.exceptions import ConnectionError, HTTPError
+
+# Imports from modules
+from cornflow_client.constants import AirflowError
+from cornflow_client.orchestrator_constants import config_orchestrator
+
+
+class Airflow(object):
+    def __init__(self, url, user, pwd):
+        self.url = f"{url}/api/v1"
+        self.auth = HTTPBasicAuth(user, pwd)
+        self.constants = config_orchestrator["airflow"]
+
+    @classmethod
+    def from_config(cls, config):
+        data = dict(
+            url=config["AIRFLOW_URL"],
+            user=config["AIRFLOW_USER"],
+            pwd=config["AIRFLOW_PWD"],
+        )
+        return cls(**data)
+
+    def is_alive(self, config=None):
+        try:
+            response = requests.get(f"{self.url}/health")
+        except (ConnectionError, HTTPError):
+            return False
+        try:
+            data = response.json()
+            database = data["metadatabase"]["status"] == "healthy"
+            scheduler = data["scheduler"]["status"] == "healthy"
+        except json.JSONDecodeError:
+            return False
+        except KeyError:
+            return False
+
+        return database and scheduler
+
+    def get_dag_info(self, dag_name, method="GET"):
+        url = f"{self.url}/dags/{dag_name}"
+        return self.request_headers_auth(method=method, url=url)
+
+    def request_headers_auth(self, status=200, **kwargs):
+        def_headers = {"Content-type": "application/json", "Accept": "application/json"}
+        headers = kwargs.get("headers", def_headers)
+        response = requests.request(headers=headers, auth=self.auth, **kwargs)
+        if response.status_code != status:
+            raise AirflowError(error=response.text, status_code=response.status_code)
+        return response
+
+    def consume_dag_run(self, dag_name, payload, dag_run_id=None, method="POST"):
+        url = f"{self.url}/dags/{dag_name}/dagRuns"
+        if dag_run_id is not None:
+            url = url + f"/{dag_run_id}"
+        response = self.request_headers_auth(method=method, url=url, json=payload)
+        return response
+
+    def set_dag_run_state(self, dag_name, payload):
+        url = f"{self.url}/dags/{dag_name}/updateTaskInstancesState"
+        return self.request_headers_auth(method="POST", url=url, json=payload)
+
+    def run_workflow(
+        self,
+        execution_id,
+        orch_name=config_orchestrator["airflow"]["def_schema"],
+        checks_only=False,
+        case_id=None,
+    ):
+        conf = dict(exec_id=execution_id, checks_only=checks_only)
+        if case_id is not None:
+            conf["case_id"] = case_id
+        payload = dict(conf=conf)
+        return self.consume_dag_run(orch_name, payload=payload, method="POST")
+
+    def update_schemas(self, dag_name="update_all_schemas"):
+        return self.consume_dag_run(dag_name, payload={}, method="POST")
+
+    def update_dag_registry(self, dag_name="update_dag_registry"):
+        return self.consume_dag_run(dag_name, payload={}, method="POST")
+
+    def get_run_status(self, schema, run_id):
+        return self.consume_dag_run(
+            schema, payload=None, dag_run_id=run_id, method="GET"
+        )
+
+    def set_dag_run_to_fail(self, dag_name, run_id, new_status="failed"):
+        # here, two calls have to be done:
+        # first we get information on the dag_run
+        dag_run = self.consume_dag_run(
+            dag_name, payload=None, dag_run_id=run_id, method="GET"
+        )
+        dag_run_data = dag_run.json()
+        # then, we use the "executed_date" to build a call to the change state api
+        # TODO: We assume the solving task is named as is parent dag!
+        payload = dict(
+            dry_run=False,
+            include_downstream=True,
+            include_future=False,
+            include_past=False,
+            include_upstream=True,
+            new_state=new_status,
+            task_id=dag_name,
+            execution_date=dag_run_data["execution_date"],
+        )
+        return self.set_dag_run_state(dag_name, payload=payload)
+
+    def get_all_dag_runs(self, dag_name):
+        return self.consume_dag_run(dag_name=dag_name, payload=None, method="GET")
+
+    def get_orch_info(self, orch_name, method="GET"):
+        url = f"{self.url}/dags/{orch_name}"
+        schema_info = self.request_headers_auth(method=method, url=url)
+        if schema_info.status_code != 200:
+            raise AirflowError("DAG not available")
+        return schema_info
+
+    def get_one_variable(self, variable):
+        url = f"{self.url}/variables/{variable}"
+        return self.request_headers_auth(method="GET", url=url).json()
+
+    def get_all_variables(self):
+        return self.request_headers_auth(
+            method="GET", url=f"{self.url}/variables"
+        ).json()
+
+    def get_one_schema(self, dag_name, schema):
+        return self.get_schemas_for_dag_name(dag_name)[schema]
+
+    def get_schemas_for_dag_name(self, dag_name):
+        response = self.get_one_variable(dag_name)
+        result = json.loads(response["value"])
+        result["name"] = response["key"]
+        return result
+
+    def get_all_schemas(self):
+        response = self.get_all_variables()
+        return [dict(name=variable["key"]) for variable in response["variables"]]
+
+    def get_all_dags(self, method="GET"):
+        url = f"{self.url}/dags"
+        return self.request_headers_auth(method=method, url=url)
+
+    def get_internal_dags(self, method="GET"):
+        url = f"{self.url}/dags?tags=internal"
+        return self.request_headers_auth(method=method, url=url)
+
+    def get_model_dags(self, method="GET"):
+        url = f"{self.url}/dags?tags=model"
+        return self.request_headers_auth(method=method, url=url)

cornflow/shared/authentication/auth.py

@@ -2,15 +2,16 @@
 This file contains the auth class that can be used for authentication on the request to the REST API
 """
 
-# Imports from external libraries
-import jwt
-import requests
-from jwt.algorithms import RSAAlgorithm
 from datetime import datetime, timedelta, timezone
-from flask import request, g, current_app, Request
 from functools import wraps
 from typing import Tuple
+
+# Imports from external libraries
+import jwt
+import requests
 from cachetools import TTLCache
+from flask import request, g, current_app, Request
+from jwt.algorithms import RSAAlgorithm
 from werkzeug.datastructures import Headers
 
 # Imports from internal modules
@@ -31,7 +32,6 @@ from cornflow.shared.exceptions import (
     InvalidData,
     InvalidUsage,
     NoPermission,
-    ObjectDoesNotExist,
 )
 
 # Cache for storing public keys with 1 hour TTL
@@ -122,15 +122,13 @@ class Auth:
     def decode_token(token: str = None) -> dict:
         """
         Decodes a given JSON Web token and extracts the username from the sub claim.
-        Works with both internal tokens and OpenID tokens.
+        Works with both internal tokens and OpenID tokens by attempting verification methods sequentially.
 
         :param str token: the given JSON Web Token
         :return: dictionary containing the username from the token's sub claim
         :rtype: dict
         """
-
         if token is None:
-
             raise InvalidCredentials(
                 "Must provide a token in Authorization header",
                 log_txt="Error while trying to decode token. Token is missing.",
@@ -138,48 +136,81 @@ class Auth:
             )
 
         try:
-            # First try to decode header to validate basic token structure
-
-            unverified_payload = jwt.decode(token, options={"verify_signature": False})
-            issuer = unverified_payload.get("iss")
-
-            # For internal tokens
-            if issuer == INTERNAL_TOKEN_ISSUER:
-
-                return jwt.decode(
-                    token, current_app.config["SECRET_TOKEN_KEY"], algorithms="HS256"
-                )
-
-            # For OpenID tokens
-            if current_app.config["AUTH_TYPE"] == AUTH_OID:
-
-                return Auth().verify_token(
-                    token,
-                    current_app.config["OID_PROVIDER"],
-                    current_app.config["OID_EXPECTED_AUDIENCE"],
-                )
-
-            # If we get here, the issuer is not valid
-
-            raise InvalidCredentials(
-                "Invalid token issuer. Token must be issued by a valid provider",
-                log_txt="Error while trying to decode token. Invalid issuer.",
-                status_code=400,
+            # Attempt 1: Verify as an internal token (HS256)
+            payload = jwt.decode(
+                token, current_app.config["SECRET_TOKEN_KEY"], algorithms=["HS256"]
             )
+            if payload.get("iss") != INTERNAL_TOKEN_ISSUER:
+                raise jwt.InvalidIssuerError(
+                    "Internal token issuer mismatch after verification"
+                )
+            return payload
 
         except jwt.ExpiredSignatureError:
-
+            # Handle expiration specifically, could apply to either token type if caught here first
             raise InvalidCredentials(
                 "The token has expired, please login again",
                 log_txt="Error while trying to decode token. The token has expired.",
                 status_code=400,
             )
-        except jwt.InvalidTokenError as e:
-
+        except (
+            jwt.InvalidSignatureError,
+            jwt.DecodeError,
+            jwt.InvalidTokenError,
+        ) as e_internal:
+            # Internal verification failed (signature, format, etc.). Try OIDC if configured.
+            if current_app.config["AUTH_TYPE"] == AUTH_OID:
+                try:
+                    # Attempt 2: Verify as an OIDC token (RS256) using the dedicated method
+                    return Auth().verify_token(
+                        token,
+                        current_app.config["OID_PROVIDER"],
+                        current_app.config["OID_EXPECTED_AUDIENCE"],
+                    )
+                except jwt.ExpiredSignatureError:
+                    # OIDC token expired
+                    raise InvalidCredentials(
+                        "The token has expired, please login again",
+                        log_txt="Error while trying to decode OIDC token. The token has expired.",
+                        status_code=400,
+                    )
+                except (
+                    jwt.InvalidTokenError,
+                    InvalidCredentials,
+                    CommunicationError,
+                ) as e_oidc:
+                    # OIDC verification failed (JWT format, signature, kid, audience, issuer, comms error)
+                    # Log details for debugging but return a generic error to the client.
+                    log_message = (
+                        f"Error decoding token. Internal verification failed ({type(e_internal).__name__}). "
+                        f"OIDC verification failed ({type(e_oidc).__name__}: {str(e_oidc)})."
+                    )
+                    current_app.logger.warning(log_message)
+                    raise InvalidCredentials(
+                        "Invalid token format, signature, or configuration",
+                        log_txt=log_message,
+                        status_code=400,
+                    )
+            else:
+                # Internal verification failed, and OIDC is not configured
+                log_message = (
+                    f"Error decoding token. Internal verification failed ({type(e_internal).__name__}). "
+                    f"OIDC is not configured."
+                )
+                current_app.logger.warning(log_message)
+                raise InvalidCredentials(
+                    "Invalid token format or signature",
+                    log_txt=log_message,
+                    status_code=400,
+                )
+        except Exception as e:
+            # Catch any other unexpected errors during the process
+            log_message = f"Unexpected error during token decoding: {str(e)}"
+            current_app.logger.error(log_message)
             raise InvalidCredentials(
-                "Invalid token format or signature",
-                log_txt=f"Error while trying to decode token. The token format is invalid: {str(e)}",
-                status_code=400,
+                "Could not decode or verify token due to an unexpected server error",
+                log_txt=log_message,
+                status_code=500,
             )
 
     def get_token_from_header(self, headers: Headers = None) -> str:

cornflow/shared/const.py

@@ -135,3 +135,12 @@ BASE_PERMISSION_ASSIGNATION = [
 EXTRA_PERMISSION_ASSIGNATION = [
     (VIEWER_ROLE, PUT_ACTION, "user-detail"),
 ]
+
+# migrations constants
+MIGRATIONS_DEFAULT_PATH = "./cornflow/migrations"
+
+# Costants for messages that are given back on exceptions
+AIRFLOW_NOT_REACHABLE_MSG = "Airflow is not reachable"
+DAG_PAUSED_MSG = "The dag exists but it is paused in airflow"
+AIRFLOW_ERROR_MSG = "Airflow responded with an error:"
+DATA_DOES_NOT_EXIST_MSG = "The data entity does not exist on the database"