spa-cli 1.0.0__tar.gz

spa_cli-1.0.0/PKG-INFO

@@ -0,0 +1,24 @@
+Metadata-Version: 2.4
+Name: spa-cli
+Version: 1.0.0
+Summary: Un cli para manejar proyectos serverless en aws con python
+Author: David Cuy
+Author-email: david.cuy.sanchez@gmail.com
+Requires-Python: >=3.11,<4.0
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Requires-Dist: cookiecutter (>=2.6.0,<3.0.0)
+Requires-Dist: pydantic (>=2.11.9,<3.0.0)
+Requires-Dist: python-dotenv (>=1.1.1,<2.0.0)
+Requires-Dist: setuptools (>=80.9.0,<81.0.0)
+Requires-Dist: toml (>=0.10.2,<0.11.0)
+Requires-Dist: typer (>=0.19.1,<0.20.0)
+Project-URL: Documentation, https://github.com/DavidCuy/spa-cli
+Project-URL: Homepage, https://github.com/DavidCuy/spa-cli
+Project-URL: Repository, https://github.com/DavidCuy/spa-cli
+Description-Content-Type: text/markdown
+
+

spa_cli-1.0.0/pyproject.toml

@@ -0,0 +1,29 @@
+[tool.poetry]
+name = "spa-cli"
+version = "1.0.0"
+description = "Un cli para manejar proyectos serverless en aws con python"
+authors = ["David Cuy <david.cuy.sanchez@gmail.com>"]
+readme = "README.md"
+packages = [{include = "spa_cli"}]
+homepage = "https://github.com/DavidCuy/spa-cli"
+repository = "https://github.com/DavidCuy/spa-cli"
+documentation = "https://github.com/DavidCuy/spa-cli"
+
+
+[tool.poetry.scripts]
+spa-cli = "spa_cli.cli:app"
+spa = "spa_cli.cli:app"
+
+[tool.poetry.dependencies]
+python = "^3.11"
+python-dotenv = "^1.1.1"
+toml = "^0.10.2"
+cookiecutter = "^2.6.0"
+setuptools = "^80.9.0"
+pydantic = "^2.11.9"
+typer = "^0.19.1"
+
+
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"

spa_cli-1.0.0/spa_cli/__main__.py

@@ -0,0 +1,3 @@
+from .cli import app
+
+app(prog_name='spa-src')

spa_cli-1.0.0/spa_cli/cli.py

@@ -0,0 +1,26 @@
+from importlib.metadata import version as v
+
+import typer
+from dotenv import load_dotenv
+
+from .src.project import project
+from .src.model import model
+from .src.endpoint import endpoint
+from .src.lambda_function import lambda_function
+
+load_dotenv()
+
+app = typer.Typer()
+app.add_typer(project.app, name='project')
+# app.add_typer(model.app, name='model')
+app.add_typer(endpoint.app, name='endpoint')
+app.add_typer(lambda_function.app, name='lambda')
+
+
+@app.callback(invoke_without_command=True)
+def callback_version(version: bool = False):
+    """
+    Imprime la versión del CLI.
+    """
+    if version:
+        typer.echo(f'version: {v("spa-cli")}')

spa_cli-1.0.0/spa_cli/globals.py

@@ -0,0 +1,215 @@
+from enum import Enum
+import os
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any, TypeVar, Type, cast, Callable, List
+import typer
+import toml
+import datetime
+from dotenv import load_dotenv
+
+class Constants(Enum):
+    PROJECT_TEMPLATE = "https://github.com/DavidCuy/serverless-python-application-pattern.git"
+    MYSQL_ENGINE = "mysql"
+    POSTGRESQL_ENGINE = "postgresql"
+    
+    AWS_REPOSITORY = "aws"
+    OTHER_REPOSITORY = "other"
+    
+    LOCALHOST_DB_DOCKER = "host.docker.internal"
+    MSSQL_SA_USER = "sa"
+
+    VALID_MODEL_TYPES = (int, str, float, datetime.datetime)
+    JSON_INT_DTYPE = 'int'
+    JSON_FLOAT_DTYPE = 'float'
+    JSON_STRING_DTYPE = 'str'
+    JSON_DATETIME_DTYPE = 'datetime'
+
+DRIVERS = {
+    Constants.MYSQL_ENGINE.value: "pymysql",
+    Constants.POSTGRESQL_ENGINE.value: "psycopg2"
+}
+
+def get_driver_from_engine(engine: Constants):
+    return DRIVERS.get(engine.value, None)
+
+SQL_PORTS_DEFAULT = {
+    Constants.MYSQL_ENGINE.value: "3306",
+    Constants.POSTGRESQL_ENGINE.value: "5432"
+}
+
+JSON_MAPPING_VALUE = {
+    Constants.JSON_INT_DTYPE.value: 'Column("{ColumnName}", Integer)',
+    Constants.JSON_STRING_DTYPE.value: 'Column("{ColumnName}", String)',
+    Constants.JSON_FLOAT_DTYPE.value: 'Column("{ColumnName}", Float)',
+    Constants.JSON_DATETIME_DTYPE.value: 'Column("{ColumnName}", DateTime)'
+}
+
+T = TypeVar("T")
+
+def from_list(f: Callable[[Any], T], x: Any) -> List[T]:
+    assert isinstance(x, list)
+    return [f(y) for y in x]
+
+
+def from_str(x: Any) -> str:
+    assert isinstance(x, str)
+    return x
+
+
+def from_str_to_list(x: Any) -> List[str]:
+    assert isinstance(x, str)
+    return [x]
+
+
+def from_union(fs, x):
+    for f in fs:
+        try:
+            return f(x)
+        except:
+            pass
+    assert False
+
+
+def to_class(c: Type[T], x: Any) -> dict:
+    assert isinstance(x, c)
+    return cast(Any, x).to_dict()
+
+class BaseConf:
+    @property
+    def attrs(self) -> List[str]:
+        """ Returns a list of the attributes of an object
+        Returns:
+            List[str]: Attributes
+        """
+        return list(filter(lambda prop: not str(prop).startswith('_'), self.__dict__.keys()))
+    
+    @classmethod
+    def from_dict(cls_, obj: Any) -> 'Folders':
+        assert isinstance(obj, dict)
+        
+        obj_dict = {}
+        attributes = list(filter(lambda prop: not str(prop).startswith('_'), (cls_).__dataclass_fields__.keys()))
+        for attr in attributes:
+            obj_dict.update({attr: from_str(obj.get(attr))})
+        return cls_(**obj_dict)
+    
+    def to_dict(self):
+        output_dict = {}
+        for attr in self.attrs:
+            output_dict.update({attr: self.__getattribute__(attr)})
+        return output_dict
+    
+    def __repr__(self) -> str:
+        """ Model representation
+        Returns:
+            str: Model output string formatted
+        """
+        attr_array = [f"{attr}={self.__getattribute__(attr)}" for attr in self.attrs]
+        args_format = ",".join(attr_array)
+        return f"<{type(self).__name__}({args_format})>"
+
+@dataclass
+class Files(BaseConf):
+    model: str
+    service: str
+    controller: str
+    endpoint: str
+    lambda_function: str
+    test_lambda: str
+    lambda_conf: str
+
+
+@dataclass
+class Folders(BaseConf):
+    models: str
+    services: str
+    controllers: str
+    lambdas: str
+    root: str
+    jsons: str
+    layers: str
+
+@dataclass
+class Definition(BaseConf):
+    name: str
+    description: str
+    author: str
+    author_email: str
+    base_api: str
+
+@dataclass
+class Project(BaseConf):
+    definition: Definition
+    folders: Folders
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Project':
+        assert isinstance(obj, dict)
+        definition = Definition.from_dict(obj.get("definition"))
+        folders = Folders.from_dict(obj.get("folders"))
+        return Project(definition, folders)
+
+@dataclass
+class Template(BaseConf):
+    files: Files
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Template':
+        assert isinstance(obj, dict)
+        files = Files.from_dict(obj.get("files"))
+        return Template(files)
+
+@dataclass
+class Config(BaseConf):
+    project: Project
+    template: Template
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Config':
+        assert isinstance(obj, dict)
+        project = Project.from_dict(obj.get("project"))
+        template = Template.from_dict(obj.get("template"))
+        return Config(project, template)
+
+
+def load_config(path="spa_project.toml") -> Config:
+    config_path = Path(Path.cwd() / path)
+    if not config_path.exists():
+        typer.echo("config file not found in the project.", color=typer.colors.YELLOW)
+        load_dotenv(".env")
+        app_name = os.getenv("app_name") or ""
+        config_path.write_text(f"""[spa.project.definition]
+name = "{app_name}"
+description = ""
+author = "David Cuy"
+author_email = ""
+base_api = "api.yaml"
+
+[spa.template.files]
+model = ".spa/templates/models/model.txt"
+service = ".spa/templates/models/service.txt"
+controller = ".spa/templates/models/controller.txt"
+endpoint = ".spa/templates/lambda_endpoint.txt"
+lambda_function = ".spa/templates/lambda.txt"
+test_lambda = ".spa/templates/test_lambda_function.txt"
+lambda_conf = ".spa/templates/lambda_conf.txt"
+
+[spa.project.folders]
+root = "src"
+models = "src/layers/databases/python/core_db/models"
+services = "src/layers/databases/python/core_db/services"
+controllers = "src/layers/core/python/core_http/controllers"
+jsons = ".spa/templates/json"
+lambdas = "src/lambdas"
+layers = "src/layers"
+        """)
+        typer.echo(
+            f"Created config file at {config_path} in this path you can find all configuration for the project here.")
+        typer.echo(f"Please add the file {config_path} to git tracking and commit it")
+    try:
+        toml_config = toml.loads(config_path.read_text())
+    except Exception as e:
+        typer.echo("Error reading the config file, please check the file format.", color=typer.colors.RED)
+        raise 
+    return Config.from_dict(toml_config["spa"])

spa_cli-1.0.0/spa_cli/src/endpoint/endpoint.py

@@ -0,0 +1,75 @@
+from ...globals import load_config
+from ..utils.folders import validate_path_not_exist
+from ..utils.strings import camel_case
+from ..utils.template_gen import copy_template_file
+
+import os
+import typer
+from pathlib import Path
+
+app = typer.Typer()
+
+@app.command('add')
+def new_endpoint(
+        method: str = typer.Option(..., help='Metodo de la peticion. Valores permitidos [GET, POST, PUT, PATCH, DELETE]'),
+        path: str = typer.Option(..., help='Path del endpoint.'),
+        endpoint_name: str = typer.Option(help='Nombre de la funcion lambda.')
+    ):
+    
+    if "-" in endpoint_name or " " in endpoint_name:
+        typer.echo('El nombre de la lambda no debe contener espacios o guiones. Se modificará por guiones bajos.', color=typer.colors.YELLOW)
+        endpoint_name = endpoint_name.replace("-", "_").replace(" ", "_")
+    
+    config = load_config()
+    camel_name = camel_case(endpoint_name)
+    
+    lambda_template_path = Path(config.template.files.lambda_function)
+    lambda_test_template_path = Path(config.template.files.test_lambda)
+    lambda_conf_template_path = Path(config.template.files.lambda_conf)
+    lambda_endpoint_template_path = Path(config.template.files.endpoint)
+    
+    lambda_output_folder_path = Path(config.project.folders.lambdas)
+
+    try:
+        model_exists = validate_path_not_exist(path=lambda_output_folder_path.joinpath(endpoint_name), custom_error_message=f'Ya existe una ruta con nombre: {endpoint_name}', abort=False)
+    except Exception as e:
+        typer.echo(str(e))
+    
+    if not model_exists:
+        os.mkdir(lambda_output_folder_path.joinpath(endpoint_name))
+    
+    copy_template_file(
+        template_path=lambda_template_path,
+        destination_path=lambda_output_folder_path.joinpath(endpoint_name).joinpath('lambda_function.py'),
+        code_format_override={}
+    )
+    
+    copy_template_file(
+        template_path=lambda_test_template_path,
+        destination_path=lambda_output_folder_path.joinpath(endpoint_name).joinpath('test_lambda_function.py'),
+        code_format_override={
+            "camel_name": camel_name,
+            "lambda_name": endpoint_name
+        }
+    )
+    
+    copy_template_file(
+        template_path=lambda_conf_template_path,
+        destination_path=lambda_output_folder_path.joinpath(endpoint_name).joinpath('infra_config.py'),
+        code_format_override={
+            "lambda_name": endpoint_name,
+            "camel_name": camel_name
+        }
+    )
+    
+    copy_template_file(
+        template_path=lambda_endpoint_template_path,
+        destination_path=lambda_output_folder_path.joinpath(endpoint_name).joinpath('endpoint.yaml'),
+        code_format_override={
+            "endpoint_url": path,
+            "endpoint_method": method.lower(),
+        }
+    )
+
+    typer.echo(f'La ruta {path} [{method}] se agrego correctamente!', color=typer.colors.GREEN)
+

spa_cli-1.0.0/spa_cli/src/lambda_function/lambda_function.py

@@ -0,0 +1,62 @@
+from ...globals import load_config
+from ..utils.folders import validate_path_not_exist
+from ..utils.strings import camel_case
+from ..utils.template_gen import copy_template_file
+
+import os
+import typer
+from pathlib import Path
+
+app = typer.Typer()
+
+@app.command('add')
+def new_lambda(
+        lambda_name: str = typer.Option(help='Nombre de la funcion lambda.')
+    ):
+    config = load_config()
+    
+    if "-" in lambda_name or " " in lambda_name:
+        typer.echo('El nombre de la lambda no debe contener espacios o guiones. Se modificará por guiones bajos.', color=typer.colors.YELLOW)
+        lambda_name = lambda_name.replace("-", "_").replace(" ", "_")
+    camel_name = camel_case(lambda_name)
+    
+    lambda_template_path = Path(config.template.files.lambda_function)
+    lambda_test_template_path = Path(config.template.files.test_lambda)
+    lambda_conf_template_path = Path(config.template.files.lambda_conf)
+    
+    lambda_output_folder_path = Path(config.project.folders.lambdas)
+
+    try:
+        model_exists = validate_path_not_exist(path=lambda_output_folder_path.joinpath(lambda_name), custom_error_message=f'Ya existe una ruta con nombre: {lambda_name}', abort=False)
+    except Exception as e:
+        typer.echo(str(e))
+    
+    if not model_exists:
+        os.mkdir(lambda_output_folder_path.joinpath(lambda_name))
+    
+    copy_template_file(
+        template_path=lambda_template_path,
+        destination_path=lambda_output_folder_path.joinpath(lambda_name).joinpath('lambda_function.py'),
+        code_format_override={}
+    )
+    
+    copy_template_file(
+        template_path=lambda_test_template_path,
+        destination_path=lambda_output_folder_path.joinpath(lambda_name).joinpath('test_lambda_function.py'),
+        code_format_override={
+            "camel_name": camel_name,
+            "lambda_name": lambda_name
+        }
+    )
+    
+    copy_template_file(
+        template_path=lambda_conf_template_path,
+        destination_path=lambda_output_folder_path.joinpath(lambda_name).joinpath('infra_config.py'),
+        code_format_override={
+            "lambda_name": lambda_name,
+            "camel_name": camel_name
+        }
+    )
+
+    typer.echo(f'La lambda {lambda_name} se agrego correctamente!', color=typer.colors.GREEN)
+

spa_cli-1.0.0/spa_cli/src/model/model.py

@@ -0,0 +1,140 @@
+from ...globals import load_config, Config, Constants, JSON_MAPPING_VALUE
+from ..utils.folders import validate_path_not_exist, validate_path_exist
+from ..utils.strings import camel_case, snake_case
+from ..utils.template_gen import add_code_to_module, add_file_to_module, read_project_config
+
+import json
+import typer
+from typing import cast
+from pathlib import Path
+from dateutil import parser
+from typing_extensions import Annotated
+
+app = typer.Typer()
+
+@app.command('new')
+def new_model(name: str = typer.Option(..., help='Nombre del nuevo modelo.'), tablename: str = typer.Option(help='Nombre de la tabla', default='same-model-name')):
+    config = load_config()
+    name = camel_case(name)
+    tablename = camel_case(name if tablename == 'same-model-name' else tablename)
+    models_folder_path = Path(config.project.folders.models)
+
+    validate_path_not_exist(path=models_folder_path.joinpath(f'{name}.py'), custom_error_message=f'Ya existe un modelo con nombre: {name}')
+    __generate_full_model_config(config, name, tablename)
+
+    typer.echo(f'{name} se agrego correctamente!', color=typer.colors.GREEN)
+
+
+
+@app.command('fromJson')
+def new_from_json(
+        name: str = typer.Option(..., help='Nombre del archivo JSON a leer. Sin extension'),
+        tablename: str = typer.Option(help='Nombre de la tabla', default='same-model-name')
+    ):
+    """
+    Crea un nuevo modelo de acuerdo con el nombre especificado y el archivo en la ruta "./.spa/templates/json"
+    """
+    config = load_config()
+    try:
+        project_config = read_project_config()
+    except:
+        typer.echo('No se puedo leer la configuracion del proyecto', color=typer.colors.RED)
+        raise typer.Abort()
+    name = camel_case(name)
+    tablename = camel_case(name if tablename == 'same-model-name' else tablename)
+    json_folder_path = Path(config.project.folders.jsons)
+    validate_path_exist(path=json_folder_path.joinpath(f'{name.lower()}.json'), custom_error_message=f'No se pudo encontrar el archivo {name.lower()}.json')
+
+    try:
+        model_map = cast(dict, json.loads(json_folder_path.joinpath(f'{name.lower()}.json').read_text()))
+    except Exception as e:
+        typer.echo('No se pudo leer el json correctamente', typer.colors.RED)
+        typer.Abort()
+
+    __generate_full_model_config(config, name, tablename)
+
+    full_column_text = ''
+    full_propmap_text = ''
+    full_display_member = ''
+    for key in model_map.keys():
+        if isinstance(model_map[key], Constants.VALID_MODEL_TYPES.value):
+            key_type = type(model_map[key]).__name__
+
+            if key_type == Constants.JSON_STRING_DTYPE.value:
+                try:
+                    is_date = bool(parser.parse(model_map[key]))
+                    if is_date:
+                        key_type = Constants.JSON_DATETIME_DTYPE.value
+                except ValueError:
+                    # 'String is not datetime format'
+                    pass
+
+            data_column_line_text = f"""
+    {key} = {JSON_MAPPING_VALUE[key_type].format(**{'ColumnName': camel_case(key)})}"""
+            #here replace
+            if key_type == Constants.JSON_STRING_DTYPE.value:
+                if project_config['dbDialect'] == Constants.MYSQL_ENGINE.value:
+                    data_column_line_text = data_column_line_text.replace('String', 'String(512)')
+            full_column_text += data_column_line_text
+            full_propmap_text += f""",
+            "{key}": "{camel_case(key)}\""""
+            full_display_member += f""",
+            "{key}\""""
+    
+    models_folder_path = Path(config.project.folders.models)
+    model_text = models_folder_path.joinpath(f'{name}.py').read_text()
+    search_text_id = f'id = Column("Id{name}", Integer, primary_key=True)'
+    search_text_propmap = f"""def property_map(self) -> Dict:
+        return """ + '{' + f"""
+            "id": "Id{name}\""""
+    search_text_display = """def display_members(cls_) -> List[str]:
+        return [
+            "id\""""
+
+    search_id = model_text.index(search_text_id) + len(search_text_id)
+    search_propmap = model_text.index(search_text_propmap) + len(search_text_propmap)
+    search_display = model_text.index(search_text_display) + len(search_text_display)
+    
+    model_text = model_text[:search_id] \
+            + full_column_text \
+            + model_text[search_id:search_propmap] \
+            + full_propmap_text \
+            + model_text[search_propmap:search_display] \
+            + full_display_member \
+            + model_text[search_display:]
+    models_folder_path.joinpath(f'{name}.py').write_text(model_text)
+
+
+    typer.echo(f'{name} se agrego correctamente!', color=typer.colors.GREEN)
+
+def __generate_full_model_config(config: Config, name: str, tablename: str):
+    models_folder_path = Path(config.project.folders.models)
+    template_model_path = Path(config.template.files.model)
+    add_code_to_module(template_model_path, models_folder_path, name, {'model_name': name, 'model_name_lower': name.lower(), 'table_name': tablename})
+    add_file_to_module(models_folder_path, name)
+    
+    service_template_path = Path(config.template.files.service)
+    service_folder_path = Path(config.project.folders.services)
+    add_code_to_module(service_template_path, service_folder_path, f"{name}Service", {'model_name': name})
+    add_file_to_module(service_folder_path, f"{name}Service")
+    
+    controller_template_path = Path(config.template.files.controller)
+    controller_folder_path = Path(config.project.folders.controllers)
+    add_code_to_module(controller_template_path, controller_folder_path, f"{name}Controller", {})
+    
+    routes_template_path = Path(config.template.files.endpoint)
+    routes_folder_path = Path(config.project.folders.endpoints)
+    add_code_to_module(routes_template_path, routes_folder_path, f"{name}Router", {'model_name': name, 'model_name_lower': name.lower()})
+    add_file_to_module(routes_folder_path, f"{name}Router", f"{name.lower()}_router")
+    
+    index_code = Path(config.project.folders.root).joinpath('__init__.py').read_text()
+
+    search_return = index_code.index('return app')
+
+    block_insert_code = f"""from .routes import {name.lower()}_router
+    app.register_blueprint({name.lower()}_router, url_prefix='/{name.lower()}')
+
+    """
+
+    index_code = index_code[:search_return] + block_insert_code + index_code[search_return:]
+    Path(config.project.folders.root).joinpath('__init__.py').write_text(index_code)