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

cornflow/cli/tools/api_generator.py

@@ -1,6 +1,7 @@
 """
 This file has the class that creates the new API
 """
+
 import json
 import os
 import re
@@ -10,6 +11,8 @@ from .models_tools import ModelGenerator, model_shared_imports
 from .schemas_tools import SchemaGenerator, schemas_imports
 from .tools import generate_class_def
 
+INIT_FILE = "__init__.py"
+
 
 class APIGenerator:
     """
@@ -52,7 +55,7 @@ class APIGenerator:
         self.endpoint_path = os.path.join(self.output_path, "endpoints")
         self.schema_path = os.path.join(self.output_path, "schemas")
         self.init_resources = []
-        self.init_file = os.path.join(self.endpoint_path, "__init__.py")
+        self.init_file = os.path.join(self.endpoint_path, INIT_FILE)
 
     def import_schema(self) -> dict:
         """
@@ -77,23 +80,23 @@ class APIGenerator:
         if not os.path.isdir(self.model_path):
             os.mkdir(self.model_path)
 
-        init_path = os.path.join(self.model_path, "__init__.py")
+        init_path = os.path.join(self.model_path, INIT_FILE)
         with open(init_path, "w") as file:
-            file.write(f'"""\nThis file exposes the models\n"""\n')
+            file.write("\nThis file exposes the models\n\n")
 
         if not os.path.isdir(self.endpoint_path):
             os.mkdir(self.endpoint_path)
 
-        init_path = os.path.join(self.endpoint_path, "__init__.py")
+        init_path = os.path.join(self.endpoint_path, INIT_FILE)
         with open(init_path, "w") as file:
-            file.write(f'"""\nThis file exposes the endpoints\n"""\n')
+            file.write("\nThis file exposes the endpoints\n\n")
 
         if not os.path.isdir(self.schema_path):
             os.mkdir(self.schema_path)
 
-        init_path = os.path.join(self.schema_path, "__init__.py")
+        init_path = os.path.join(self.schema_path, INIT_FILE)
         with open(init_path, "w") as file:
-            file.write(f'"""\nThis file exposes the schemas\n"""\n')
+            file.write("\nThis file exposes the schemas\n\n")
 
     def main(self):
         """
@@ -151,7 +154,7 @@ class APIGenerator:
             fd.write(mg.generate_model_repr_str())
             fd.write("\n")
 
-        init_file = os.path.join(self.model_path, "__init__.py")
+        init_file = os.path.join(self.model_path, INIT_FILE)
 
         with open(init_file, "a") as file:
             file.write(f"from .{self.prefix}{table_name} import {class_name}\n")
@@ -207,7 +210,7 @@ class APIGenerator:
             fd.write(generate_class_def(class_name_one, parents_class))
             fd.write(sg.generate_schema())
 
-        init_file = os.path.join(self.schema_path, "__init__.py")
+        init_file = os.path.join(self.schema_path, INIT_FILE)
         with open(init_file, "a") as file:
             file.write(
                 f"from .{self.prefix}{table_name} import {class_name_one}, "
@@ -432,7 +435,7 @@ class APIGenerator:
         :return: str: the type in format "<type:idx>"
         """
         schema_table = self.schema["properties"][table_name]["items"]["properties"]
-        id_type=None
+        id_type = None
         if "id" in schema_table.keys():
             id_type = schema_table["id"]["type"]
         if id_type == "string" or isinstance(id_type, list):

cornflow/cli/tools/endpoint_tools.py

@@ -2,7 +2,15 @@
 SP8 = 8 * " "
 SP12 = 12 * " "
 
+DOC_DECORATOR = "@doc"
+AUTH_DECORATOR = "@authenticate(auth_class=Auth())"
+COMMENT_AUTH_1 = "It requires authentication to be passed in the form of a token that has to be linked to\n"
+COMMENT_AUTH_2 = "an existing session (login) made by a user.\n"
+PARAM_IDX_DOCSTRING = ":param idx: ID of the row\n"
+RETURN_DOCSTRING_1 = ":rtype: Tuple(dict, integer)\n"
 
+
+# TODO: refactor these methods to make them more modular
 class EndpointGenerator:
     def __init__(self, table_name, app_name, model_name, schemas_names):
         self.table_name = table_name
@@ -12,7 +20,7 @@ class EndpointGenerator:
         self.descriptions = {
             "base": "Endpoint used to manage the table",
             "bulk": "Endpoint used to perform bulk operations on the table",
-            "detail": "Endpoint used to perform detail operations on the table"
+            "detail": "Endpoint used to perform detail operations on the table",
         }
 
     def generate_endpoints_imports(self, roles):
@@ -41,8 +49,10 @@ class EndpointGenerator:
         :param ep_type: type of endpoint (base, bulk or detail)
         :return:
         """
-        name_types = dict(base="list", bulk ="bulk", detail ="detail")
-        return [v[0] for v in [m.split("_") for m in methods] if v[1] == name_types[ep_type]]
+        name_types = dict(base="list", bulk="bulk", detail="detail")
+        return [
+            v[0] for v in [m.split("_") for m in methods] if v[1] == name_types[ep_type]
+        ]
 
     def generate_endpoint_description(self, methods, ep_type="base"):
         """
@@ -55,7 +65,7 @@ class EndpointGenerator:
         """
         type_methods = self.get_type_methods(methods, ep_type)
         description = self.descriptions[ep_type]
-        app_name = f' of app {self.app_name}' if self.app_name is not None else ""
+        app_name = f" of app {self.app_name}" if self.app_name is not None else ""
         res = '    """\n'
         res += f"    {description} {self.table_name}{app_name}.\n\n"
         res += f"    Available methods: [{', '.join(type_methods)}]\n"
@@ -66,223 +76,208 @@ class EndpointGenerator:
         res = "    def __init__(self):\n"
         res += SP8 + "super().__init__()\n"
         res += SP8 + f"self.data_model = {self.model_name}\n"
-        res += SP8 + f"self.unique = ['id']\n"
+        res += SP8 + "self.unique = ['id']\n"
         return res
 
-    def generate_endpoint_get_all(self):
-        schema_name = self.schemas_names["one"]
-        res = "    @doc(\n"
-        res += SP8 + 'description="Get list of all the elements in the table",\n'
-        res += SP8 + f'tags=["{self.app_name}"],\n'
-        res += "    )\n"
-        res += "    @authenticate(auth_class=Auth())\n"
-        res += f"    @marshal_with({schema_name}(many=True))\n"
-        res += "    def get(self, **kwargs):\n"
-        res += SP8 + '"""\n'
-        res += SP8 + "API method to get all the rows of the table.\n"
-        res += (
-            SP8
-            + "It requires authentication to be passed in the form of a token that has to be linked to\n"
+    def _generate_docstring(self, summary, param_idx=False, return_desc=""):
+        """Generates the common docstring structure for endpoint methods."""
+        lines = [
+            SP8 + '"""\n',
+            SP8 + summary + "\n",
+            f"{SP8}{COMMENT_AUTH_1}",
+            f"{SP8}{COMMENT_AUTH_2}",
+        ]
+        if param_idx:
+            lines.append(f"{SP8}{PARAM_IDX_DOCSTRING}")
+        if return_desc:
+            lines.append(SP8 + return_desc + "\n")
+        lines.append(f"{SP8}{RETURN_DOCSTRING_1}")
+        lines.append(SP8 + '"""\n')
+        return "".join(lines)
+
+    def _generate_method(
+        self,
+        http_method: str,
+        method_name: str,
+        is_detail: bool,
+        doc_description: str,
+        docstring_summary: str,
+        docstring_return_desc: str,
+        base_method_call: str,
+        marshal_schema: str = None,
+        kwargs_schema: str = None,
+        marshal_many: bool = False,
+    ):
+        """Generates the complete string for an endpoint method."""
+        lines = []
+
+        # @doc decorator
+        lines.append(f"    {DOC_DECORATOR}(")
+        lines.append(f'        description="{doc_description}",')
+        lines.append(
+            f'        tags=["{self.app_name}"],'
+        )  # Add comma if needed for future args
+        lines.append("    )")
+
+        # @authenticate decorator
+        lines.append(f"    {AUTH_DECORATOR}")
+
+        # @marshal_with decorator
+        if marshal_schema:
+            many_str = "(many=True)" if marshal_many else ""
+            lines.append(f"    @marshal_with({marshal_schema}{many_str})")
+
+        # @use_kwargs decorator
+        if kwargs_schema:
+            lines.append(f'    @use_kwargs({kwargs_schema}, location="json")')
+
+        # Method signature
+        params = "idx" if is_detail else "**kwargs"
+        if http_method in ["put", "patch"] and is_detail:
+            params = "idx, **data"
+        elif http_method == "post" and not is_detail:
+            params = "**kwargs"  # Keep as kwargs for bulk post
+
+        lines.append(f"    def {method_name}(self, {params}):")
+
+        # Docstring
+        docstring = self._generate_docstring(
+            summary=docstring_summary,
+            param_idx=is_detail,
+            return_desc=docstring_return_desc,
         )
-        res += SP8 + "an existing session (login) made by a user.\n\n"
-        res += (
-            SP8
-            + ":return: A list of objects with the data, and an integer with the HTTP status code.\n"
+        lines.append(docstring.strip("\n"))  # Remove leading/trailing newlines if any
+
+        # Base method call
+        lines.append(f"{SP8}return {base_method_call}")
+
+        return "\n".join(lines) + "\n"  # Ensure trailing newline
+
+    def generate_endpoint_get_all(self):
+        return self._generate_method(
+            http_method="get",
+            method_name="get",
+            is_detail=False,
+            doc_description="Get list of all the elements in the table",
+            marshal_schema=self.schemas_names["one"],
+            marshal_many=True,
+            docstring_summary="API method to get all the rows of the table.",
+            docstring_return_desc=":return: A list of objects with the data, and an integer with the HTTP status code.",
+            base_method_call="self.get_list(**kwargs)",
         )
-        res += SP8 + ":rtype: Tuple(dict, integer)\n"
-        res += SP8 + '"""\n'
-        res += SP8 + "return self.get_list(**kwargs)\n"
-        return res
 
     def generate_endpoint_get_one(self):
-        schema_name = self.schemas_names["one"]
-        res = "    @doc(\n"
-        res += SP8 + 'description="Get one element of the table",\n'
-        res += SP8 + f'tags=["{self.app_name}"],\n'
-        res += "    )\n"
-        res += "    @authenticate(auth_class=Auth())\n"
-        res += f"    @marshal_with({schema_name})\n"
-        res += "    def get(self, idx):\n"
-        res += SP8 + '"""\n'
-        res += SP8 + "API method to get a row of the table.\n"
-        res += (
-            SP8
-            + "It requires authentication to be passed in the form of a token that has to be linked to\n"
+        return self._generate_method(
+            http_method="get",
+            method_name="get",
+            is_detail=True,
+            doc_description="Get one element of the table",
+            marshal_schema=self.schemas_names["one"],
+            docstring_summary="API method to get a row of the table.",
+            docstring_return_desc=":return: A dictionary with the response data and an integer with the HTTP status code.",
+            base_method_call="self.get_detail(idx=idx)",
         )
-        res += SP8 + "an existing session (login) made by a user.\n\n"
-        res += SP8 + ":param idx: ID of the row\n"
-        res += (
-            SP8
-            + ":return: A dictionary with the response data and an integer with the HTTP status code.\n"
-        )
-        res += SP8 + ":rtype: Tuple(dict, integer)\n"
-        res += SP8 + '"""\n'
-        res += SP8 + "return self.get_detail(idx=idx)\n"
-        return res
 
     def generate_endpoint_post(self):
-        schema_marshal = self.schemas_names["one"]
-        schema_kwargs = self.schemas_names["postRequest"]
-        res = "    @doc(\n"
-        res += SP8 + 'description="Add a new row to the table",\n'
-        res += SP8 + f'tags=["{self.app_name}"],\n'
-        res += "    )\n"
-        res += "    @authenticate(auth_class=Auth())\n"
-        res += f"    @marshal_with({schema_marshal})\n"
-        res += f'    @use_kwargs({schema_kwargs}, location="json")\n'
-        res += "    def post(self, **kwargs):\n"
-        res += SP8 + '"""\n'
-        res += SP8 + "API method to add a row to the table.\n"
-        res += (
-            SP8
-            + "It requires authentication to be passed in the form of a token that has to be linked to\n"
+        return self._generate_method(
+            http_method="post",
+            method_name="post",
+            is_detail=False,
+            doc_description="Add a new row to the table",
+            marshal_schema=self.schemas_names["one"],
+            kwargs_schema=self.schemas_names["postRequest"],
+            docstring_summary="API method to add a row to the table.",
+            docstring_return_desc=":return: An object with the data for the created row,\\n"
+            + SP8
+            + "and an integer with the HTTP status code.",
+            base_method_call="self.post_list(data=kwargs)",
         )
-        res += SP8 + "an existing session (login) made by a user.\n\n"
-        res += SP8 + ":return: An object with the data for the created row,\n"
-        res += SP8 + "and an integer with the HTTP status code.\n"
-        res += SP8 + ":rtype: Tuple(dict, integer)\n"
-        res += SP8 + '"""\n'
-        res += SP8 + "return self.post_list(data=kwargs)\n"
-        return res
 
     def generate_endpoint_delete_one(self):
-        res = "    @doc(\n"
-        res += SP8 + 'description="Delete one row of the table",\n'
-        res += SP8 + f'tags=["{self.app_name}"], \n'
-        res += "    )\n"
-        res += "    @authenticate(auth_class=Auth())\n"
-        res += "    def delete(self, idx):\n"
-        res += SP8 + '"""\n'
-        res += SP8 + "API method to delete a row of the table.\n"
-        res += (
-            SP8
-            + "It requires authentication to be passed in the form of a token that has to be linked to\n"
-        )
-        res += SP8 + "an existing session (login) made by a user.\n\n"
-        res += SP8 + ":param idx: ID of the row\n"
-        res += (
-            SP8
-            + ":return: A dictionary with a message (error if authentication failed, "
-            + "or the execution does not exist or\n"
+        return self._generate_method(
+            http_method="delete",
+            method_name="delete",
+            is_detail=True,
+            doc_description="Delete one row of the table",
+            docstring_summary="API method to delete a row of the table.",
+            docstring_return_desc=":return: A dictionary with a message (error if authentication failed, or the execution does not exist or\\n"
+            + SP8
+            + "a message) and an integer with the HTTP status code.",
+            base_method_call="self.delete_detail(idx=idx)",
         )
-        res += SP8 + "a message) and an integer with the HTTP status code.\n"
-        res += SP8 + ":rtype: Tuple(dict, integer)\n"
-        res += SP8 + '"""\n'
-        res += SP8 + "return self.delete_detail(idx=idx)\n"
-        return res
 
     def generate_endpoint_put(self):
-        schema_name = self.schemas_names["editRequest"]
-        res = "    @doc(\n"
-        res += SP8 + 'description="Edit one row of the table",\n'
-        res += SP8 + f'tags=["{self.app_name}"], \n'
-        res += "    )\n"
-        res += "    @authenticate(auth_class=Auth())\n"
-        res += f'    @use_kwargs({schema_name}, location="json")\n'
-        res += "    def put(self, idx, **data):\n"
-        res += SP8 + '"""\n'
-        res += SP8 + "API method to edit a row of the table.\n"
-        res += (
-            SP8
-            + "It requires authentication to be passed in the form of a token that has to be linked to\n"
+        return self._generate_method(
+            http_method="put",
+            method_name="put",
+            is_detail=True,
+            doc_description="Edit one row of the table",
+            kwargs_schema=self.schemas_names["editRequest"],
+            docstring_summary="API method to edit a row of the table.",
+            docstring_return_desc=":return: A dictionary with a message (error if authentication failed, or the execution does not exist or\\n"
+            + SP8
+            + "a message) and an integer with the HTTP status code.",
+            base_method_call="self.put_detail(data=data, idx=idx)",
         )
-        res += SP8 + "an existing session (login) made by a user.\n\n"
-        res += SP8 + ":param idx: ID of the row\n"
-        res += (
-            SP8
-            + ":return: A dictionary with a message (error if authentication failed, "
-            + "or the execution does not exist or\n"
-        )
-        res += SP8 + "a message) and an integer with the HTTP status code.\n"
-        res += SP8 + ":rtype: Tuple(dict, integer)\n"
-        res += SP8 + '"""\n'
-        res += SP8 + "return self.put_detail(data=data, idx=idx)\n"
-        return res
 
     def generate_endpoint_patch(self):
-        schema_name = self.schemas_names["editRequest"]
-        res = "    @doc(\n"
-        res += SP8 + 'description="Patch one row of the table",\n'
-        res += SP8 + f'tags=["{self.app_name}"], \n'
-        res += "    )\n"
-        res += "    @authenticate(auth_class=Auth())\n"
-        res += f'    @use_kwargs({schema_name}, location="json")\n'
-        res += "    def patch(self, idx, **data):\n"
-        res += SP8 + '"""\n'
-        res += SP8 + "API method to patch a row of the table.\n"
-        res += (
-            SP8
-            + "It requires authentication to be passed in the form of a token that has to be linked to\n"
-        )
-        res += SP8 + "an existing session (login) made by a user.\n\n"
-        res += SP8 + ":param idx: ID of the row\n"
-        res += (
-            SP8
-            + ":return: A dictionary with a message (error if authentication failed, "
-            + "or the execution does not exist or\n"
+        return self._generate_method(
+            http_method="patch",
+            method_name="patch",
+            is_detail=True,
+            doc_description="Patch one row of the table",
+            kwargs_schema=self.schemas_names["editRequest"],
+            docstring_summary="API method to patch a row of the table.",
+            docstring_return_desc=":return: A dictionary with a message (error if authentication failed, or the execution does not exist or\\n"
+            + SP8
+            + "a message) and an integer with the HTTP status code.",
+            base_method_call="self.patch_detail(data=data, idx=idx)",
         )
-        res += SP8 + "a message) and an integer with the HTTP status code.\n"
-        res += SP8 + ":rtype: Tuple(dict, integer)\n"
-        res += SP8 + '"""\n'
-        res += SP8 + "return self.patch_detail(data=data, idx=idx)\n"
-        return res
 
     def generate_endpoint_post_bulk(self):
-        schema_marshal = self.schemas_names["one"]
-        schema_kwargs = self.schemas_names["postBulkRequest"]
-        res = "    @doc(\n"
-        res += SP8 + 'description="Add several new rows to the table",\n'
-        res += SP8 + f'tags=["{self.app_name}"],\n'
-        res += "    )\n"
-        res += "    @authenticate(auth_class=Auth())\n"
-        res += f"    @marshal_with({schema_marshal}(many=True))\n"
-        res += f'    @use_kwargs({schema_kwargs}, location="json")\n'
-        res += "    def post(self, **kwargs):\n"
-        res += SP8 + '"""\n'
-        res += SP8 + "API method to add several new rows to the table.\n"
-        res += (
-            SP8
-            + "It requires authentication to be passed in the form of a token that has to be linked to\n"
+        return self._generate_method(
+            http_method="post",
+            method_name="post",
+            is_detail=False,
+            doc_description="Add several new rows to the table",
+            marshal_schema=self.schemas_names["one"],
+            marshal_many=True,
+            kwargs_schema=self.schemas_names["postBulkRequest"],
+            docstring_summary="API method to add several new rows to the table.",
+            docstring_return_desc=":return: An object with the data for the created row,\\n"
+            + SP8
+            + "and an integer with the HTTP status code.",
+            base_method_call="self.post_bulk(data=kwargs)",
         )
-        res += SP8 + "an existing session (login) made by a user.\n\n"
-        res += SP8 + ":return: An object with the data for the created row,\n"
-        res += SP8 + "and an integer with the HTTP status code.\n"
-        res += SP8 + ":rtype: Tuple(dict, integer)\n"
-        res += SP8 + '"""\n'
-        res += SP8 + "return self.post_bulk(data=kwargs)\n"
-        return res
 
     def generate_endpoint_put_bulk(self):
-        schema_marshal = self.schemas_names["one"]
-        schema_kwargs = self.schemas_names["putBulkRequest"]
-        res = "    @doc(\n"
-        res += SP8 + 'description="Updates several rows of the table or adds them if they do not exist",\n'
-        res += SP8 + f'tags=["{self.app_name}"],\n'
-        res += "    )\n"
-        res += "    @authenticate(auth_class=Auth())\n"
-        res += f"    @marshal_with({schema_marshal}(many=True))\n"
-        res += f'    @use_kwargs({schema_kwargs}, location="json")\n'
-        res += "    def put(self, **kwargs):\n"
-        res += SP8 + '"""\n'
-        res += SP8 + "API method to add several new rows to the table.\n"
-        res += (
-            SP8
-            + "It requires authentication to be passed in the form of a token that has to be linked to\n"
+        return self._generate_method(
+            http_method="put",
+            method_name="put",
+            is_detail=False,
+            doc_description="Updates several rows of the table or adds them if they do not exist",
+            marshal_schema=self.schemas_names["one"],
+            marshal_many=True,
+            kwargs_schema=self.schemas_names["putBulkRequest"],
+            docstring_summary="API method to add or update several rows to the table.",
+            docstring_return_desc=":return: An object with the data for the created/updated rows,\\n"
+            + SP8
+            + "and an integer with the HTTP status code.",
+            base_method_call="self.post_bulk_update(data=kwargs)",
         )
-        res += SP8 + "an existing session (login) made by a user.\n\n"
-        res += SP8 + ":return: An object with the data for the created row,\n"
-        res += SP8 + "and an integer with the HTTP status code.\n"
-        res += SP8 + ":rtype: Tuple(dict, integer)\n"
-        res += SP8 + '"""\n'
-        res += SP8 + "return self.post_bulk_update(data=kwargs)\n"
-        return res
 
     def generate_endpoint(self, method):
-        ep_map = dict(get_list=self.generate_endpoint_get_all, post_list=self.generate_endpoint_post, get_detail=self.generate_endpoint_get_one,
-                      put_detail=self.generate_endpoint_put,
-                      patch_detail=self.generate_endpoint_patch,
-                      delete_detail= self.generate_endpoint_delete_one,
-                      post_bulk=self.generate_endpoint_post_bulk,
-                      put_bulk=self.generate_endpoint_put_bulk
+        ep_map = dict(
+            get_list=self.generate_endpoint_get_all,
+            post_list=self.generate_endpoint_post,
+            get_detail=self.generate_endpoint_get_one,
+            put_detail=self.generate_endpoint_put,
+            patch_detail=self.generate_endpoint_patch,
+            delete_detail=self.generate_endpoint_delete_one,
+            post_bulk=self.generate_endpoint_post_bulk,
+            put_bulk=self.generate_endpoint_put_bulk,
         )
-        return ep_map[method]()
+        generator_func = ep_map.get(method)
+        if generator_func is None:
+            raise ValueError(f"Unsupported endpoint generation method: {method}")
+        return generator_func()