neuroglia-python 0.0.23__py3-none-any.whl

neuroglia/serialization/json.py

@@ -0,0 +1,212 @@
+import json
+from datetime import datetime
+from enum import Enum
+import typing
+from neuroglia.hosting.abstractions import ApplicationBuilderBase
+from neuroglia.serialization.abstractions import Serializer, TextSerializer
+from typing import Any, Dict, Optional, Type, Union, get_args, get_origin
+from dataclasses import is_dataclass, fields
+
+
+class JsonEncoder(json.JSONEncoder):
+
+    def default(self, obj):
+        if issubclass(type(obj), Enum):
+            return obj.name
+        elif issubclass(type(obj), datetime):
+            return obj.isoformat()
+        elif hasattr(obj, "__dict__"):
+            filtered_dict = {
+                key: value
+                for key, value in obj.__dict__.items()
+                if not key.startswith("_") and value is not None
+            }
+            return filtered_dict
+        try:
+            return super().default(obj)
+        except Exception:
+            return str(obj)
+
+
+class JsonSerializer(TextSerializer):
+    """Represents the service used to serialize/deserialize to/from JSON"""
+
+    def serialize(self, value: Any) -> bytearray:
+        text = self.serialize_to_text(value)
+        if text is None:
+            return None
+        return text.encode()
+
+    def serialize_to_text(self, value: Any) -> str:
+        return json.dumps(value, cls=JsonEncoder)
+
+    def deserialize(self, input: bytearray, expected_type: Any | None) -> Any:
+        return self.deserialize_from_text(input.decode(), expected_type)
+
+    def deserialize_from_text(
+        self, input: str, expected_type: Optional[Type] = None
+    ) -> Any:
+        value = json.loads(input)
+        if expected_type is None or not isinstance(value, dict):
+            return value
+        elif expected_type == dict:
+            return dict(value)
+        fields = {}
+        for base_type in reversed(expected_type.__mro__):
+            if not hasattr(base_type, "__annotations__"):
+                continue
+            for key, field_type in base_type.__annotations__.items():
+                if key in value:
+                    fields[key] = self._deserialize_nested(value[key], field_type)
+        value = object.__new__(expected_type)
+        value.__dict__ = fields
+        return value
+
+    def _deserialize_nested(self, value: Any, expected_type: Type) -> Any:
+        """Recursively deserializes a nested object. Support native types (str, int, float, bool) as well as Generic Types that also include subtypes (typing.Dict, typing.List)."""
+
+        # Handle None for Optional types
+        if value is None:
+            return None
+
+        origin_type = get_origin(expected_type)
+        if origin_type is not None:
+            # This is a generic type (e.g., Optional[SomeType], List[SomeType])
+            type_args = get_args(expected_type)
+            if origin_type is Union and type(None) in type_args:
+                # This is an Optional type
+                non_optional_type = next(t for t in type_args if t is not type(None))
+                return self._deserialize_nested(value, non_optional_type)
+
+            elif origin_type in (list, typing.List):
+                # Handle List deserialization
+                if len(type_args) > 0:
+                    # List with type hints (e.g. typing.List[str])
+                    item_type = type_args[0]
+                else:
+                    item_type = type(value[0]) if value else object
+
+                # Deserialize each item in the list
+                return [self._deserialize_nested(v, item_type) for v in value]
+
+            elif origin_type is dict:
+                # Handle Dict deserialization
+                if len(type_args) > 0:
+                    # Dictionary with type hints (e.g. typing.Dict[str, int])
+                    key_type, val_type = type_args
+                    return {
+                        self._deserialize_nested(k, key_type): self._deserialize_nested(
+                            v, val_type
+                        )
+                        for k, v in value.items()
+                    }
+                else:
+                    # Dictionary without type hints, use the actual type of each value
+                    return {
+                        k: self._deserialize_nested(v, type(v))
+                        for k, v in value.items()
+                    }
+
+        if isinstance(value, dict):
+            # Handle Dataclass deserialization
+            if is_dataclass(expected_type):
+                field_dict = {}
+                for field in fields(expected_type):
+                    if field.name in value:
+                        field_value = self._deserialize_nested(
+                            value[field.name], field.type
+                        )
+                        field_dict[field.name] = field_value
+                value = object.__new__(expected_type)
+                value.__dict__ = field_dict
+                return value
+
+            # If the expected type is a plain dict, we need to deserialize each value in the dict.
+            if hasattr(expected_type, "__args__") and expected_type.__args__:
+                # Dictionary with type hints (e.g. typing.Dict[str, int])
+                key_type, val_type = expected_type.__args__
+                return {
+                    self._deserialize_nested(k, key_type): self._deserialize_nested(
+                        v, val_type
+                    )
+                    for k, v in value.items()
+                }
+            else:
+                # Dictionary without type hints, use the actual type of each value
+                return {
+                    k: self._deserialize_nested(v, type(v)) for k, v in value.items()
+                }
+
+        elif isinstance(value, list):
+            # List with type hints (e.g. typing.List[str])
+            if hasattr(expected_type, "__args__") and expected_type.__args__:
+                # Extract the actual type from the generic alias
+                item_type = expected_type.__args__[0]
+                if hasattr(item_type, "__origin__"):  # Check if it's a generic alias
+                    if len(item_type.__args__) == 1:
+                        item_type = item_type.__args__[0]  # Get the actual type
+                    else:
+                        item_type = item_type.__origin__
+
+            else:
+                item_type = type(value[0]) if value else object
+
+            # Deserialize each item in the list
+            items = [self._deserialize_nested(v, item_type) for v in value]
+            values = []
+
+            for item in items:
+                if isinstance(item, (int, str, float, bool)):
+                    # For simple types, the deserialized item is already in the correct form
+                    values.append(item)
+                elif isinstance(item_type, type):
+                    # For complex types or custom classes, instantiate using __new__
+                    new_item = object.__new__(item_type)
+                    if hasattr(new_item, "__dict__"):
+                        # If the new item has a __dict__, we can directly update it
+                        new_item.__dict__.update(item)
+                    elif isinstance(item, dict):
+                        new_item = item
+                    values.append(new_item)
+                else:
+                    # If item_type is not a class type, just use the item as is
+                    values.append(item)
+            return values
+
+        elif isinstance(value, str) and expected_type == datetime:
+            return datetime.fromisoformat(value)
+
+        elif (
+            hasattr(expected_type, "__bases__")
+            and expected_type.__bases__
+            and issubclass(expected_type, Enum)
+        ):
+            # Handle Enum deserialization
+            for enum_member in expected_type:
+                if enum_member.value == value:
+                    return enum_member
+            raise ValueError(
+                f"Invalid enum value for {
+                             expected_type.__name__}: {value}"
+            )
+
+        else:
+            # Return the value as is for types that do not require deserialization
+            return value
+
+    def configure(builder: ApplicationBuilderBase) -> ApplicationBuilderBase:
+        """Configures the specified application builder to use the JsonSerializer"""
+        builder.services.add_singleton(JsonSerializer)
+        builder.services.add_singleton(
+            Serializer,
+            implementation_factory=lambda provider: provider.get_required_service(
+                JsonSerializer
+            ),
+        )
+        builder.services.add_singleton(
+            TextSerializer,
+            implementation_factory=lambda provider: provider.get_required_service(
+                JsonSerializer
+            ),
+        )
+        return builder

neuroglia_python-0.0.23.dist-info/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

neuroglia_python-0.0.23.dist-info/METADATA

@@ -0,0 +1,127 @@
+Metadata-Version: 2.1
+Name: neuroglia-python
+Version: 0.0.23
+Summary: Port from .NET to Python of the Neuroglia Framework
+License: Apache
+Author: Charles d'Avernas
+Author-email: charles.davernas@neuroglia.io
+Requires-Python: >=3.12,<4.0
+Classifier: License :: Other/Proprietary License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Dist: annotated-types (>=0.6.0,<0.7.0)
+Requires-Dist: classy-fastapi (>=0.6.1,<0.7.0)
+Requires-Dist: esdbclient (>=1.0.17,<2.0.0)
+Requires-Dist: fastapi (>=0.109.2,<0.110.0)
+Requires-Dist: grpcio (>=1.60.1,<2.0.0)
+Requires-Dist: httpx (>=0.26.0,<0.27.0)
+Requires-Dist: multipledispatch (>=1.0.0,<2.0.0)
+Requires-Dist: pydantic-settings (>=2.2.0,<3.0.0)
+Requires-Dist: pymongo (>=4.6.1,<5.0.0)
+Requires-Dist: pytest (>=8.1.1,<9.0.0)
+Requires-Dist: python-dotenv (>=1.0.1,<2.0.0)
+Requires-Dist: rx (>=3.2.0,<4.0.0)
+Requires-Dist: typing-extensions (>=4.9.0,<5.0.0)
+Requires-Dist: uvicorn (>=0.27.1,<0.28.0)
+Description-Content-Type: text/markdown
+
+# Neuroglia Python Framework
+
+A framework of libraries used to build modern Python V3 applications
+
+## Disclaimer
+
+This project was the opportunity for me (cdavernas) to learn Python while porting some of the concepts and services of the .NET version of the Neuroglia Framework
+
+## Packaging
+
+```sh
+# Set the version tag in pyproject.toml
+# Commit changes
+
+poetry build
+
+poetry publish --repository gitlab -u <token-username> -p <token-password>
+
+```
+
+---
+
+_DRAFT_
+
+## Developer Guide Structure
+
+### Introduction
+
+Briefly describe your framework, its purpose, and its target audience.
+Highlight key features and benefits.
+
+#### Installation:
+
+Provide clear and step-by-step instructions on how to install your framework, including:
+Prerequisites (e.g., Python version, dependencies)
+Installation methods (e.g., pip install <framework_name>, source code compilation)
+Virtual environment recommendations (for isolation and dependency management)
+
+#### Getting Started:
+
+Offer a simple "Hello, World!" or similar example to demonstrate basic usage and familiarize users with your framework's syntax and structure.
+Include code snippets and explanations where necessary.
+
+#### Core Concepts:
+
+Dedicate this section to in-depth explanations of the fundamental building blocks and functionalities of your framework. This might include:
+Key objects and classes within the framework
+Data structures and design patterns employed
+Architectural overview (e.g., MVC, MVVM) if applicable
+
+#### Tutorials and Examples:
+
+Provide a collection of well-structured, step-by-step tutorials that showcase how to accomplish common tasks using your framework.
+Consider varying the difficulty levels (beginner, intermediate, advanced) to cater to a wide range of users.
+Include code examples, explanations, and screenshots as needed.
+
+#### API Reference:
+
+Create a comprehensive reference for all available classes, functions, and modules within your framework.
+Use a consistent format that includes the following information for each API element:
+Name
+Description
+Arguments (with data types and descriptions)
+Return values (with data types and descriptions)
+Usage examples
+
+#### Testing and Debugging:
+
+Explain how to effectively test code written using your framework.
+Recommend testing frameworks and tools.
+Provide practical guidance on common debugging techniques and strategies.
+
+#### Contributing:
+
+Outline how developers can contribute to your framework's development.
+Include information on:
+Issue tracking system (e.g., GitHub issues)
+Pull request guidelines
+Coding style and conventions
+Testing requirements
+
+#### Community and Support:
+
+Specify available resources for users to seek help and engage with the community. This could include:
+Official channels (e.g., discussion forums, mailing lists)
+Third-party resources (e.g., Stack Overflow tags, community blogs)
+
+#### License:
+
+Clearly state the license under which your framework is distributed.
+
+#### Additional Tips:
+
+Maintain a clear and concise writing style, using easy-to-understand language.
+Ensure proper formatting and structure for readability.
+Provide code snippets in a visually appealing format, using code blocks and syntax highlighting.
+Consider adding screenshots or diagrams to illustrate complex concepts.
+Regularly update the guide with new features, bug fixes, and best practices.
+

neuroglia_python-0.0.23.dist-info/RECORD

@@ -0,0 +1,58 @@
+neuroglia/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+neuroglia/core/__init__.py,sha256=MIYU40bW7XIp6FYAOdUcV9oirOBGISMApiVPPgsoVX4,118
+neuroglia/core/module_loader.py,sha256=aKql4lNhdiPfnHTlbbcVMetZnexOB9e1MjDESL_bBN8,303
+neuroglia/core/operation_result.py,sha256=bnIlP7_YkFMkpILaoi4C4XmR7kxjKvCQIxG1nnzfXWE,344
+neuroglia/core/problem_details.py,sha256=_IdZi_MTxiX9mfwqapax8rVLjnBGtyefNdYxMmWL0xc,814
+neuroglia/core/type_extensions.py,sha256=R1FnlR79uJcRtkO6s6doqmSi4U0Q0uim__nWP3QjF4I,4431
+neuroglia/core/type_finder.py,sha256=APNBfa8f6pk9Z4FZaDIXu7OPLtflj3zQRWZodN31BWo,1565
+neuroglia/data/__init__.py,sha256=YQeNZEWkJU1QfwxNeANyF3rkZ7DcvHc1KiiRQ6Jo4fs,24
+neuroglia/data/abstractions.py,sha256=J3H82_uB1irf3_GvL0D37bho_XM7vNjCBQ2AY6EFxsA,3865
+neuroglia/data/infrastructure/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+neuroglia/data/infrastructure/abstractions.py,sha256=-mIm9aL94GsejiVGviNi6DBPy09ool0g3k-ZRi4LziI,2924
+neuroglia/data/infrastructure/event_sourcing/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+neuroglia/data/infrastructure/event_sourcing/abstractions.py,sha256=BCOF-Xpkf3bHixBqM_6ueqvYGApTyKvp2KHRHEJwR9I,4227
+neuroglia/data/infrastructure/event_sourcing/event_sourcing_repository.py,sha256=oviPw4I5CacZ8mVNjUPmi_ooWbPliD7TcIRtfb8VWt4,3951
+neuroglia/data/infrastructure/event_sourcing/event_store/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+neuroglia/data/infrastructure/event_sourcing/event_store/event_store.py,sha256=8z47MCagnfjyoZC7ZV78i16Vk5NUajwbDTu4OaPOWV8,9388
+neuroglia/data/infrastructure/event_sourcing/read_model_reconciliator.py,sha256=JvTc1XUzXSI2VkFZ9M0SjTBXTibWn4zZJXtB2Z6vji4,2489
+neuroglia/data/infrastructure/memory/__init__.py,sha256=dmQJmgzSChdvKFK_RdJBIrDElWZcbYfYBjfNRUKOsmk,67
+neuroglia/data/infrastructure/memory/memory_repository.py,sha256=biqMqav5nDmE1QA1CneWnT1O-en0AlBQiIGeUZ-2TNw,905
+neuroglia/data/infrastructure/mongo/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+neuroglia/data/infrastructure/mongo/mongo_repository.py,sha256=JDBk7525W4D_pqjeNZFapQJDPGKeVntrsnBVfP6zCFM,17152
+neuroglia/data/queries/generic/__init__.py,sha256=x0_HfnY1_9sYPVxk8AQFrW-iq8NpGoUhHNuMwX5ZhBE,56
+neuroglia/data/queries/generic/get_by_id_query.py,sha256=EkPLrlumtGbgVXFOwFXgM8WJN5eyzX5Ivlag-LBoefw,1189
+neuroglia/data/queries/generic/list_query.py,sha256=nT-1MgrOCHXJwL62mdwB_H_eU2k3PSPshJA0POg7mSQ,959
+neuroglia/data/queryable.py,sha256=U3wtk4TcMf8K3SyXNiK1VZmS4v8AxmY3nh4Fwj4viy8,9211
+neuroglia/dependency_injection/__init__.py,sha256=tB4ZK88ZFcz0Z7I7sFZc6Ob9f5dMqWj_vDTef21tPZA,31
+neuroglia/dependency_injection/service_provider.py,sha256=HROO9zO84yHORkoIZuyP1g4o-jVGimuH3DYCaPtScKY,19410
+neuroglia/eventing/cloud_events/__init__.py,sha256=v-QQ7TAvtpcvk3JjbyRLEIuwApiSFvavWStR70cotmc,49
+neuroglia/eventing/cloud_events/cloud_event.py,sha256=u9ZzDyvazFQKdbNvyn-gOw0LteeSamEZ_O9_wpUik6g,3397
+neuroglia/eventing/cloud_events/decorators.py,sha256=VmmJX1J47M8io_slzG3O_AZRvPkeDppT_LZsyr47mVA,155
+neuroglia/eventing/cloud_events/infrastructure/__init__.py,sha256=SWClIn7XCmcpbkzUmYyLMChZMqlRPATn4aU2hzetcBY,208
+neuroglia/eventing/cloud_events/infrastructure/cloud_event_bus.py,sha256=fSkdYoyyTjjdjwpwAR9JQGTBw3TWTT2rbZ7NtQrVt-M,377
+neuroglia/eventing/cloud_events/infrastructure/cloud_event_ingestor.py,sha256=9zSi8NChA4r9ZHBOPD-S6kf42NhTIyezfp8wnOy3ovw,3514
+neuroglia/eventing/cloud_events/infrastructure/cloud_event_middleware.py,sha256=eKOCFdce9R0SKpJEZkZU4Q9BQ_OYMtouLcBpuyrLezA,1886
+neuroglia/eventing/cloud_events/infrastructure/cloud_event_publisher.py,sha256=e_4bOIZorDmT9X59mw1EunjczxO99MmXHcLl2UfJUp4,5004
+neuroglia/expressions/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+neuroglia/expressions/javascript_expression_translator.py,sha256=51krd6zAaKkMbsE7B38NzP-wrLT_iukOx3y8LT5rR8s,7575
+neuroglia/hosting/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+neuroglia/hosting/abstractions.py,sha256=rCfcAQdJeFExNNHdBSI40AUJ7afXD2xiAmYag6tLLEA,4512
+neuroglia/hosting/configuration/data_access_layer.py,sha256=qpddcrcGjHf5dc6pS3-Og5QTy_1C-Z1jZyOzXr51X_c,3549
+neuroglia/hosting/web.py,sha256=4cgrcKv11i5pCvF6BAvADDh61yhnngtG_MegKTETQzk,3853
+neuroglia/integration/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+neuroglia/integration/models.py,sha256=WQe0AfDBkaARq9cCvrNKwdqWK2MbLBPYvxlSOM2XgP4,562
+neuroglia/mapping/__init__.py,sha256=aHGxWkILW84XNj_b_OSgqKQWH39fRdvbMKxbSmGYlV0,36
+neuroglia/mapping/mapper.py,sha256=2Rjqo897pNvmMgF1WcIu_u-sWuScLQlOPeKt8Lq7HmQ,11023
+neuroglia/mediation/__init__.py,sha256=OuWOVpeZXNCjc4aet9W0myZI6w8trD6c7tVaIojpfLw,23
+neuroglia/mediation/mediator.py,sha256=Tpzk7sLFKa_B3eEvpatesZJX_-HSjbJpjeQNxWJOCno,8788
+neuroglia/mvc/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+neuroglia/mvc/controller_base.py,sha256=8dd4jDITxCAJ4a3-zuc-M_1bGhiDppRlnKwjKhMcavk,2900
+neuroglia/reactive/__init__.py,sha256=-DJt-eZdeEkSS4qV6CECg_gokeLns0xQGUMhzj0Pse8,29
+neuroglia/reactive/rx_async.py,sha256=3EGW-PykvnDtqKfWb3AX8nW1YojnVmN72lFHWi2hrQc,409
+neuroglia/serialization/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+neuroglia/serialization/abstractions.py,sha256=k-BYTnpIwvx7QPUOvxwzMz23YPEh8gGbuylY54LqDac,1063
+neuroglia/serialization/json.py,sha256=qPcriQpFLIU7TBNTNTBUuNKsxFrJYQeM4eFCN-YpVBo,8792
+neuroglia_python-0.0.23.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+neuroglia_python-0.0.23.dist-info/METADATA,sha256=tkZC1S1s1dvqpM_NVxkQlRUtDXwgp7JrwFqDQvDC2Yk,4435
+neuroglia_python-0.0.23.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
+neuroglia_python-0.0.23.dist-info/RECORD,,

neuroglia_python-0.0.23.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: poetry-core 1.9.1
+Root-Is-Purelib: true
+Tag: py3-none-any