cornflow 1.2.1__py3-none-any.whl → 1.2.3__py3-none-any.whl

cornflow/commands/views.py

@@ -1,9 +1,11 @@
-
 # Imports from external libraries
-from flask import current_app
+import sys
 from importlib import import_module
+
+from flask import current_app
 from sqlalchemy.exc import DBAPIError, IntegrityError
-import sys
+
+from cornflow.endpoints import resources, alarms_resources
 
 # Imports from internal libraries
 from cornflow.models import ViewModel
@@ -11,45 +13,21 @@ from cornflow.shared import db
 
 
 def register_views_command(external_app: str = None, verbose: bool = False):
+    """
+    Register views for the application.
+    external_app: If provided, it will register the views for the external app.
+    verbose: If True, it will print the views that are being registered.
+    """
+    resources_to_register = get_resources_to_register(external_app)
+    views_registered_urls_all_attributes = get_database_view()
+    views_to_register, views_registered_urls_all_attributes = get_views_to_register(
+        resources_to_register, views_registered_urls_all_attributes
+    )
+    views_to_delete, views_to_update = get_views_to_update_and_delete(
+        resources_to_register, views_registered_urls_all_attributes
+    )
 
-    if external_app is None:
-        from cornflow.endpoints import resources, alarms_resources
-        resources_to_register = resources
-        if current_app.config["ALARMS_ENDPOINTS"]:
-            resources_to_register = resources + alarms_resources
-    elif external_app is not None:
-        sys.path.append("./")
-        external_module = import_module(external_app)
-        resources_to_register = external_module.endpoints.resources
-    else:
-        resources_to_register = []
-        exit()
-
-    views_registered = [view.name for view in ViewModel.get_all_objects()]
-
-    views_to_register = [
-        ViewModel(
-            {
-                "name": view["endpoint"],
-                "url_rule": view["urls"],
-                "description": view["resource"].DESCRIPTION,
-            }
-        )
-        for view in resources_to_register
-        if view["endpoint"] not in views_registered
-    ]
-
-    if len(views_to_register) > 0:
-        db.session.bulk_save_objects(views_to_register)
-
-    try:
-        db.session.commit()
-    except IntegrityError as e:
-        db.session.rollback()
-        current_app.logger.error(f"Integrity error on views register: {e}")
-    except DBAPIError as e:
-        db.session.rollback()
-        current_app.logger.error(f"Unknow error on views register: {e}")
+    load_changes_to_db(views_to_delete, views_to_register, views_to_update)
 
     if "postgres" in str(db.session.get_bind()):
         db.engine.execute(
@@ -68,3 +46,155 @@ def register_views_command(external_app: str = None, verbose: bool = False):
             current_app.logger.info("No new endpoints to be registered")
 
     return True
+
+
+def load_changes_to_db(views_to_delete, views_to_register, views_to_update):
+    """
+    Load changes to the database.
+    views_to_delete: List of views to delete.
+    views_to_register: List of views to register.
+    views_to_update: List of views to update.
+    """
+    if len(views_to_register) > 0:
+        db.session.bulk_save_objects(views_to_register)
+    if len(views_to_update) > 0:
+        db.session.bulk_update_mappings(ViewModel, views_to_update)
+    # If the list views_to_delete is not empty, we will iterate over it and delete the views
+    # If it is empty, we will not delete any view since we are iterating over an empty list
+    for view_id in views_to_delete:
+        view_to_delete = ViewModel.get_one_object(idx=view_id)
+        if view_to_delete:
+            view_to_delete.delete()
+    try:
+        db.session.commit()
+    except IntegrityError as e:
+        db.session.rollback()
+        current_app.logger.error(f"Integrity error on views register: {e}")
+    except DBAPIError as e:
+        db.session.rollback()
+        current_app.logger.error(f"Unknow error on views register: {e}")
+
+
+def get_views_to_delete(
+    all_resources_to_register_views_endpoints, views_registered_urls_all_attributes
+):
+    """
+    Get the views to delete.
+    Views to delete: exist in registered views but not in resources to register.
+    """
+    return [
+        view_attrs["id"]
+        for view_name, view_attrs in views_registered_urls_all_attributes.items()
+        if view_name not in all_resources_to_register_views_endpoints
+    ]
+
+
+def get_views_to_update(
+    all_resources_to_register_views_endpoints, views_registered_urls_all_attributes
+):
+    """
+    Get the views to update.
+    Views to update: exist in both but with different url_rule or description.
+    """
+    return [
+        {
+            "id": view_attrs["id"],
+            "name": view_name,
+            "url_rule": all_resources_to_register_views_endpoints[view_name][
+                "url_rule"
+            ],
+            "description": all_resources_to_register_views_endpoints[view_name][
+                "description"
+            ],
+        }
+        for view_name, view_attrs in views_registered_urls_all_attributes.items()
+        if view_name in all_resources_to_register_views_endpoints
+        and (
+            view_attrs["url_rule"]
+            != all_resources_to_register_views_endpoints[view_name]["url_rule"]
+            or view_attrs["description"]
+            != all_resources_to_register_views_endpoints[view_name]["description"]
+        )
+    ]
+
+
+def get_views_to_update_and_delete(
+    resources_to_register, views_registered_urls_all_attributes
+):
+    """
+    Get the views to update and delete.
+    all_resources_to_register_views_endpoints: Dictionary of all resources to register views endpoints.
+    views_registered_urls_all_attributes: Dictionary of views registered urls all attributes.
+    """
+    all_resources_to_register_views_endpoints = {
+        view["endpoint"]: {
+            "url_rule": view["urls"],
+            "description": view["resource"].DESCRIPTION,
+        }
+        for view in resources_to_register
+    }
+
+    views_to_delete = get_views_to_delete(
+        all_resources_to_register_views_endpoints, views_registered_urls_all_attributes
+    )
+
+    views_to_update = get_views_to_update(
+        all_resources_to_register_views_endpoints, views_registered_urls_all_attributes
+    )
+
+    return views_to_delete, views_to_update
+
+
+def get_views_to_register(resources_to_register, views_registered_urls_all_attributes):
+    """
+    Get the views to register.
+    resources_to_register: List of resources to register.
+    """
+
+    views_to_register = [
+        ViewModel(
+            {
+                "name": view["endpoint"],
+                "url_rule": view["urls"],
+                "description": view["resource"].DESCRIPTION,
+            }
+        )
+        for view in resources_to_register
+        if view["endpoint"] not in views_registered_urls_all_attributes.keys()
+    ]
+
+    return views_to_register, views_registered_urls_all_attributes
+
+
+def get_database_view():
+    """
+    Get the database views.
+    """
+    views_registered_urls_all_attributes = {
+        view.name: {
+            "url_rule": view.url_rule,
+            "description": view.description,
+            "id": view.id,
+        }
+        for view in ViewModel.get_all_objects()
+    }
+    return views_registered_urls_all_attributes
+
+
+def get_resources_to_register(external_app):
+    if external_app is None:
+        resources_to_register = resources
+        if current_app.config["ALARMS_ENDPOINTS"]:
+            resources_to_register = resources + alarms_resources
+            current_app.logger.info(" ALARMS ENDPOINTS ENABLED ")
+    else:
+        current_app.logger.info(f" USING EXTERNAL APP: {external_app} ")
+        sys.path.append("./")
+        external_module = import_module(external_app)
+        if current_app.config["ALARMS_ENDPOINTS"]:
+            resources_to_register = (
+                external_module.endpoints.resources + resources + alarms_resources
+            )
+        else:
+            resources_to_register = external_module.endpoints.resources + resources
+    return resources_to_register

cornflow/endpoints/dag.py

@@ -2,6 +2,7 @@
 Internal endpoint for getting and posting execution data
 These are the endpoints used by airflow in its communication with cornflow
 """
+
 # Import from libraries
 from cornflow_client.constants import SOLUTION_SCHEMA
 from flask import current_app
@@ -17,7 +18,6 @@ from cornflow.schemas.execution import (
     ExecutionDagPostRequest,
     ExecutionDagRequest,
     ExecutionDetailsEndpointResponse,
-    ExecutionSchema,
 )
 
 from cornflow.shared.authentication import Auth, authenticate
@@ -85,7 +85,7 @@ class DAGDetailEndpoint(BaseMetaResource):
     @doc(description="Edit an execution", tags=["DAGs"])
     @authenticate(auth_class=Auth())
     @use_kwargs(ExecutionDagRequest, location="json")
-    def put(self, idx, **req_data):
+    def put(self, idx, **kwargs):
         """
         API method to write the results of the execution
         It requires authentication to be passed in the form of a token that has to be linked to
@@ -95,13 +95,20 @@ class DAGDetailEndpoint(BaseMetaResource):
         :return: A dictionary with a message (body) and an integer with the HTTP status code
         :rtype: Tuple(dict, integer)
         """
-        solution_schema = req_data.pop("solution_schema", "pulp")
+        execution = ExecutionModel.get_one_object(user=self.get_user(), idx=idx)
+        if execution is None:
+            err = "The execution does not exist."
+            raise ObjectDoesNotExist(
+                error=err,
+                log_txt=f"Error while user {self.get_user()} tries to edit execution {idx}."
+                + err,
+            )
+
+        solution_schema = execution.schema
 
-        # TODO: the solution_schema maybe we should get it from the created execution_id?
-        #  at least, check they have the same schema-name
         # Check data format
-        data = req_data.get("data")
-        checks = req_data.get("checks")
+        data = kwargs.get("data")
+        checks = kwargs.get("checks")
         if data is None:
             # only check format if executions_results exist
             solution_schema = None
@@ -111,24 +118,19 @@ class DAGDetailEndpoint(BaseMetaResource):
         if solution_schema is not None:
             config = current_app.config
 
-            solution_schema = DeployedDAG.get_one_schema(config, solution_schema, SOLUTION_SCHEMA)
+            solution_schema = DeployedDAG.get_one_schema(
+                config, solution_schema, SOLUTION_SCHEMA
+            )
             solution_errors = json_schema_validate_as_string(solution_schema, data)
 
             if solution_errors:
                 raise InvalidData(
                     payload=dict(jsonschema_errors=solution_errors),
                     log_txt=f"Error while user {self.get_user()} tries to edit execution {idx}. "
-                            f"Solution data do not match the jsonschema.",
+                    f"Solution data do not match the jsonschema.",
                 )
-        execution = ExecutionModel.get_one_object(user=self.get_user(), idx=idx)
-        if execution is None:
-            err = "The execution does not exist."
-            raise ObjectDoesNotExist(
-                error=err,
-                log_txt=f"Error while user {self.get_user()} tries to edit execution {idx}."
-                + err,
-            )
-        state = req_data.get("state", EXEC_STATE_CORRECT)
+
+        state = kwargs.get("state", EXEC_STATE_CORRECT)
         new_data = dict(
             state=state,
             state_message=EXECUTION_STATE_MESSAGE_DICT[state],
@@ -141,10 +143,9 @@ class DAGDetailEndpoint(BaseMetaResource):
             new_data["data"] = data
         if checks is not None:
             new_data["checks"] = checks
-        req_data.update(new_data)
-        execution.update(req_data)
-        # TODO: is this save necessary?
-        execution.save()
+        kwargs.update(new_data)
+        execution.update(kwargs)
+
         current_app.logger.info(f"User {self.get_user()} edits execution {idx}")
         return {"message": "results successfully saved"}, 200
 
@@ -207,7 +208,6 @@ class DAGEndpointManual(BaseMetaResource):
 
         # Check data format
         data = kwargs.get("data")
-        # TODO: create a function to validate and replace data/ execution_results
         if data is None:
             # only check format if executions_results exist
             solution_schema = None
@@ -215,14 +215,16 @@ class DAGEndpointManual(BaseMetaResource):
             solution_schema = "solve_model_dag"
         if solution_schema is not None:
             config = current_app.config
-            solution_schema = DeployedDAG.get_one_schema(config, solution_schema, SOLUTION_SCHEMA)
+            solution_schema = DeployedDAG.get_one_schema(
+                config, solution_schema, SOLUTION_SCHEMA
+            )
             solution_errors = json_schema_validate_as_string(solution_schema, data)
 
             if solution_errors:
                 raise InvalidData(
                     payload=dict(jsonschema_errors=solution_errors),
                     log_txt=f"Error while user {self.get_user()} tries to manually create an execution. "
-                            f"Solution data do not match the jsonschema.",
+                    f"Solution data do not match the jsonschema.",
                 )
 
         kwargs_copy = dict(kwargs)