nsj-rest-lib2 0.0.3__py3-none-any.whl → 0.0.5__py3-none-any.whl

nsj_rest_lib2/compiler/property_compiler.py

@@ -0,0 +1,359 @@
+import ast
+
+from nsj_rest_lib2.compiler.compiler_structures import (
+    IndexCompilerStructure,
+    PropertiesCompilerStructure,
+)
+from nsj_rest_lib2.compiler.edl_model.entity_model import EntityModel
+from nsj_rest_lib2.compiler.edl_model.primitives import PrimitiveTypes
+from nsj_rest_lib2.compiler.edl_model.property_meta_model import PropertyMetaModel
+from nsj_rest_lib2.compiler.util.str_util import CompilerStrUtil
+from nsj_rest_lib2.compiler.util.type_util import TypeUtil
+
+# TODO pattern
+# TODO lowercase
+# TODO uppercase
+# TODO Adicionar o nome da entidade, no nome das classes de enum (para evitar conflitos no caso das traits)
+
+
+class EDLPropertyCompiler:
+    def compile(
+        self,
+        properties_structure: PropertiesCompilerStructure,
+        map_unique_by_property: dict[str, IndexCompilerStructure],
+        entity_model: EntityModel,
+    ) -> tuple[list[ast.stmt], list[ast.stmt], list[str], list[ast.stmt]]:
+
+        # TODO Criar opção de campo calculado?
+
+        ast_dto_attributes = []
+        ast_entity_attributes = []
+        props_pk = []
+        enum_classes = []
+
+        if properties_structure.properties is None:
+            return (ast_dto_attributes, ast_entity_attributes, props_pk, enum_classes)
+
+        for pkey in properties_structure.properties:
+            prop = properties_structure.properties[pkey]
+            enum_class_name = None
+
+            # DTO
+            ## Tratando propriedade simples (não array, não object)
+            if prop.type not in [PrimitiveTypes.ARRAY, PrimitiveTypes.OBJECT]:
+                keywords = []
+
+                if prop.pk:
+                    keywords.append(ast.keyword(arg="pk", value=ast.Constant(True)))
+                    props_pk.append(pkey)
+
+                if prop.key_alternative:
+                    keywords.append(
+                        ast.keyword(arg="candidate_key", value=ast.Constant(True))
+                    )
+
+                if (
+                    properties_structure.main_properties
+                    and pkey in properties_structure.main_properties
+                ):
+                    keywords.append(ast.keyword(arg="resume", value=ast.Constant(True)))
+
+                if (
+                    properties_structure.required
+                    and pkey in properties_structure.required
+                ):
+                    keywords.append(
+                        ast.keyword(arg="not_null", value=ast.Constant(True))
+                    )
+
+                if (
+                    properties_structure.partition_data
+                    and pkey in properties_structure.partition_data
+                ):
+                    keywords.append(
+                        ast.keyword(arg="partition_data", value=ast.Constant(True))
+                    )
+
+                if pkey in map_unique_by_property:
+                    unique = map_unique_by_property[pkey].index_model
+                    keywords.append(
+                        ast.keyword(
+                            arg="unique",
+                            value=ast.Constant(unique.name),
+                        )
+                    )
+
+                if (
+                    prop.default
+                ):  # TODO Verificar esse modo de tratar valores default (principalmente expressões)
+                    keywords.append(
+                        ast.keyword(
+                            arg="default_value",
+                            value=ast.Name(str(prop.default), ctx=ast.Load()),
+                        )
+                    )
+
+                if prop.trim:
+                    keywords.append(ast.keyword(arg="strip", value=ast.Constant(True)))
+
+                max = None
+                min = None
+                if prop.type in [PrimitiveTypes.STRING, PrimitiveTypes.EMAIL]:
+                    if prop.max_length:
+                        max = prop.max_length
+                    elif prop.min_length:
+                        min = prop.min_length
+                elif prop.type in [PrimitiveTypes.INTEGER, PrimitiveTypes.NUMBER]:
+                    if prop.minimum:
+                        min = prop.minimum
+                    elif prop.maximum:
+                        max = prop.maximum
+
+                if max:
+                    keywords.append(
+                        ast.keyword(arg="max", value=ast.Constant(prop.max_length))
+                    )
+                if min:
+                    keywords.append(
+                        ast.keyword(arg="min", value=ast.Constant(prop.min_length))
+                    )
+
+                if (
+                    properties_structure.search_properties
+                    and pkey in properties_structure.search_properties
+                ):
+                    keywords.append(ast.keyword(arg="search", value=ast.Constant(True)))
+                else:
+                    keywords.append(
+                        ast.keyword(arg="search", value=ast.Constant(False))
+                    )
+
+                if (
+                    properties_structure.metric_label
+                    and pkey in properties_structure.metric_label
+                ):
+                    keywords.append(
+                        ast.keyword(arg="metric_label", value=ast.Constant(True))
+                    )
+
+                if prop.type == PrimitiveTypes.CPF and not prop.validator:
+                    keywords.append(
+                        ast.keyword(
+                            arg="validator",
+                            value=ast.Attribute(
+                                value=ast.Call(
+                                    func=ast.Name(
+                                        id="DTOFieldValidators", ctx=ast.Load()
+                                    ),
+                                    args=[],
+                                    keywords=[],
+                                ),
+                                attr="validate_cpf",
+                                ctx=ast.Load(),
+                            ),
+                        )
+                    )
+                elif prop.type == PrimitiveTypes.CNPJ and not prop.validator:
+                    keywords.append(
+                        ast.keyword(
+                            arg="validator",
+                            value=ast.Attribute(
+                                value=ast.Call(
+                                    func=ast.Name(
+                                        id="DTOFieldValidators", ctx=ast.Load()
+                                    ),
+                                    args=[],
+                                    keywords=[],
+                                ),
+                                attr="validate_cnpj",
+                                ctx=ast.Load(),
+                            ),
+                        )
+                    )
+                elif prop.type == PrimitiveTypes.CPF_CNPJ and not prop.validator:
+                    keywords.append(
+                        ast.keyword(
+                            arg="validator",
+                            value=ast.Attribute(
+                                value=ast.Call(
+                                    func=ast.Name(
+                                        id="DTOFieldValidators", ctx=ast.Load()
+                                    ),
+                                    args=[],
+                                    keywords=[],
+                                ),
+                                attr="validate_cpf_or_cnpj",
+                                ctx=ast.Load(),
+                            ),
+                        )
+                    )
+                elif prop.type == PrimitiveTypes.EMAIL and not prop.validator:
+                    keywords.append(
+                        ast.keyword(
+                            arg="validator",
+                            value=ast.Attribute(
+                                value=ast.Call(
+                                    func=ast.Name(
+                                        id="DTOFieldValidators", ctx=ast.Load()
+                                    ),
+                                    args=[],
+                                    keywords=[],
+                                ),
+                                attr="validate_email",
+                                ctx=ast.Load(),
+                            ),
+                        )
+                    )
+                elif prop.validator:
+                    keywords.append(
+                        ast.keyword(
+                            arg="validator",
+                            value=ast.Name(prop.validator, ctx=ast.Load()),
+                        )
+                    )
+
+                if prop.immutable:
+                    keywords.append(
+                        ast.keyword(arg="read_only", value=ast.Constant(True))
+                    )
+
+                if prop.on_save:
+                    keywords.append(
+                        ast.keyword(
+                            arg="convert_to_entity",
+                            value=ast.Name(prop.on_save, ctx=ast.Load()),
+                        )
+                    )
+
+                if prop.on_retrieve:
+                    keywords.append(
+                        ast.keyword(
+                            arg="convert_from_entity",
+                            value=ast.Name(id=prop.on_retrieve, ctx=ast.Load()),
+                        )
+                    )
+
+                if prop.domain_config:
+                    result = self._compile_domain_config(pkey, prop, entity_model)
+                    if not result:
+                        raise Exception(
+                            f"Erro desconhecido ao compilar a propriedade {pkey}"
+                        )
+
+                    enum_class_name, ast_enum_class = result
+                    enum_classes.append(ast_enum_class)
+
+                # Instanciando o atributo AST
+                if enum_class_name:
+                    prop_type = enum_class_name
+                else:
+                    prop_type = TypeUtil.property_type_to_python_type(prop.type)
+
+                ast_attr = ast.AnnAssign(
+                    target=ast.Name(
+                        id=CompilerStrUtil.to_snake_case(pkey), ctx=ast.Store()
+                    ),
+                    annotation=ast.Name(
+                        id=prop_type,
+                        ctx=ast.Load(),
+                    ),
+                    value=ast.Call(
+                        func=ast.Name(id="DTOField", ctx=ast.Load()),
+                        args=[],
+                        keywords=keywords,
+                    ),
+                    simple=1,
+                )
+
+                ast_dto_attributes.append(ast_attr)
+
+                # Entity
+                if (
+                    properties_structure.entity_properties
+                    and pkey in properties_structure.entity_properties
+                ):
+                    entity_field_name = properties_structure.entity_properties[
+                        pkey
+                    ].column
+                else:
+                    entity_field_name = pkey
+
+                ast_entity_attr = ast.AnnAssign(
+                    target=ast.Name(
+                        id=CompilerStrUtil.to_snake_case(entity_field_name),
+                        ctx=ast.Store(),
+                    ),
+                    annotation=ast.Name(
+                        id=TypeUtil.property_type_to_python_type(prop.type),
+                        ctx=ast.Load(),
+                    ),
+                    value=ast.Constant(value=None),
+                    simple=1,
+                )
+
+                ast_entity_attributes.append(ast_entity_attr)
+
+        return ast_dto_attributes, ast_entity_attributes, props_pk, enum_classes
+
+    def _compile_domain_config(
+        self,
+        pkey: str,
+        prop: PropertyMetaModel,
+        entity_model: EntityModel,
+    ) -> tuple[str, ast.stmt] | None:
+        if not prop.domain_config:
+            return None
+
+        # Verificando se deveria usar o mapped_value
+        use_mapped_value = False
+        for value in prop.domain_config:
+            if value.mapped_value:
+                use_mapped_value = True
+                break
+
+        # Compilando as opções do enum
+        ast_values = []
+        for value in prop.domain_config:
+            value_name = CompilerStrUtil.to_snake_case(value.value).upper()
+
+            if use_mapped_value and value.mapped_value is None:
+                raise Exception(
+                    f"Propriedade '{pkey}' possui domain_config com value '{value.value}' mas sem mapped_value"
+                )
+
+            if value.mapped_value is not None:
+                ast_value = ast.Assign(
+                    targets=[ast.Name(id=value_name, ctx=ast.Store())],
+                    value=ast.Tuple(
+                        elts=[
+                            ast.Constant(value=value.value),
+                            ast.Constant(value=value.mapped_value),
+                        ],
+                        ctx=ast.Load(),
+                    ),
+                )
+            else:
+                ast_value = ast.Assign(
+                    targets=[ast.Name(id=value_name, ctx=ast.Store())],
+                    value=ast.Constant(value=value.value),
+                )
+
+            ast_values.append(ast_value)
+
+        # Instanciando o atributo AST
+        enum_class_name = f"{CompilerStrUtil.to_pascal_case(entity_model.escopo)}{CompilerStrUtil.to_pascal_case(entity_model.id)}{CompilerStrUtil.to_pascal_case(pkey)}Enum"
+        ast_enum_class = ast.ClassDef(
+            name=enum_class_name,
+            bases=[
+                ast.Attribute(
+                    value=ast.Name(id="enum", ctx=ast.Load()),
+                    attr="Enum",
+                    ctx=ast.Load(),
+                )
+            ],
+            keywords=[],
+            decorator_list=[],
+            body=ast_values,
+        )
+
+        return enum_class_name, ast_enum_class

nsj_rest_lib2/service/entity_loader.py

@@ -11,6 +11,7 @@ from nsj_rest_lib2.redis_config import get_redis
 from nsj_rest_lib2.settings import ESCOPO_RESTLIB2, MIN_TIME_SOURCE_REFRESH
 
 
+# TODO Verificar se está atualizando o loaded_at, quando o hash não muda
 class LoadedEntity:
     def __init__(self):
         self.dto_class_name: str = ""

nsj_rest_lib2/settings.py

@@ -1,6 +1,8 @@
+import logging
 import os
 
 ESCOPO_RESTLIB2 = os.environ["ESCOPO_RESTLIB2"]
+APP_NAME = os.getenv("APP_NAME", "nsj_rest_lib2")
 
 ENV = os.getenv("ENV", "dev").lower()
 
@@ -8,3 +10,7 @@ if ENV in ("dev", "local"):
     MIN_TIME_SOURCE_REFRESH = 0
 else:
     MIN_TIME_SOURCE_REFRESH = int(os.getenv("MIN_TIME_SOURCE_REFRESH", "15"))
+
+
+def get_logger():
+    return logging.getLogger(APP_NAME)

{nsj_rest_lib2-0.0.3.dist-info → nsj_rest_lib2-0.0.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nsj_rest_lib2
-Version: 0.0.3
+Version: 0.0.5
 Summary: Biblioteca para permitir a distribuição de rotas dinâmicas numa API, configuradas por meio de EDLs declarativos (em formato JSON).
 Home-page: https://github.com/Nasajon/nsj_rest_lib2
 Author: Nasajon Sistemas
@@ -14,6 +14,9 @@ Requires-Python: >=3.4
 Description-Content-Type: text/markdown
 Requires-Dist: nsj-rest-lib<5.0.0,>=4.9.0
 Requires-Dist: redis<7.0.0,>=6.4.0
+Requires-Dist: nsj-multi-database-lib<3.0.0,>=2.0.1
+Requires-Dist: pydantic<3.0.0,>=2.11.9
+Requires-Dist: black<26.0.0,>=25.1.0
 
 # nsj_rest_lib2
 

nsj_rest_lib2-0.0.5.dist-info/RECORD

@@ -0,0 +1,29 @@
+nsj_rest_lib2/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+nsj_rest_lib2/exception.py,sha256=E9uMUdoCCQOVQfc8f6gD9b5Pxurf3Q4SytDCcqSlkZ8,56
+nsj_rest_lib2/redis_config.py,sha256=4KLcvYS3nJO7PMQgF6F9_j6r-TyqcS7TBbd3LEQuKDU,629
+nsj_rest_lib2/settings.py,sha256=Hn_o1HZmievnYb8D1kNT2Nq-OEjxbyNjOiOpbnFsMwE,367
+nsj_rest_lib2/compiler/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+nsj_rest_lib2/compiler/ai_compiler.py,sha256=shAtN4T0ai_52qh15L3mK1QbeC6glHOR6C3J3gj14II,9029
+nsj_rest_lib2/compiler/compiler.py,sha256=EX_ACseDkYd7CoRkqT7F_NjAd8NBB1PS1Nu9k_AKHug,10639
+nsj_rest_lib2/compiler/compiler_structures.py,sha256=2bM4_7lG1fytDGxJl6SU9pLsbspiNV36gVn9-O-23Q8,1009
+nsj_rest_lib2/compiler/dto_compiler.py,sha256=hVmy9WLBl8217zmNSBBTpmSmdzXU6NXy7TJym6eRd-Q,2615
+nsj_rest_lib2/compiler/entity_compiler.py,sha256=ytcS-RPQTJtf56z4HqT3xQLBYzbd6UUPGsaGB1pj_EA,4240
+nsj_rest_lib2/compiler/property_compiler.py,sha256=NwQd3hVypT7CYgy8rK506XTRaz5oxiWUtkZEpGyolRs,13969
+nsj_rest_lib2/compiler/edl_model/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+nsj_rest_lib2/compiler/edl_model/ai_entity_edl.py,sha256=664QBDcOgVnyfwtUOXO1W7AKaZhueBG335x5DuogruY,7644
+nsj_rest_lib2/compiler/edl_model/api_model.py,sha256=pH0Uiq_64AGvkHqwY44TrulWWZXbi6M0EKJWUhSqKj0,837
+nsj_rest_lib2/compiler/edl_model/column_meta_model.py,sha256=V1VI0LslSDO6oB2cOQrTcBijBnWIPL7s4xNbI2Wb8Kk,195
+nsj_rest_lib2/compiler/edl_model/entity_model.py,sha256=mn19nIuzDdzo7N2K4ElYwKpk8T9tb3pNU4CudkblblI,3375
+nsj_rest_lib2/compiler/edl_model/index_model.py,sha256=cXWlu0hxtro5vvYoirkDW4R3PCnBW5oCCWjRJ6AX5zE,508
+nsj_rest_lib2/compiler/edl_model/primitives.py,sha256=VAzTbpkQAZWkeTdpoXL4FSaO1KEMTPXOxl6WxIJMWHk,1104
+nsj_rest_lib2/compiler/edl_model/property_meta_model.py,sha256=i7lu-JFvPzUDBdsHB6kspGUyCkqf_GuTRmKfpIZj-K0,3444
+nsj_rest_lib2/compiler/edl_model/repository_model.py,sha256=Vt1HxlaoifP4w5ij1laKDkD1-COBihE8EX1HkdEDUSo,977
+nsj_rest_lib2/compiler/edl_model/trait_property_meta_model.py,sha256=NA8eRh5rA0boFmFd-0sHLrilOoOQSeN-amN_4TXcGiA,358
+nsj_rest_lib2/controller/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+nsj_rest_lib2/controller/dynamic_controller.py,sha256=4HS1__ton8cQ1LSvMoZUv93BQEnGV5f2gE-jW5lD510,13448
+nsj_rest_lib2/service/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+nsj_rest_lib2/service/entity_loader.py,sha256=E--DbswAMIn3Ic6LOMotRTcUN4PsArA9oSFAVzadnAQ,10713
+nsj_rest_lib2-0.0.5.dist-info/METADATA,sha256=JMlSA-H1FhzSjxR908UZCAMlG_ujjWb2A8BBN2KvHow,1324
+nsj_rest_lib2-0.0.5.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+nsj_rest_lib2-0.0.5.dist-info/top_level.txt,sha256=L6zh0EfH8_rur7OJ8_V-El-XEMf4qg3bkF8ADgqLVIA,14
+nsj_rest_lib2-0.0.5.dist-info/RECORD,,

nsj_rest_lib2-0.0.3.dist-info/RECORD

@@ -1,12 +0,0 @@
-nsj_rest_lib2/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-nsj_rest_lib2/exception.py,sha256=E9uMUdoCCQOVQfc8f6gD9b5Pxurf3Q4SytDCcqSlkZ8,56
-nsj_rest_lib2/redis_config.py,sha256=4KLcvYS3nJO7PMQgF6F9_j6r-TyqcS7TBbd3LEQuKDU,629
-nsj_rest_lib2/settings.py,sha256=f_jqFEv1rkhfEfyvCtTduUEwc4dwiiLnP00VM7gvWPw,243
-nsj_rest_lib2/controller/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-nsj_rest_lib2/controller/dynamic_controller.py,sha256=4HS1__ton8cQ1LSvMoZUv93BQEnGV5f2gE-jW5lD510,13448
-nsj_rest_lib2/service/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-nsj_rest_lib2/service/entity_loader.py,sha256=1_NhcO_7g7CWC3WTKHCYkblH2luO3AbPRyE2uCQ2zXw,10638
-nsj_rest_lib2-0.0.3.dist-info/METADATA,sha256=wkUs-y8kYkmSQYVt2pi4QHR28ECogJkjez3VcsGpcMY,1196
-nsj_rest_lib2-0.0.3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-nsj_rest_lib2-0.0.3.dist-info/top_level.txt,sha256=L6zh0EfH8_rur7OJ8_V-El-XEMf4qg3bkF8ADgqLVIA,14
-nsj_rest_lib2-0.0.3.dist-info/RECORD,,