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

cornflow/cli/tools/models_tools.py

@@ -29,40 +29,47 @@ class ModelGenerator:
         self.table_name = table_name
         self.app_name = app_name
 
+    def _format_description(self, description_obj, prefix=""):
+        """Formats a description object (str, dict, or None) into a string."""
+        if description_obj is None or description_obj == "":
+            return ""
+        if isinstance(description_obj, dict):
+            # Assuming 'en' key exists if it's a dict
+            desc_text = description_obj.get("en", "")
+        else:
+            desc_text = str(description_obj)
+        return f"{prefix}{desc_text}\n\n" if desc_text else ""
+
+    def _format_field_description(self, key, val):
+        """Formats the description line for a single model field."""
+        desc_text = self._format_description(val.get("description")).strip()
+        primary_key_text = " The primary key." if key == "id" else ""
+        return f'    - **{key}**: {val["type"]}.{primary_key_text} {desc_text}\n'
+
     def generate_model_description(self):
-        res = '    """\n'
-        res += f"    Model class for table {self.table_name} of the application {self.app_name}\n"
-        res += f'    It inherits from :class:`{" and :class:".join(self.parents_class)}`\n\n'
-        app_description = self.schema.get("description")
-        if app_description is not None and app_description != "":
-            if isinstance(app_description, dict):
-                app_description = app_description["en"]
-            res += f"    Description of the app: {app_description}\n\n"
-        table_description = self.schema["properties"][self.table_name].get(
-            "description"
+        """Generates the model's docstring description."""
+        lines = [
+            '    """\n',
+            f"    Model class for table {self.table_name} of the application {self.app_name}\n",
+            f'    It inherits from :class:`{" and :class:".join(self.parents_class)}`\n\n',
+        ]
+
+        app_desc = self.schema.get("description")
+        lines.append(self._format_description(app_desc, "Description of the app: "))
+
+        table_desc = self.schema["properties"][self.table_name].get("description")
+        lines.append(self._format_description(table_desc, "Description of the table: "))
+
+        lines.append(
+            f"    The :class:`{self.class_name}` has the following fields: \n\n"
         )
-        if table_description is not None and table_description != "":
-            if isinstance(table_description, dict):
-                table_description = table_description["en"]
-            res += f"    Description of the table: {table_description}\n\n"
-        res += f"    The :class:`{self.class_name}` has the following fields: \n\n"
-        for key, val in self.schema["properties"][self.table_name]["items"][
-            "properties"
-        ].items():
-            if key != "id":
-                if isinstance(val.get("description"), dict):
-                    res += (
-                        f'    - **{key}**: {val["type"]}. {val["description"]["en"]}\n'
-                    )
-                else:
-                    res += f'    - **{key}**: {val["type"]}. {val.get("description") or ""}\n'
-            else:
-                if isinstance(val.get("description"), dict):
-                    res += f'    - **{key}**: {val["type"]}. The primary key. {val["description"]["en"]}\n'
-                else:
-                    res += f'    - **{key}**: {val["type"]}. The primary key. {val.get("description") or ""}\n'
-        res += '    """\n'
-        return res
+
+        fields = self.schema["properties"][self.table_name]["items"]["properties"]
+        for key, val in fields.items():
+            lines.append(self._format_field_description(key, val))
+
+        lines.append('    """\n')
+        return "".join(lines)
 
     def generate_table_name(self):
         res = "    # Table name in the database\n"
@@ -72,36 +79,51 @@ class ModelGenerator:
             res += f'    __tablename__ = "{self.app_name}_{self.table_name}"\n'
         return res
 
+    def _generate_field_definition(self, key, val, schema_table):
+        """Generates the db.Column definition string for a single field."""
+        parts = [f"    {key} = db.Column("]
+        ty, nullable = get_type(val)
+        parts.append(JSON_TYPES_TO_SQLALCHEMY[ty])
+
+        # Handle foreign key
+        if val.get("foreign_key"):
+            foreign_table, foreign_prop = val["foreign_key"].split(".")
+            if self.app_name is not None:
+                foreign_table = self.app_name + "_" + foreign_table
+            parts.append(f', db.ForeignKey("{foreign_table}.{foreign_prop}")')
+
+        # Handle nullability
+        is_required = key in schema_table.get("required", [])
+        if is_required and not nullable:
+            parts.append(", nullable=False")
+        else:
+            parts.append(", nullable=True")
+
+        # Handle primary key for 'id' specifically
+        if key == "id":
+            parts.append(", primary_key=True")
+
+        parts.append(")")
+        return "".join(parts) + "\n"
+
     def generate_model_fields(self):
+        """Generates the SQLAlchemy model field definitions."""
         schema_table = self.schema["properties"][self.table_name]["items"]
+        properties = schema_table.get("properties", {})
 
-        def has_id(schema):
-            for prop in schema:
-                if prop == "id":
-                    return True
-            return False
-
-        res = "    # Model fields\n"
-        if not has_id(schema_table["properties"]):
-            res += f"    id = db.Column(db.Integer, primary_key=True, autoincrement=True)\n"
-        for key, val in schema_table["properties"].items():
-            res += f"    {key} = db.Column("
-            ty, nullable = get_type(val)
-            res += JSON_TYPES_TO_SQLALCHEMY[ty]
-            if val.get("foreign_key"):
-                foreign_table, foreign_prop = val["foreign_key"].split(".")
-                if self.app_name is not None:
-                    foreign_table = self.app_name + "_" + foreign_table
-
-                res += f', db.ForeignKey("{foreign_table}.{foreign_prop}")'
-            if key in schema_table["required"] and not nullable:
-                res += ", nullable=False"
-            else:
-                res += ", nullable=True"
-            if key == "id":
-                res += ", primary_key=True"
-            res += ")\n"
-        return res
+        lines = ["    # Model fields\n"]
+
+        # Add default ID if not present in schema
+        if "id" not in properties:
+            lines.append(
+                "    id = db.Column(db.Integer, primary_key=True, autoincrement=True)\n"
+            )
+
+        # Generate definition for each field in the schema
+        for key, val in properties.items():
+            lines.append(self._generate_field_definition(key, val, schema_table))
+
+        return "".join(lines)
 
     def generate_model_init(self):
         keys = self.schema["properties"][self.table_name]["items"]["properties"].keys()
@@ -130,5 +152,10 @@ class ModelGenerator:
         res += SP8 + f":return: The representation of the :class:`{self.class_name}`\n"
         res += SP8 + ":rtype: str\n"
         res += SP8 + '"""\n'
-        res += SP8 + f"return self.__repr__()"
+        res += SP8 + "return self.__repr__()"
+        return res
+
+    def generate_imports(self):
+        # Imports from libraries
+        res = model_shared_imports
         return res

cornflow/cli/tools/schema_generator.py

@@ -61,6 +61,8 @@ class SchemaGenerator:
         for file_path, file_name in files:
             with open(file_path, "r") as fd:
                 text = fd.read()
+            # SonarQube ReDoS FP: Pattern uses .+ but operates on Python source code
+            # within a developer CLI tool, making ReDoS risk negligible.
             parents = re.findall(r"class (.+)\((.+)\):", text)
             for cl, parent in parents:
                 self.parents[cl] = parent.replace(" ", "")
@@ -72,77 +74,169 @@ class SchemaGenerator:
 
         sys.modules["mockedpackage"] = MagicMock()
 
-    def parse(self, files):
+    def _load_module(self, file_path, file_name):
+        """Loads a Python module dynamically from a file path."""
+        try:
+            spec = importlib.util.spec_from_file_location(file_name, file_path)
+            if spec is None or spec.loader is None:
+                click.echo(f"Warning: Could not create spec for {file_path}")
+                return None
+            mod = importlib.util.module_from_spec(spec)
+            spec.loader.exec_module(mod)
+            return mod
+        except Exception as e:
+            click.echo(f"Error loading module {file_name}: {e}")
+            return None
+
+    def _process_module(self, mod):
+        """Processes a loaded module to find and parse model classes."""
+        if mod is None:
+            return
+
+        models_in_mod = SuperDict(mod.__dict__).kfilter(lambda k: k in self.parents)
+        for model_name, model_class in models_in_mod.items():
+            processed_data = self._process_model(model_name, model_class, mod)
+            if processed_data:
+                table_name, props = processed_data
+                self._process_properties(table_name, props)
+
+    def _get_model_properties(self, model_name, model_class, mod):
+        """Extracts properties (props) from a model class, handling mocks and abstract classes."""
+        if isinstance(model_class, MagicMock):
+            # Handle mocked models (often from relative imports)
+            if not isinstance(mod.__dict__[model_name]._mock_return_value, dict):
+                return None
+            return mod.__dict__[model_name]._mock_return_value
+        elif getattr(model_class, "__abstract__", False):
+            # Handle abstract base models
+            self.parents[model_name] = None  # Mark as a base parent
+            return model_class.__dict__
+        elif hasattr(model_class, "__table__"):
+            # Handle concrete SQLAlchemy models
+            self.parents[model_name] = None  # Mark as a base parent
+            tmp = model_class.__dict__
+            props = {"__tablename__": tmp.get("__tablename__")}
+            # Extract columns directly from the __table__ object
+            for col in model_class.__table__.columns:
+                # Use col.key instead of internal __dict__['key']
+                # Use col instead of iterating through proxy_set, as col represents the Column object
+                props[col.key] = col
+            return props
+        else:
+            # Not a recognized model type
+            return None
+
+    def _process_model(self, model_name, model_class, mod):
+        """Processes a single model class to get its properties and initialize schema."""
+        props = self._get_model_properties(model_name, model_class, mod)
+        if props is None:
+            return None
+
+        table_name = props.get("__tablename__", model_name)
+
+        # Initialize schema structure for this table
+        self.data[table_name] = SuperDict(
+            type="array", items=dict(properties=dict(), required=[])
+        )
+
+        # Mark for removal if it's a base class without a table and we want to remove bases
+        if not props.get("__tablename__") and not self.leave_bases:
+            self.data[table_name]["remove"] = True
+
+        # Update model/table name mappings
+        self.model_table[model_name] = table_name
+        self.table_model[table_name] = model_name
+
+        return table_name, props
+
+    def _process_properties(self, table_name, props):
+        """Iterates through model properties and processes columns."""
         forget_keys = ["created_at", "updated_at", "deleted_at"]
         db = SQLAlchemy()
+
+        for key, val in props.items():
+            if key in forget_keys or key.startswith("_"):
+                continue
+            # Check if it's a SQLAlchemy Column or a proxied Column from __table__
+            if isinstance(val, (db.Column, Column)):
+                self._process_column(table_name, key, val)
+            # Potentially handle other property types here if needed
+
+    def _process_column(self, table_name, key, column_obj):
+        """Processes a single db.Column object to update the JSON schema."""
+        db = SQLAlchemy()
+        type_converter = {
+            db.String: "string",
+            TEXT: "string",
+            JSON: "object",
+            Integer: "integer",
+            db.Integer: "integer",
+            db.Boolean: "boolean",
+            db.SmallInteger: "integer",
+            db.Float: "number",
+            # Represent dates as strings in JSON schema (format: date)
+            db.Date: "string",
+            # Represent datetimes as strings (format: date-time)
+            db.DateTime: "string",
+            # Represent time as string (format: time)
+            db.Time: "string",
+            # Consider how to represent LargeBinary - maybe string with format 'binary'?
+        }
+        type_col = "null"
+        # Access the column type directly via column_obj.type
+        column_type = column_obj.type
+        for possible_type_class, repr_type in type_converter.items():
+            # Use isinstance for robust type checking
+            if isinstance(column_type, possible_type_class):
+                type_col = repr_type
+                break  # Found the type
+
+        if type_col == "null":
+            click.echo(
+                f"Warning: Unknown column type '{column_type}' for {table_name}.{key}"
+            )
+            type_col = "string"
+
+        self.data[table_name]["items"]["properties"][key] = SuperDict(type=type_col)
+
+        # Add format for date/time types
+        if isinstance(column_type, db.Date):
+            self.data[table_name]["items"]["properties"][key]["format"] = "date"
+        elif isinstance(column_type, db.DateTime):
+            self.data[table_name]["items"]["properties"][key]["format"] = "date-time"
+        elif isinstance(column_type, db.Time):
+            self.data[table_name]["items"]["properties"][key]["format"] = "time"
+
+        # Handle foreign keys using column_obj.foreign_keys
+        if column_obj.foreign_keys:
+            # Assuming only one foreign key per column for simplicity here
+            fk = next(iter(column_obj.foreign_keys))
+            self.data[table_name]["items"]["properties"][key][
+                "foreign_key"
+            ] = fk.target_fullname
+
+        # Handle nullability using column_obj.nullable
+        if not column_obj.nullable:
+            # Ensure 'required' list exists before appending
+            if "required" not in self.data[table_name]["items"]:
+                self.data[table_name]["items"]["required"] = []
+            if key not in self.data[table_name]["items"]["required"]:
+                self.data[table_name]["items"]["required"].append(key)
+
+    def parse(self, files):
+        SQLAlchemy()
         try:
             for file_path, file_name in files:
-                spec = importlib.util.spec_from_file_location(file_name, file_path)
-                mod = importlib.util.module_from_spec(spec)
-
-                spec.loader.exec_module(mod)
-
-                models = SuperDict(mod.__dict__).kfilter(lambda k: k in self.parents)
-                for model in models:
-                    if isinstance(models[model], MagicMock):
-                        # Models that inherit from other models that are relatively imported
-                        if not isinstance(mod.__dict__[model]._mock_return_value, dict):
-                            continue
-                        props = mod.__dict__[model]._mock_return_value
-                    elif mod.__dict__[model].__dict__.get("__abstract__"):
-                        # BaseDataModel
-                        props = mod.__dict__[model].__dict__
-                        self.parents[model] = None
-                    else:
-                        # Models that inherit from other models that are imported from libraries
-                        self.parents[model] = None
-                        tmp = mod.__dict__[model].__dict__
-                        props = {"__tablename__": tmp.get("__tablename__")}
-                        for col in tmp["__table__"]._columns:
-                            props[col.__dict__["key"]] = next(iter(col.proxy_set))
-                    table_name = props.get("__tablename__", model)
-                    self.data[table_name] = SuperDict(
-                        type="array", items=dict(properties=dict(), required=[])
-                    )
-                    if not props.get("__tablename__") and not self.leave_bases:
-                        self.data[table_name]["remove"] = True
-                    self.model_table[model] = table_name
-                    self.table_model[table_name] = model
-                    for key, val in props.items():
-                        if key in forget_keys:
-                            continue
-                        elif isinstance(val, db.Column):
-                            type_converter = {
-                                db.String: "string",
-                                TEXT: "string",
-                                JSON: "object",
-                                Integer: "integer",
-                                db.Integer: "integer",
-                                db.Boolean: "boolean",
-                                db.SmallInteger: "integer",
-                                db.Float: "number",
-                            }
-                            type_col = "null"
-                            for possible_type, repr_type in type_converter.items():
-                                if isinstance(val.type, possible_type):
-                                    type_col = repr_type
-                            if type_col == "null":
-                                raise Exception("Unknown column type")
-
-                            self.data[table_name]["items"]["properties"][
-                                key
-                            ] = SuperDict(type=type_col)
-                            if val.foreign_keys:
-                                fk = list(val.foreign_keys)[0]
-                                self.data[table_name]["items"]["properties"][key][
-                                    "foreign_key"
-                                ] = fk._colspec
-                            if not val.nullable:
-                                self.data[table_name]["items"]["required"].append(key)
-
-            db.session.close()
+                mod = self._load_module(file_path, file_name)
+                if mod:
+                    self._process_module(mod)
+
+            # Potential db.session cleanup if it was actually used and persisted
+            # If db is only used for type comparison, this might not be needed
+            # db.session.close() # Consider if this is necessary
+
         except Exception as err:
-            click.echo(err)
+            click.echo(f"An error occurred during parsing: {err}")
 
     def inherit(self):
         all_classes = set(self.parents.keys())
@@ -180,7 +274,7 @@ class SchemaGenerator:
 
     def to_schema(self):
         return {
-            "$schema": "http://json-schema.org/schema#",
+            "$schema": "https://json-schema.org/schema#",
             "type": "object",
             "properties": self.data,
             "required": list(self.data.keys()),

cornflow/cli/tools/schemas_tools.py

@@ -35,7 +35,7 @@ class SchemaGenerator:
         for key, val in self.schema["properties"].items():
             if key == "id":
                 continue
-            ty, nullable = get_type(val)
+            ty, _ = get_type(val)
             res += f"    {key} = {JSON_TYPES_TO_FIELDS[ty]}("
             res += "required=False"
             res += ")\n"
@@ -44,7 +44,7 @@ class SchemaGenerator:
     def generate_post_schema(self):
         res = ""
         for key, val in self.schema["properties"].items():
-            ty, nullable = get_type(val)
+            ty, _ = get_type(val)
             res += f"    {key} = {JSON_TYPES_TO_FIELDS[ty]}("
             if key in self.schema["required"]:
                 res += "required=True"
@@ -62,9 +62,8 @@ class SchemaGenerator:
         if not self.schema["properties"].get("id"):
             return "    id = fields.Int(required=True)\n"
         else:
-            id_type=self.schema["properties"].get("id")["type"]
-            return f'    id = {JSON_TYPES_TO_FIELDS[id_type]}(required=True)\n'
-
+            id_type = self.schema["properties"].get("id")["type"]
+            return f"    id = {JSON_TYPES_TO_FIELDS[id_type]}(required=True)\n"
 
     def generate_schema(self):
         if not self.schema["properties"].get("id"):

cornflow/cli/users.py

@@ -14,11 +14,19 @@ from cornflow.shared.exceptions import (
 
 @click.group(name="users", help="Commands to manage the users")
 def users():
+    """
+    This method is empty but it serves as the building block
+    for the rest of the commands
+    """
     pass
 
 
 @click.group(name="create", help="Create a user")
 def create():
+    """
+    This method is empty but it serves as the building block
+    for the rest of the commands
+    """
     pass
 
 

cornflow/cli/views.py

@@ -8,6 +8,10 @@ from .utils import get_app
 
 @click.group(name="views", help="Commands to manage the views")
 def views():
+    """
+    This method is empty but it serves as the building block
+    for the rest of the commands
+    """
     pass
 
 

cornflow/commands/access.py

@@ -1,3 +1,4 @@
+import logging
 import os
 
 from .actions import register_actions_command
@@ -5,18 +6,28 @@ from .permissions import register_base_permissions_command
 from .roles import register_roles_command
 from .views import register_views_command
 
+# Configure logger for access
+logger = logging.getLogger("cornflow.access")
+
 
 def access_init_command(verbose: bool = False):
+    """
+    Initialize the access to the system.
+    """
+
     external = int(os.getenv("EXTERNAL_APP", 0))
     external_app = os.getenv("EXTERNAL_APP_MODULE", "external_app")
 
     register_actions_command(verbose)
-    register_roles_command(verbose)
 
-    register_views_command(verbose=verbose)
     if external != 0:
+        register_roles_command(external_app=external_app, verbose=verbose)
         register_views_command(external_app=external_app, verbose=verbose)
+    else:
+        register_roles_command(verbose=verbose)
+        register_views_command(verbose=verbose)
 
-    register_base_permissions_command(verbose=verbose)
     if external != 0:
         register_base_permissions_command(external_app=external_app, verbose=verbose)
+    else:
+        register_base_permissions_command(verbose=verbose)

cornflow/commands/auxiliar.py

@@ -0,0 +1,106 @@
+import sys
+from importlib import import_module
+
+from flask import current_app
+
+from cornflow.endpoints import resources, alarms_resources
+from cornflow.models import RoleModel
+from cornflow.shared.const import (
+    EXTRA_PERMISSION_ASSIGNATION,
+    ALL_DEFAULT_ROLES,
+)
+from cornflow.shared.const import ROLES_MAP
+
+
+def get_all_external(external_app):
+    """
+    Get all resources, extra permissions, and custom roles actions.
+    external_app: If provided, it will get the resources and extra permissions for the external app.
+    """
+    if external_app is None:
+        resources_to_register = resources
+        extra_permissions = EXTRA_PERMISSION_ASSIGNATION
+        custom_roles_actions = {}
+        if current_app.config["ALARMS_ENDPOINTS"]:
+            resources_to_register = resources + alarms_resources
+    else:
+        sys.path.append("./")
+        external_module = import_module(external_app)
+        try:
+            extra_permissions = (
+                EXTRA_PERMISSION_ASSIGNATION
+                + external_module.shared.const.EXTRA_PERMISSION_ASSIGNATION
+            )
+        except AttributeError:
+            extra_permissions = EXTRA_PERMISSION_ASSIGNATION
+
+        try:
+            custom_roles_actions = external_module.shared.const.CUSTOM_ROLES_ACTIONS
+        except AttributeError:
+            custom_roles_actions = {}
+
+        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, extra_permissions, custom_roles_actions
+
+
+def get_all_resources(resources_to_register):
+    """
+    Get all resources and roles with access.
+    resources_to_register: List of resources to register.
+    """
+
+    resources_roles_with_access = {
+        resource["endpoint"]: resource["resource"].ROLES_WITH_ACCESS
+        for resource in resources_to_register
+    }
+
+    return resources_roles_with_access
+
+
+def get_new_roles_to_add(extra_permissions, resources_roles_with_access):
+    """
+    Get the new roles to add.
+    extra_permissions: List of extra permissions.
+    resources_roles_with_access: Dictionary of resources and roles with access.
+    """
+
+    roles_with_access = list(
+        set([role for roles in resources_roles_with_access.values() for role in roles])
+    )
+    roles_in_extra_permissions = [role for role, _, _ in extra_permissions]
+    roles_with_access = list(set(roles_with_access + roles_in_extra_permissions))
+
+    # Add all default roles that are referenced in BASE_PERMISSION_ASSIGNATION
+    roles_with_access = list(set(roles_with_access + ALL_DEFAULT_ROLES))
+
+    # We extract the existing roles in the database
+    existing_roles = [role.id for role in RoleModel.get_all_objects()]
+    new_roles_to_add = []
+
+    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
+                role_name = ROLES_MAP[role_id]
+                new_role = RoleModel(
+                    {
+                        "id": role_id,
+                        "name": role_name,
+                    }
+                )
+            else:
+                # Create custom role with custom_role_<id> name
+                new_role = RoleModel(
+                    {
+                        "id": role_id,
+                        "name": f"custom_role_{role_id}",
+                    }
+                )
+            new_roles_to_add.append(new_role)
+
+    return new_roles_to_add

cornflow/commands/dag.py

@@ -12,6 +12,7 @@ def register_deployed_dags_command(
     from cornflow_client.airflow.api import Airflow
     from cornflow.models import DeployedDAG
     from cornflow.shared import db
+    from cornflow.shared.const import AIRFLOW_NOT_REACHABLE_MSG
 
     af_client = Airflow(url, user, pwd)
     max_attempts = 20
@@ -19,12 +20,12 @@ def register_deployed_dags_command(
     while not af_client.is_alive() and attempts < max_attempts:
         attempts += 1
         if verbose:
-            current_app.logger.info(f"Airflow is not reachable (attempt {attempts})")
+            current_app.logger.info(f"{AIRFLOW_NOT_REACHABLE_MSG} (attempt {attempts})")
         time.sleep(15)
 
     if not af_client.is_alive():
         if verbose:
-            current_app.logger.info("Airflow is not reachable")
+            current_app.logger.info(f"{AIRFLOW_NOT_REACHABLE_MSG}")
         return False
 
     dags_registered = [dag.id for dag in DeployedDAG.get_all_objects()]