cornflow 1.1.1a1__py3-none-any.whl → 1.1.4__py3-none-any.whl

cornflow/endpoints/reports.py

@@ -1,283 +0,0 @@
-"""
-External endpoints to manage the reports: create new ones, list all of them, get one in particular
-These endpoints have different access url, but manage the same data entities
-"""
-import os
-
-from flask import current_app, request, send_from_directory
-from flask_apispec import marshal_with, use_kwargs, doc
-from werkzeug.utils import secure_filename
-import uuid
-
-from cornflow.endpoints.meta_resource import BaseMetaResource
-from cornflow.models import ExecutionModel, ReportModel
-from cornflow.schemas.reports import (
-    ReportSchema,
-    ReportEditRequest,
-    QueryFiltersReports,
-    ReportRequest,
-)
-from cornflow.shared.authentication import Auth, authenticate
-from cornflow.shared.const import SERVICE_ROLE
-from cornflow.shared.exceptions import (
-    FileError,
-    ObjectDoesNotExist,
-    NoPermission,
-)
-
-
-class ReportEndpoint(BaseMetaResource):
-    """
-    Endpoint used to create a new report or get all the reports and their information back
-    """
-
-    ROLES_WITH_ACCESS = [SERVICE_ROLE]
-
-    def __init__(self):
-        super().__init__()
-        self.model = ReportModel
-        self.data_model = ReportModel
-        self.foreign_data = {"execution_id": ExecutionModel}
-
-    @doc(description="Get all reports", tags=["Reports"])
-    @authenticate(auth_class=Auth())
-    @marshal_with(ReportSchema(many=True))
-    @use_kwargs(QueryFiltersReports, location="query")
-    def get(self, **kwargs):
-        """
-        API method to get all the reports created by the user and its related info
-        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
-
-        :return: A dictionary with a message (error if authentication failed or a list with all the reports
-          created by the authenticated user) and a integer with the HTTP status code
-        :rtype: Tuple(dict, integer)
-        """
-        reports = self.get_list(user=self.get_user(), **kwargs)
-        current_app.logger.info(f"User {self.get_user()} gets list of reports")
-        return reports
-
-    @doc(description="Create a report", tags=["Reports"])
-    @authenticate(auth_class=Auth())
-    @use_kwargs(ReportRequest, location="form")
-    @marshal_with(ReportSchema)
-    def post(self, **kwargs):
-        """
-        API method to create a new report linked to an existing execution
-        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
-
-        :return: A dictionary with a message (error if authentication failed, error if data is not validated or
-          the reference_id for the newly created report if successful) and a integer with the HTTP status code
-        :rtype: Tuple(dict, integer)
-        """
-
-        execution = ExecutionModel.get_one_object(idx=kwargs["execution_id"])
-
-        if execution is None:
-            raise ObjectDoesNotExist("The execution does not exist")
-        if "file" not in request.files:
-            # we're creating an empty report.
-            # which is possible
-            report = ReportModel(get_report_info(kwargs, execution, None))
-
-            report.save()
-            return report, 201
-
-        file = request.files["file"]
-        report_name = new_file_name(file)
-
-        report = ReportModel(get_report_info(kwargs, execution, report_name))
-
-        report.save()
-
-        # We try to save the file, if an error is raised then we delete the record on the database
-        try:
-            write_file(file, execution.id, report_name)
-            return report, 201
-
-        except Exception as error:
-            report.delete()
-            current_app.logger.error(error)
-            raise FileError(error=str(error))
-
-
-class ReportDetailsEndpointBase(BaseMetaResource):
-    """
-    Endpoint used to get the information of a certain report. But not the data!
-    """
-
-    def __init__(self):
-        super().__init__()
-        self.data_model = ReportModel
-        self.foreign_data = {"execution_id": ExecutionModel}
-
-
-class ReportDetailsEditEndpoint(ReportDetailsEndpointBase):
-
-    ROLES_WITH_ACCESS = [SERVICE_ROLE]
-
-    @doc(description="Edit a report", tags=["Reports"], inherit=False)
-    @authenticate(auth_class=Auth())
-    @use_kwargs(ReportEditRequest, location="form")
-    def put(self, idx, **data):
-        """
-        Edit an existing report
-
-        :param string idx: ID of the report.
-        :return: A dictionary with a message (error if authentication failed, or the report does not exist or
-          a message) and an integer with the HTTP status code.
-        :rtype: Tuple(dict, integer)
-        """
-        # TODO: forbid non-service users from running put
-        current_app.logger.info(f"User {self.get_user()} edits report {idx}")
-
-        report = self.get_detail(idx=idx)
-
-        if "file" not in request.files:
-            # we're creating an empty report.
-            # which is possible
-            report.update(data)
-            report.save()
-            return {"message": "Updated correctly"}, 200
-
-        # there's two cases,
-        # (1) the report already has a file
-        # (2) the report doesn't yet have a file
-        file = request.files["file"]
-        report_name = new_file_name(file)
-        old_name = report.file_url
-        # we update the report with the new content, including the new name
-        report.update(dict(**data, file_url=report_name))
-
-        # We try to save the file, if an error is raised then we delete the record on the database
-        try:
-            write_file(file, report.execution_id, report_name)
-            report.save()
-
-        except Exception as error:
-            # we do not save the report
-            current_app.logger.error(error)
-            raise FileError(error=str(error))
-
-        # if it saves correctly, we delete the old file, if exists
-        # if unsuccessful, we still return 201 but log the error
-        if old_name is not None:
-            try:
-                os.remove(get_report_path(report))
-            except OSError as error:
-                current_app.logger.error(error)
-        return {"message": "Updated correctly"}, 200
-
-
-class ReportDetailsEndpoint(ReportDetailsEndpointBase):
-    @doc(description="Get details of a report", tags=["Reports"], inherit=False)
-    @authenticate(auth_class=Auth())
-    @marshal_with(ReportSchema)
-    @BaseMetaResource.get_data_or_404
-    def get(self, idx):
-        """
-        API method to get a report created by the user and its related info.
-        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.
-
-        :param str idx: ID of the report.
-        :return: A dictionary with a message (error if authentication failed, or the report does not exist or
-          the data of the report) and an integer with the HTTP status code.
-        :rtype: Tuple(dict, integer)
-        """
-        # TODO: are we able to download the name in the database and not as part of the file?
-        current_app.logger.info(f"User {self.get_user()} gets details of report {idx}")
-        report = self.get_detail(user=self.get_user(), idx=idx)
-
-        if report is None:
-            raise ObjectDoesNotExist
-
-        # if there's no file, we do not return it:
-        if report.file_url is None:
-            return report, 200
-
-        my_dir = get_report_dir(report.execution_id)
-        response = send_from_directory(my_dir, report.file_url)
-        response.headers["File-Description"] = report.description
-        response.headers["File-Name"] = report.file_url
-        return response
-
-    @doc(description="Delete a report", tags=["Reports"], inherit=False)
-    @authenticate(auth_class=Auth())
-    def delete(self, idx):
-        """
-        API method to delete a report created by the user and its related info.
-        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.
-
-        :param string idx: ID of the report.
-        :return: A dictionary with a message (error if authentication failed, or the report does not exist or
-          a message) and an integer with the HTTP status code.
-        :rtype: Tuple(dict, integer)
-        """
-
-        # get report objet
-        report = self.get_detail(user_id=self.get_user_id(), idx=idx)
-
-        if report is None:
-            raise ObjectDoesNotExist
-
-        # delete file
-        os.remove(get_report_path(report))
-
-        return self.delete_detail(user_id=self.get_user_id(), idx=idx)
-
-
-def get_report_dir(execution_id):
-    return f"{current_app.config['UPLOAD_FOLDER']}/{execution_id}"
-
-
-def get_report_path(report):
-    try:
-        return f"{get_report_dir(report['execution_id'])}/{report['file_url']}"
-    except:
-        return f"{get_report_dir(report.execution_id)}/{report.file_url}"
-
-
-def new_file_name(file):
-
-    filename = secure_filename(file.filename)
-    filename_extension = filename.split(".")[-1]
-
-    if filename_extension not in current_app.config["ALLOWED_EXTENSIONS"]:
-        return {
-            "message": f"Invalid file extension. "
-            f"Valid extensions are: {current_app.config['ALLOWED_EXTENSIONS']}"
-        }, 400
-
-    report_name = f"{uuid.uuid4().hex}.{filename_extension}"
-
-    return report_name
-
-
-def write_file(file, execution_id, file_name):
-    my_directory = get_report_dir(execution_id)
-
-    # we create a directory for the execution
-    if not os.path.exists(my_directory):
-        current_app.logger.info(f"Creating directory {my_directory}")
-        os.mkdir(my_directory)
-
-    save_path = os.path.normpath(os.path.join(my_directory, file_name))
-
-    if "static" not in save_path or ".." in save_path:
-        raise NoPermission("Invalid file name")
-    file.save(save_path)
-
-
-def get_report_info(data, execution, file_url=None):
-    return {
-        "name": data["name"],
-        "file_url": file_url,
-        "execution_id": execution.id,
-        "user_id": execution.user_id,
-        "description": data.get("description", ""),
-        "state": data.get("state"),
-        "state_message": data.get("state_message"),
-    }

cornflow/migrations/versions/83164be03c23_.py

@@ -1,40 +0,0 @@
-"""empty message
-
-Revision ID: 83164be03c23
-Revises: 96f00d0961d1
-Create Date: 2024-07-23 13:18:47.748324
-
-"""
-from alembic import op
-import sqlalchemy as sa
-
-
-# revision identifiers, used by Alembic.
-revision = '83164be03c23'
-down_revision = '96f00d0961d1'
-branch_labels = None
-depends_on = None
-
-
-def upgrade():
-    # ### commands auto generated by Alembic - please adjust! ###
-    with op.batch_alter_table('reports', schema=None) as batch_op:
-        batch_op.add_column(sa.Column('state', sa.SmallInteger(), nullable=True))
-        batch_op.add_column(sa.Column('state_message', sa.TEXT(), nullable=True))
-        batch_op.alter_column('file_url',
-               existing_type=sa.VARCHAR(length=256),
-               nullable=True)
-
-    # ### end Alembic commands ###
-
-
-def downgrade():
-    # ### commands auto generated by Alembic - please adjust! ###
-    with op.batch_alter_table('reports', schema=None) as batch_op:
-        batch_op.alter_column('file_url',
-               existing_type=sa.VARCHAR(length=256),
-               nullable=False)
-        batch_op.drop_column('state_message')
-        batch_op.drop_column('state')
-
-    # ### end Alembic commands ###

cornflow/migrations/versions/96f00d0961d1_reports_table.py

@@ -1,50 +0,0 @@
-"""
-Adds reports table to database
-
-Revision ID: 96f00d0961d1
-Revises: 991b98e24225
-Create Date: 2024-06-12 18:47:06.366487
-
-"""
-
-from alembic import op
-import sqlalchemy as sa
-
-
-# revision identifiers, used by Alembic.
-revision = "96f00d0961d1"
-down_revision = "991b98e24225"
-branch_labels = None
-depends_on = None
-
-
-def upgrade():
-    # ### commands auto generated by Alembic - please adjust! ###
-    op.create_table(
-        "reports",
-        sa.Column("created_at", sa.DateTime(), nullable=False),
-        sa.Column("updated_at", sa.DateTime(), nullable=False),
-        sa.Column("deleted_at", sa.DateTime(), nullable=True),
-        sa.Column("id", sa.Integer(), autoincrement=True, nullable=False),
-        sa.Column("execution_id", sa.String(length=256), nullable=False),
-        sa.Column("name", sa.String(length=256), nullable=False),
-        sa.Column("description", sa.TEXT(), nullable=True),
-        sa.Column("file_url", sa.String(length=256), nullable=False),
-        sa.Column("user_id", sa.Integer(), nullable=False),
-        sa.ForeignKeyConstraint(
-            ["execution_id"],
-            ["executions.id"],
-        ),
-        sa.ForeignKeyConstraint(
-            ["user_id"],
-            ["users.id"],
-        ),
-        sa.PrimaryKeyConstraint("id"),
-    )
-    # ### end Alembic commands ###
-
-
-def downgrade():
-    # ### commands auto generated by Alembic - please adjust! ###
-    op.drop_table("reports")
-    # ### end Alembic commands ###

cornflow/models/reports.py

@@ -1,119 +0,0 @@
-"""
-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/reports.py

@@ -1,48 +0,0 @@
-# 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()