nsj-rest-lib2 0.0.1__py3-none-any.whl

nsj_rest_lib2/controller/dynamic_controller.py

@@ -0,0 +1,300 @@
+import json
+
+from typing import Any
+
+from flask import Flask, request
+
+from nsj_rest_lib.settings import APP_NAME
+
+from nsj_gcf_utils.rest_error_util import format_json_error
+
+from nsj_multi_database_lib.decorator.multi_database import multi_database
+
+from nsj_rest_lib.controller.controller_util import DEFAULT_RESP_HEADERS
+from nsj_rest_lib.controller.list_route import ListRoute
+from nsj_rest_lib.controller.get_route import GetRoute
+from nsj_rest_lib.controller.post_route import PostRoute
+from nsj_rest_lib.controller.put_route import PutRoute
+from nsj_rest_lib.controller.patch_route import PatchRoute
+from nsj_rest_lib.controller.delete_route import DeleteRoute
+
+from nsj_rest_lib2.exception import MissingEntityConfigException
+from nsj_rest_lib2.service.entity_loader import EntityLoader
+
+
+def _get_tenant_grupo() -> tuple[str, str]:
+    # Tentando ler do query args
+    query_args = request.args
+    tenant = query_args.get("tenant")
+    grupo_empresarial = query_args.get("grupo_empresarial")
+
+    # Tentando ler do corpo da requisição
+    try:
+        body_str = request.data.decode("utf-8")
+        body_json = json.loads(body_str)
+
+        if not tenant:
+            tenant = body_json.get("tenant")
+        if not grupo_empresarial:
+            grupo_empresarial = body_json.get("grupo_empresarial")
+    except:
+        pass
+
+    return (str(tenant), str(grupo_empresarial))
+
+
+def _endpoint_name(func: Any, multidb: bool, root: str) -> str:
+    suffix = "_mb" if multidb else ""
+    return f"{root}_{func.__name__}{suffix}"
+
+
+def setup_dynamic_routes(
+    flask_app: Flask,
+    multidb: bool = True,
+    dynamic_root_path: str = "edl1",
+    injector_factory: Any = None,
+) -> None:
+
+    COLLECTION_DYNAMIC_ROUTE = f"/{APP_NAME}/{dynamic_root_path}/<entity_id>"
+    ONE_DYNAMIC_ROUTE = f"/{APP_NAME}/{dynamic_root_path}/<entity_id>/<id>"
+
+    def list_dynamic_wrapper(injector_factory: Any, *args: Any, **kwargs: Any) -> Any:
+
+        def list_dynamic(*args: Any, **kwargs: Any):
+            # Recuperando o identificador da entidade
+            if "entity_id" not in kwargs:
+                msg = "Faltando parâmetro identificador da entidade na URL."
+                return (format_json_error(msg), 400, {**DEFAULT_RESP_HEADERS})
+            entity_id = kwargs.pop("entity_id")
+
+            # Lendo tenant e grupo_empresarial
+            tenant, grupo_empresarial = _get_tenant_grupo()
+
+            try:
+                # Recuperando o código do DTO e Entity correspondente
+                entity_loader = EntityLoader()
+                dto_class_name, entity_class_name, etities_dict = (
+                    entity_loader.load_entity_source(
+                        entity_id, tenant, grupo_empresarial
+                    )
+                )
+
+                # Executando o list pelo RestLib
+                route = ListRoute(
+                    url=COLLECTION_DYNAMIC_ROUTE,
+                    http_method="GET",
+                    dto_class=etities_dict[dto_class_name],
+                    entity_class=etities_dict[entity_class_name],
+                    injector_factory=injector_factory,
+                )
+
+                return route.handle_request(*args, **kwargs)
+            except MissingEntityConfigException:
+                msg = f"Entity configuration for {entity_id} not found."
+                return (format_json_error(msg), 412, {**DEFAULT_RESP_HEADERS})
+
+        return list_dynamic
+
+    def get_dynamic(*args: Any, **kwargs: Any):
+        # Recuperando o identificador da entidade
+        if "entity_id" not in kwargs:
+            msg = "Faltando parâmetro identificador da entidade na URL."
+            return (format_json_error(msg), 400, {**DEFAULT_RESP_HEADERS})
+        entity_id = kwargs.pop("entity_id")
+
+        # Lendo tenant e grupo_empresarial
+        tenant, grupo_empresarial = _get_tenant_grupo()
+
+        try:
+            # Recuperando o código do DTO e Entity correspondente
+            entity_loader = EntityLoader()
+            dto_class_name, entity_class_name, etities_dict = (
+                entity_loader.load_entity_source(entity_id, tenant, grupo_empresarial)
+            )
+
+            # Executando o list pelo RestLib
+            route = GetRoute(
+                url=ONE_DYNAMIC_ROUTE,
+                http_method="GET",
+                dto_class=etities_dict[dto_class_name],
+                entity_class=etities_dict[entity_class_name],
+            )
+
+            return route.handle_request(*args, **kwargs)
+        except MissingEntityConfigException:
+            msg = f"Entity configuration for {entity_id} not found."
+            return (format_json_error(msg), 412, {**DEFAULT_RESP_HEADERS})
+
+    def post_dynamic(*args: Any, **kwargs: Any):
+        # Recuperando o identificador da entidade
+        if "entity_id" not in kwargs:
+            msg = "Faltando parâmetro identificador da entidade na URL."
+            return (format_json_error(msg), 400, {**DEFAULT_RESP_HEADERS})
+        entity_id = kwargs.pop("entity_id")
+
+        # Lendo tenant e grupo_empresarial
+        tenant, grupo_empresarial = _get_tenant_grupo()
+
+        try:
+            # Recuperando o código do DTO e Entity correspondente
+            entity_loader = EntityLoader()
+            dto_class_name, entity_class_name, etities_dict = (
+                entity_loader.load_entity_source(entity_id, tenant, grupo_empresarial)
+            )
+
+            # Executando o list pelo RestLib
+            route = PostRoute(
+                url=COLLECTION_DYNAMIC_ROUTE,
+                http_method="POST",
+                dto_class=etities_dict[dto_class_name],
+                entity_class=etities_dict[entity_class_name],
+            )
+
+            return route.handle_request(*args, **kwargs)
+        except MissingEntityConfigException:
+            msg = f"Entity configuration for {entity_id} not found."
+            return (format_json_error(msg), 412, {**DEFAULT_RESP_HEADERS})
+
+    def put_dynamic(*args: Any, **kwargs: Any):
+        # Recuperando o identificador da entidade
+        if "entity_id" not in kwargs:
+            msg = "Faltando parâmetro identificador da entidade na URL."
+            return (format_json_error(msg), 400, {**DEFAULT_RESP_HEADERS})
+        entity_id = kwargs.pop("entity_id")
+
+        # Lendo tenant e grupo_empresarial
+        tenant, grupo_empresarial = _get_tenant_grupo()
+
+        try:
+            # Recuperando o código do DTO e Entity correspondente
+            entity_loader = EntityLoader()
+            dto_class_name, entity_class_name, etities_dict = (
+                entity_loader.load_entity_source(entity_id, tenant, grupo_empresarial)
+            )
+
+            # Executando o list pelo RestLib
+            route = PutRoute(
+                url=ONE_DYNAMIC_ROUTE,
+                http_method="PUT",
+                dto_class=etities_dict[dto_class_name],
+                entity_class=etities_dict[entity_class_name],
+            )
+
+            return route.handle_request(*args, **kwargs)
+        except MissingEntityConfigException:
+            msg = f"Entity configuration for {entity_id} not found."
+            return (format_json_error(msg), 412, {**DEFAULT_RESP_HEADERS})
+
+    def patch_dynamic(*args: Any, **kwargs: Any):
+        # Recuperando o identificador da entidade
+        if "entity_id" not in kwargs:
+            msg = "Faltando parâmetro identificador da entidade na URL."
+            return (format_json_error(msg), 400, {**DEFAULT_RESP_HEADERS})
+        entity_id = kwargs.pop("entity_id")
+
+        # Lendo tenant e grupo_empresarial
+        tenant, grupo_empresarial = _get_tenant_grupo()
+
+        try:
+            # Recuperando o código do DTO e Entity correspondente
+            entity_loader = EntityLoader()
+            dto_class_name, entity_class_name, etities_dict = (
+                entity_loader.load_entity_source(entity_id, tenant, grupo_empresarial)
+            )
+
+            # Executando o list pelo RestLib
+            route = PatchRoute(
+                url=ONE_DYNAMIC_ROUTE,
+                http_method="PATCH",
+                dto_class=etities_dict[dto_class_name],
+                entity_class=etities_dict[entity_class_name],
+            )
+
+            return route.handle_request(*args, **kwargs)
+        except MissingEntityConfigException:
+            msg = f"Entity configuration for {entity_id} not found."
+            return (format_json_error(msg), 412, {**DEFAULT_RESP_HEADERS})
+
+    def delete_dynamic(*args: Any, **kwargs: Any):
+        # Recuperando o identificador da entidade
+        if "entity_id" not in kwargs:
+            msg = "Faltando parâmetro identificador da entidade na URL."
+            return (format_json_error(msg), 400, {**DEFAULT_RESP_HEADERS})
+        entity_id = kwargs.pop("entity_id")
+
+        # Lendo tenant e grupo_empresarial
+        tenant, grupo_empresarial = _get_tenant_grupo()
+
+        try:
+            # Recuperando o código do DTO e Entity correspondente
+            entity_loader = EntityLoader()
+            dto_class_name, entity_class_name, etities_dict = (
+                entity_loader.load_entity_source(entity_id, tenant, grupo_empresarial)
+            )
+
+            # Executando o list pelo RestLib
+            route = DeleteRoute(
+                url=ONE_DYNAMIC_ROUTE,
+                http_method="DELETE",
+                dto_class=etities_dict[dto_class_name],
+                entity_class=etities_dict[entity_class_name],
+            )
+
+            return route.handle_request(*args, **kwargs)
+        except MissingEntityConfigException:
+            msg = f"Entity configuration for {entity_id} not found."
+            return (format_json_error(msg), 412, {**DEFAULT_RESP_HEADERS})
+
+    # Ajustando para o padrão com multi database (se necessário)
+    if multidb:
+        list_dynamic = multi_database()(list_dynamic_wrapper(injector_factory))
+        get_dynamic = multi_database()(get_dynamic)
+        post_dynamic = multi_database()(post_dynamic)
+        put_dynamic = multi_database()(put_dynamic)
+        patch_dynamic = multi_database()(patch_dynamic)
+        delete_dynamic = multi_database()(delete_dynamic)
+    else:
+        list_dynamic = list_dynamic_wrapper(injector_factory)
+        get_dynamic = get_dynamic
+        post_dynamic = post_dynamic
+        put_dynamic = put_dynamic
+        patch_dynamic = patch_dynamic
+        delete_dynamic = delete_dynamic
+
+    # Registrando as rotas no flask
+    flask_app.add_url_rule(
+        COLLECTION_DYNAMIC_ROUTE,
+        endpoint=_endpoint_name(list_dynamic, multidb, dynamic_root_path),
+        view_func=list_dynamic,
+        methods=["GET"],
+    )
+    flask_app.add_url_rule(
+        ONE_DYNAMIC_ROUTE,
+        endpoint=_endpoint_name(get_dynamic, multidb, dynamic_root_path),
+        view_func=get_dynamic,
+        methods=["GET"],
+    )
+    flask_app.add_url_rule(
+        COLLECTION_DYNAMIC_ROUTE,
+        endpoint=_endpoint_name(post_dynamic, multidb, dynamic_root_path),
+        view_func=post_dynamic,
+        methods=["POST"],
+    )
+    flask_app.add_url_rule(
+        ONE_DYNAMIC_ROUTE,
+        endpoint=_endpoint_name(put_dynamic, multidb, dynamic_root_path),
+        view_func=put_dynamic,
+        methods=["PUT"],
+    )
+    flask_app.add_url_rule(
+        ONE_DYNAMIC_ROUTE,
+        endpoint=_endpoint_name(patch_dynamic, multidb, dynamic_root_path),
+        view_func=patch_dynamic,
+        methods=["PATCH"],
+    )
+    flask_app.add_url_rule(
+        ONE_DYNAMIC_ROUTE,
+        endpoint=_endpoint_name(delete_dynamic, multidb, dynamic_root_path),
+        view_func=delete_dynamic,
+        methods=["DELETE"],
+    )

nsj_rest_lib2/exception.py

@@ -0,0 +1,2 @@
+class MissingEntityConfigException(Exception):
+    pass

nsj_rest_lib2/redis_config.py

@@ -0,0 +1,31 @@
+import os
+import redis
+
+from typing import Any
+
+REDIS_HOST = os.environ["REDIS_HOST"]
+REDIS_PORT = int(os.environ["REDIS_PORT"])
+REDIS_DB = int(os.getenv("REDIS_DB", 0))
+
+redis_client = redis.Redis(host=REDIS_HOST, port=REDIS_PORT, db=REDIS_DB)
+
+
+def k(*parts: str) -> str:
+    return ":".join(parts)
+
+
+def get_redis(*args: str) -> Any:
+    value = redis_client.get(k(*args))
+    if value:
+        return value.decode("utf-8")
+    return None
+
+
+def set_redis(*args) -> None:
+    value = args[-1]
+    redis_client.set(k(*args[:-1]), value)
+
+
+if __name__ == "__main__":
+    set_redis("ping", "pong")
+    print(get_redis(("ping")))

nsj_rest_lib2/service/entity_loader.py

@@ -0,0 +1,268 @@
+import json
+import sys
+import threading
+import types
+
+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
+
+
+class LoadedEntity:
+    dto_class_name: str = ""
+    entity_class_name: str = ""
+    entity_hash: str = ""
+
+
+class Namespace:
+    def __init__(self):
+        self.key: str = ""
+        self.loaded_entities: dict[str, LoadedEntity] = {}
+        self.entities_dict: dict = None
+        self.module: types.ModuleType = None
+
+
+namespaces_dict = {}
+
+
+class EntityLoader:
+    def __init__(self) -> types.NoneType:
+        self._lock = threading.Lock()
+
+    def load_entity_source(
+        self,
+        entity_id: str,
+        tenant: str | None,
+        grupo_empresarial: str | None,
+    ) -> tuple[str, str, dict]:
+        # Montando as chaves dos namespaces
+        grupo_key = f"tenant_{tenant}.ge_{grupo_empresarial}"
+        tenant_key = f"tenant_{tenant}"
+        default_key = "default"
+
+        result = self._load_entity_source_from_memory(
+            entity_id, grupo_key, tenant_key, default_key
+        )
+
+        # 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
+
+            # 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
+            )
+
+            # 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)
+
+            # 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,
+            )
+
+            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)
+
+        # Se não conseguir recuperar a entidade, procura no redis:
+        loaded_config = self._load_entity_config_from_redis(
+            entity_id, grupo_key, tenant_key, default_key, None
+        )
+
+        # Se também não achar no redis, lanca exceção
+        if not loaded_config:
+            raise MissingEntityConfigException()
+
+        # Desempacotando resultado
+        entity_config_key, entity_config_str = loaded_config
+
+        # Executando o código da entidade
+        result_execute = self._execute_entity_source(
+            entity_config_str, entity_config_key, entity_id
+        )
+
+        if result_execute is None:
+            raise RuntimeError(f"Erro desconhecido carregando entidade: {entity_id}")
+        dto_class_name, entity_class_name, namespace = result_execute
+
+        return (dto_class_name, entity_class_name, namespace.entities_dict)
+
+    def clear_namespaces(self):
+        """
+        Clears all loaded namespaces from memory.
+
+        This method removes all entries from the namespaces_dict, effectively resetting
+        the in-memory cache of loaded entities and their associated namespaces.
+        """
+        with self._lock:
+            namespaces_dict.clear()
+
+    def _execute_entity_source(
+        self,
+        entity_config_str: str,
+        entity_config_key: str,
+        entity_id: str,
+        check_refresh: bool = False,
+    ) -> tuple[str, str, Namespace] | None:
+        # Interpretando o json de configuração da entidade
+        try:
+            entity_config = json.loads(entity_config_str)
+
+            dto_class_name = entity_config["dto_class_name"]
+            entity_class_name = entity_config["entity_class_name"]
+            source_dto = entity_config["source_dto"]
+            source_entity = entity_config["source_entity"]
+            entity_hash = entity_config["entity_hash"]
+        except json.JSONDecodeError as e:
+            if not check_refresh:
+                raise RuntimeError(
+                    f"Erro ao decodificar JSON da entidade {entity_id}; na chave {entity_config_key}: {e}"
+                )
+            else:
+                get_logger().error(
+                    f"Erro ao decodificar JSON da entidade {entity_id}; na chave {entity_config_key}: {e}"
+                )
+                return None
+
+        # Verificando se a entidade precisa ou não de refresh
+        if check_refresh:
+            loaded_namespace = namespaces_dict.get(entity_config_key)
+            if not loaded_namespace:
+                return None
+
+            loaded_entity = loaded_namespace.loaded_entities.get(entity_id)
+            if not loaded_entity:
+                return None
+
+            if loaded_entity.entity_hash == entity_hash:
+                return None
+
+        # Imprimindo alerta de load no log
+        get_logger().debug(
+            f"Carregando entidade {entity_id} no namespace {entity_config_key}."
+        )
+
+        # Carregando a entidade no namespace
+        with self._lock:
+            namespace = namespaces_dict.get(entity_config_key)
+            if namespace is None:
+                namespace = Namespace()
+                namespace.key = entity_config_key
+                namespaces_dict[entity_config_key] = namespace
+
+            # Executando o código da entidade
+            module = types.ModuleType(entity_config_key)
+            sys.modules[entity_config_key] = module
+            module.__dict__["__builtins__"] = __builtins__
+
+            namespace.module = module
+            namespace.entities_dict = module.__dict__
+
+            self._safe_exec(source_dto, namespace.entities_dict, "DTO source")
+            self._safe_exec(source_entity, namespace.entities_dict, "Entity source")
+
+            # Gravando a entidade no dict de entidades carregadas
+            loaded_entity = LoadedEntity()
+            loaded_entity.dto_class_name = dto_class_name
+            loaded_entity.entity_class_name = entity_class_name
+            loaded_entity.entity_hash = entity_hash
+
+            namespace.loaded_entities[entity_id] = loaded_entity
+
+        return (dto_class_name, entity_class_name, namespace)
+
+    def _safe_exec(self, source_code, context, description):
+        try:
+            exec(source_code, context)
+        except Exception as e:
+            get_logger().error(f"Error executing {description}: {e}")
+            raise
+
+    def _load_entity_config_from_redis(
+        self,
+        entity_id: str,
+        grupo_key: str,
+        tenant_key: str,
+        default_key: str,
+        entity_config_key: str | None,
+    ) -> tuple[str, str] | None:
+        get_logger().debug(
+            f"Procurando a configuração da entidade {entity_id} no redis"
+        )
+
+        if entity_config_key is not None:
+            entity_config_str = get_redis(
+                "entity_config", ESCOPO_RESTLIB2, entity_config_key, entity_id
+            )
+
+        else:
+            entity_config_key = grupo_key
+            entity_config_str = get_redis(
+                "entity_config", ESCOPO_RESTLIB2, grupo_key, entity_id
+            )
+            if entity_config_str is None:
+                entity_config_key = tenant_key
+                entity_config_str = get_redis(
+                    "entity_config", ESCOPO_RESTLIB2, tenant_key, entity_id
+                )
+            if entity_config_str is None:
+                entity_config_key = default_key
+                entity_config_str = get_redis(
+                    "entity_config", ESCOPO_RESTLIB2, default_key, entity_id
+                )
+
+        # Se não encontrar no redis, retorna None
+        if entity_config_str is None:
+            return None
+
+        return (entity_config_key, entity_config_str)
+
+    def _load_entity_source_from_memory(
+        self,
+        entity_id: str,
+        grupo_key: str,
+        tenant_key: str,
+        default_key: str,
+    ) -> tuple[str, str, dict, str] | None:
+        namespace = None
+        entity_config_key = None
+
+        # Pesquisando a entidade no namespace mais específico (grupo_empresarial)
+        grupo_namespace = namespaces_dict.get(grupo_key)
+        if grupo_namespace and entity_id in grupo_namespace.loaded_entities:
+            entity_config_key = grupo_key
+            namespace = grupo_namespace
+
+        # Pesquisando a entidade no namespace intermediário (tenant)
+        tenant_namespace = namespaces_dict.get(tenant_key)
+        if tenant_namespace and entity_id in tenant_namespace.loaded_entities:
+            entity_config_key = tenant_key
+            namespace = tenant_namespace
+
+        # Pesquisando a entidade no namespace padrão (default)
+        default_namespace = namespaces_dict.get(default_key)
+        if default_namespace and entity_id in default_namespace.loaded_entities:
+            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)
+        else:
+            return None

nsj_rest_lib2/settings.py

@@ -0,0 +1,3 @@
+import os
+
+ESCOPO_RESTLIB2 = os.environ["ESCOPO_RESTLIB2"]

nsj_rest_lib2-0.0.1.dist-info/METADATA

@@ -0,0 +1,26 @@
+Metadata-Version: 2.4
+Name: nsj_rest_lib2
+Version: 0.0.1
+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
+Author-email: contact.dev@nasajon.com.br
+Project-URL: Source, https://github.com/Nasajon/nsj_rest_lib2
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Programming Language :: Python :: 3
+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
+
+# nsj_rest_lib2
+
+Biblioteca para permitir a distribuição de rotas dinâmicas numa API, configuradas por meio de EDLs declarativos (em formato JSON).
+
+## TODO
+* Colocar tempo para recarregamento das entidades (para checar, no redis, se mudou o hash.)
+* Unificar o arquivo redis_config.py
+* Usar pydantic, ou similar, para transformar a configuração das entidades, no redis, num objeto
+* Rever modo de usar o InjectFactory (talvez dando ciência, ao RestLib, do padrão multibanco)

nsj_rest_lib2-0.0.1.dist-info/RECORD

@@ -0,0 +1,12 @@
+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=3XjRm9QSvE5ORaQB4zQNTkCG0saFyFfjYtuQCiYTg14,11600
+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.1.dist-info/METADATA,sha256=EJwy1kt7HUZw4MjhbF4On9v2wwa5XyFs3llvU87ivCw,1196
+nsj_rest_lib2-0.0.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+nsj_rest_lib2-0.0.1.dist-info/top_level.txt,sha256=L6zh0EfH8_rur7OJ8_V-El-XEMf4qg3bkF8ADgqLVIA,14
+nsj_rest_lib2-0.0.1.dist-info/RECORD,,

nsj_rest_lib2-0.0.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

nsj_rest_lib2-0.0.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+nsj_rest_lib2