nsj-rest-lib2 0.0.2__py3-none-any.whl → 0.0.4__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

@@ -1,3 +1,4 @@
+import datetime
 import json
 import sys
 import threading
@@ -7,13 +8,16 @@ from nsj_rest_lib.settings import get_logger
 
 from nsj_rest_lib2.exception import MissingEntityConfigException
 from nsj_rest_lib2.redis_config import get_redis
-from nsj_rest_lib2.settings import ESCOPO_RESTLIB2
+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:
-    dto_class_name: str = ""
-    entity_class_name: str = ""
-    entity_hash: str = ""
+    def __init__(self):
+        self.dto_class_name: str = ""
+        self.entity_class_name: str = ""
+        self.entity_hash: str = ""
+        self.loaded_at: datetime.datetime = datetime.datetime.now()
 
 
 class Namespace:
@@ -24,7 +28,7 @@ class Namespace:
         self.module: types.ModuleType = None
 
 
-namespaces_dict = {}
+namespaces_dict: dict[str, Namespace] = {}
 
 
 class EntityLoader:
@@ -48,34 +52,51 @@ class EntityLoader:
 
         # Se conseguiu carregar da memória, verifica se houve alteração no hash, em relação ao redis
         if result is not None:
-            # Desempacotando o result
-            dto_class_name, entity_class_name, entities_dict, entity_config_key = result
+            # Desempacotando o result e recuperando informações do namespace
+            (
+                entity_config_key,
+                namespace,
+            ) = result
 
-            # Recuperando do Redis direto pela key (faz uma só chamada ao redis)
-            loaded_config = self._load_entity_config_from_redis(
-                entity_id, grupo_key, tenant_key, default_key, entity_config_key
-            )
+            loaded_entity = namespace.loaded_entities[entity_id]
+            dto_class_name = loaded_entity.dto_class_name
+            entity_class_name = loaded_entity.entity_class_name
+            entities_dict = namespace.entities_dict
 
-            # Se não achar no redis, usa o que estava em memória
-            if not loaded_config:
-                return (dto_class_name, entity_class_name, entities_dict)
+            # Se o tempo entre o carregamento e agora for maior do que MIN_TIME_SOURCE_REFRESH minutos,
+            # verifica se precisa de refresh
+            time_diff = datetime.datetime.now() - loaded_entity.loaded_at
 
-            # Desempacotando resultado
-            entity_config_key, entity_config_str = loaded_config
+            if time_diff.total_seconds() >= MIN_TIME_SOURCE_REFRESH * 60:
+                # Recuperando do Redis direto pela key (faz uma só chamada ao redis)
+                loaded_config = self._load_entity_config_from_redis(
+                    entity_id, grupo_key, tenant_key, default_key, entity_config_key
+                )
 
-            # Executando o código da entidade, só se houver mudança no hash
-            result_execute = self._execute_entity_source(
-                entity_config_str,
-                entity_config_key,
-                entity_id,
-                check_refresh=True,
-            )
+                # Se não achar no redis, usa o que estava em memória
+                if not loaded_config:
+                    return (dto_class_name, entity_class_name, entities_dict)
 
-            if result_execute is None:
-                return (dto_class_name, entity_class_name, entities_dict)
+                # Desempacotando resultado
+                entity_config_key, entity_config_str = loaded_config
+
+                # Executando o código da entidade, só se houver mudança no hash
+                result_execute = self._execute_entity_source(
+                    entity_config_str,
+                    entity_config_key,
+                    entity_id,
+                    check_refresh=True,
+                )
+
+                # Se não carregou novo código, usa o que estava em memória
+                if result_execute is None:
+                    return (dto_class_name, entity_class_name, entities_dict)
+                else:
+                    dto_class_name, entity_class_name, namespace = result_execute
+                    return (dto_class_name, entity_class_name, namespace.entities_dict)
             else:
-                dto_class_name, entity_class_name, namespace = result_execute
-                return (dto_class_name, entity_class_name, namespace.entities_dict)
+                # Se não deu o intervalo de verificação do refresh, retorna o que está em memória
+                return (dto_class_name, entity_class_name, entities_dict)
 
         # Se não conseguir recuperar a entidade, procura no redis:
         loaded_config = self._load_entity_config_from_redis(
@@ -236,7 +257,7 @@ class EntityLoader:
         grupo_key: str,
         tenant_key: str,
         default_key: str,
-    ) -> tuple[str, str, dict, str] | None:
+    ) -> tuple[str, Namespace] | None:
         namespace = None
         entity_config_key = None
 
@@ -258,11 +279,7 @@ class EntityLoader:
             entity_config_key = default_key
             namespace = default_namespace
 
-        if namespace:
-            loaded_entity = namespace.loaded_entities[entity_id]
-            dto_class_name = loaded_entity.dto_class_name
-            entity_class_name = loaded_entity.entity_class_name
-            entities_dict = namespace.entities_dict
-            return (dto_class_name, entity_class_name, entities_dict, entity_config_key)
+        if namespace and entity_config_key:
+            return (entity_config_key, namespace)
         else:
             return None

nsj_rest_lib2/settings.py

@@ -1,3 +1,16 @@
+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()
+
+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.2.dist-info → nsj_rest_lib2-0.0.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nsj_rest_lib2
-Version: 0.0.2
+Version: 0.0.4
 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

nsj_rest_lib2-0.0.4.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=Zo9gMaUaHhiGS-5lm0hHSdTn4wRW89OV_xrQPxlezOI,9945
+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.4.dist-info/METADATA,sha256=WUKrR5K1gPeEDjFP0WP_lhb5gDBlyHdPfW0Hnnk_zy8,1196
+nsj_rest_lib2-0.0.4.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+nsj_rest_lib2-0.0.4.dist-info/top_level.txt,sha256=L6zh0EfH8_rur7OJ8_V-El-XEMf4qg3bkF8ADgqLVIA,14
+nsj_rest_lib2-0.0.4.dist-info/RECORD,,

nsj_rest_lib2-0.0.2.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=F6y6lOAdLhGzZA6NE01x3t1vSAvrm1pC9ImjLhe61IU,59
-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=i7ljsgDV4jlG-Flq5u-gmMqJp7SnpNfMRX1MYunln0E,9771
-nsj_rest_lib2-0.0.2.dist-info/METADATA,sha256=Z5cHSoCY_AfI8ax7hxGufv236q5ffK6Nbjrw_4RD5bg,1196
-nsj_rest_lib2-0.0.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-nsj_rest_lib2-0.0.2.dist-info/top_level.txt,sha256=L6zh0EfH8_rur7OJ8_V-El-XEMf4qg3bkF8ADgqLVIA,14
-nsj_rest_lib2-0.0.2.dist-info/RECORD,,