cornflow 1.1.0a2__py3-none-any.whl → 1.1.1a1__py3-none-any.whl

cornflow/models/reports.py

@@ -0,0 +1,119 @@
+"""
+Model for the reports
+"""
+
+# Import from libraries
+from sqlalchemy.dialects.postgresql import TEXT
+from sqlalchemy.ext.declarative import declared_attr
+
+# Imports from internal modules
+from cornflow.models.base_data_model import TraceAttributesModel
+from cornflow.shared import db
+from cornflow.shared.const import REPORT_STATE, REPORT_STATE_MSG
+
+
+class ReportModel(TraceAttributesModel):
+    """
+    Model class for the Reports.
+    It inherits from :class:`TraceAttributesModel<cornflow.models.base_data_model.TraceAttributesModel>` to have the trace fields and user field.
+
+    - **id**: int, the report id, primary key for the reports.
+    - **execution_id**: str, the foreign key for the execution (:class:`ExecutionModel`). It links the report to its
+      parent execution.
+    - **file_url**: str, the link with the actual report. It should be a valid url to a cloud storage bucket or a file.
+    - **name**: str, the name of the report given by the user.
+    - **description**: str, the description of the report given by the user. It is optional.
+    - **user_id**: int, the foreign key for the user (:class:`UserModel`). It links the report to its owner.
+    - **created_at**: datetime, the datetime when the report was created (in UTC).
+      This datetime is generated automatically, the user does not need to provide it.
+    - **updated_at**: datetime, the datetime when the report was last updated (in UTC).
+      This datetime is generated automatically, the user does not need to provide it.
+    - **deleted_at**: datetime, the datetime when the report was deleted (in UTC). Even though it is deleted,
+      actually, it is not deleted from the database, in order to have a command that cleans up deleted data
+      after a certain time of its deletion.
+      This datetime is generated automatically, the user does not need to provide it.
+
+    """
+
+    # Table name in the database
+    __tablename__ = "reports"
+
+    # Model fields
+    id = db.Column(db.Integer, primary_key=True, autoincrement=True)
+    execution_id = db.Column(
+        db.String(256), db.ForeignKey("executions.id"), nullable=False
+    )
+    name = db.Column(db.String(256), nullable=False)
+    description = db.Column(TEXT, nullable=True)
+    file_url = db.Column(db.String(256), nullable=True)
+    state = db.Column(db.SmallInteger, default=REPORT_STATE.CORRECT)
+    state_message = db.Column(TEXT, default=REPORT_STATE_MSG[REPORT_STATE.CORRECT])
+
+    @declared_attr
+    def user_id(self):
+        """
+        The foreign key for the user (:class:`UserModel<cornflow.models.UserModel>`).
+        """
+        return db.Column(db.Integer, db.ForeignKey("users.id"), nullable=False)
+
+    @declared_attr
+    def user(self):
+        return db.relationship("UserModel")
+
+    def __init__(self, data: dict):
+        super().__init__()
+        self.user_id = data.get("user_id")
+        self.execution_id = data.get("execution_id")
+        self.name = data.get("name")
+        self.description = data.get("description")
+        self.file_url = data.get("file_url")
+        self.state = data.get("state")
+        if self.state is None:
+            if self.file_url is None:
+                self.state = REPORT_STATE.UNKNOWN
+            else:
+                self.state = REPORT_STATE.CORRECT
+        self.state_message = data.get("state_message")
+        if self.state_message is None:
+            self.state_message = REPORT_STATE_MSG.get(self.state)
+
+    def update(self, data):
+        """
+        Method used to update a report from the database
+
+        :param dict data: the data of the object
+        :return: None
+        :rtype: None
+        """
+        # we try to keep the state_message synced, by default
+        if "state" in data and "state_message" not in data:
+            data["state_message"] = REPORT_STATE_MSG[data["state"]]
+        super().update(data)
+
+    def update_link(self, file_url: str):
+        """
+        Method to update the report link
+
+        :param str file_url: new URL for the report
+        :return: nothing
+        """
+        self.file_url = file_url
+        super().update({})
+
+    def __repr__(self):
+        """
+        Method to represent the class :class:`ReportModel`
+
+        :return: The representation of the :class:`ReportModel`
+        :rtype: str
+        """
+        return f"<Report {self.id}>"
+
+    def __str__(self):
+        """
+        Method to print a string representation of the :class:`ReportModel`
+
+        :return: The string for the :class:`ReportModel`
+        :rtype: str
+        """
+        return self.__repr__()

cornflow/schemas/execution.py

@@ -5,6 +5,7 @@ from marshmallow import fields, Schema, validate
 from cornflow.shared.const import MIN_EXECUTION_STATUS_CODE, MAX_EXECUTION_STATUS_CODE
 from .common import QueryFilters, BaseDataEndpointResponse
 from .solution_log import LogSchema, BasicLogSchema
+from .reports import ReportSchemaBase
 
 
 class QueryFiltersExecution(QueryFilters):
@@ -30,6 +31,7 @@ class ConfigSchema(Schema):
     threads = fields.Int(required=False)
     logPath = fields.Str(required=False)
     MIPGap = fields.Float(required=False)
+    report = fields.Raw(required=False)
 
 
 class ConfigSchemaResponse(ConfigSchema):
@@ -95,6 +97,7 @@ class ExecutionDagPostRequest(ExecutionRequest, ExecutionDagRequest):
 
 
 class ExecutionDetailsEndpointResponse(BaseDataEndpointResponse):
+    reports = fields.Nested(ReportSchemaBase, many=True)
     config = fields.Nested(ConfigSchemaResponse)
     instance_id = fields.Str()
     state = fields.Int()

cornflow/schemas/reports.py

@@ -0,0 +1,48 @@
+# Imports from libraries
+from marshmallow import fields, Schema, INCLUDE
+
+# Imports from internal modules
+from .common import BaseQueryFilters
+
+
+class QueryFiltersReports(BaseQueryFilters):
+    execution_id = fields.Str(required=False)
+
+
+class ReportSchemaBase(Schema):
+    id = fields.Int(dump_only=True)
+    file_url = fields.Str(required=False)
+    name = fields.Str(required=True)
+    state = fields.Int()
+
+
+class ReportSchema(ReportSchemaBase):
+    user_id = fields.Int(required=False, load_only=True)
+    execution_id = fields.Str(required=True)
+    description = fields.Str()
+    state_message = fields.Str()
+    created_at = fields.DateTime(dump_only=True)
+    updated_at = fields.DateTime(dump_only=True)
+    deleted_at = fields.DateTime(dump_only=True)
+
+
+class ReportEditRequest(Schema):
+    class META:
+        unknown = INCLUDE
+
+    name = fields.Str()
+    description = fields.Str()
+    file_url = fields.Str(required=False)
+    state = fields.Int()
+    state_message = fields.Str()
+
+
+class ReportRequest(Schema):
+    class META:
+        unknown = INCLUDE
+
+    name = fields.Str(required=True)
+    description = fields.Str(required=False)
+    execution_id = fields.Str(required=True)
+    state = fields.Int()
+    state_message = fields.Str()

cornflow/shared/const.py

@@ -43,6 +43,25 @@ AIRFLOW_TO_STATE_MAP = dict(
     queued=EXEC_STATE_QUEUED,
 )
 
+# Reports codes
+
+
+class REPORT_STATE:
+    RUNNING = 0
+    CORRECT = 1
+    ERROR = -1
+    UNKNOWN = -5
+    ERROR_NO_QUARTO = -10
+
+
+REPORT_STATE_MSG = {
+    REPORT_STATE.RUNNING: "The report is currently running.",
+    REPORT_STATE.CORRECT: "The report has been solved correctly.",
+    REPORT_STATE.ERROR: "The report has an error.",
+    REPORT_STATE.UNKNOWN: "The report has an unknown error.",
+    REPORT_STATE.ERROR_NO_QUARTO: "The report failed because Quarto was not found.",
+}
+
 # These codes and names are inherited from flask app builder in order to have the same names and values
 # as this library that is the base of airflow
 AUTH_DB = 1
@@ -122,4 +141,6 @@ BASE_PERMISSION_ASSIGNATION = [
 
 EXTRA_PERMISSION_ASSIGNATION = [
     (VIEWER_ROLE, PUT_ACTION, "user-detail"),
+    (VIEWER_ROLE, GET_ACTION, "report"),
+    (PLANNER_ROLE, GET_ACTION, "report"),
 ]

cornflow/shared/exceptions.py

@@ -21,7 +21,10 @@ class InvalidUsage(Exception):
     def __init__(self, error=None, status_code=None, payload=None, log_txt=None):
         Exception.__init__(self, error)
         if error is not None:
-            self.error = error
+            if isinstance(error, Exception):
+                self.error = str(error)
+            else:
+                self.error = error
         if status_code is not None:
             self.status_code = status_code
         self.payload = payload
@@ -122,10 +125,21 @@ class ConfigurationError(InvalidUsage):
     error = "No authentication method configured on the server"
 
 
+class FileError(InvalidUsage):
+    """
+    Exception used when there is an error regarding the upload of a file to the server
+    """
+
+    status_code = 400
+    error = "Error uploading the file"
+
+
 INTERNAL_SERVER_ERROR_MESSAGE = "500 Internal Server Error"
-INTERNAL_SERVER_ERROR_MESSAGE_DETAIL = "The server encountered an internal error and was unable " \
-                                       "to complete your request. Either the server is overloaded or " \
-                                       "there is an error in the application."
+INTERNAL_SERVER_ERROR_MESSAGE_DETAIL = (
+    "The server encountered an internal error and was unable "
+    "to complete your request. Either the server is overloaded or "
+    "there is an error in the application."
+)
 
 
 def initialize_errorhandlers(app):
@@ -187,10 +201,7 @@ def initialize_errorhandlers(app):
             status_code = error.code or status_code
             error_msg = f"{status_code} {error.name or INTERNAL_SERVER_ERROR_MESSAGE}"
             error_str = f"{error_msg}. {str(error.description or '') or INTERNAL_SERVER_ERROR_MESSAGE_DETAIL}"
-            response_dict = {
-                "message": error_msg,
-                "error": error_str
-            }
+            response_dict = {"message": error_msg, "error": error_str}
             response = jsonify(response_dict)
 
         elif app.config["ENV"] == "production":
@@ -202,7 +213,7 @@ def initialize_errorhandlers(app):
 
             response_dict = {
                 "message": INTERNAL_SERVER_ERROR_MESSAGE,
-                "error": INTERNAL_SERVER_ERROR_MESSAGE_DETAIL
+                "error": INTERNAL_SERVER_ERROR_MESSAGE_DETAIL,
             }
             response = jsonify(response_dict)
         else: