bisslog-flask 0.0.1__py3-none-any.whl

bisslog_flask/__init__.py

@@ -0,0 +1,26 @@
+"""
+bisslog_flask
+
+An extension of the `bisslog` library to support service orchestration via Flask.
+
+This package enables dynamic registration of HTTP and WebSocket routes in a Flask
+application, using declarative metadata (YAML/JSON). It promotes clean separation
+between application logic and infrastructure concerns, aligning with hexagonal
+or clean architecture principles.
+
+
+Requirements
+------------
+- Flask >= 2.0
+- bisslog-schema >= 0.0.3
+- flask-cors
+- (optional) flask-socketio for WebSocket integration
+
+License
+-------
+MIT © Darwin Stiven Herrera Cartagena
+"""
+from .initializer.init_flask_app_manager import BisslogFlask
+from .socket_helper.socket_helper import BisslogFlaskSocketHelper
+
+__all__ = ["BisslogFlask", "BisslogFlaskSocketHelper"]

bisslog_flask/initializer/bisslog_flask_http_resolver.py

@@ -0,0 +1,186 @@
+"""
+Flask HTTP resolver for Bisslog-based use case routing.
+
+This module provides a class to dynamically register HTTP endpoints
+in a Flask application using 'use case metadata'. It supports CORS configuration
+and flexible request mapping using the Bisslog schema and Mapper.
+
+Classes
+-------
+BisslogFlaskHttpResolver : Register HTTP routes for use cases based on metadata.
+
+Dependencies
+------------
+- Flask
+- flask_cors
+- bisslog_schema
+- bisslog.utils.mapping
+"""
+from copy import deepcopy
+from typing import Callable, Optional, Dict
+
+from flask import Flask, request, jsonify
+try:
+    from flask_cors import cross_origin
+except ImportError:
+    cross_origin = None
+from bisslog.utils.mapping import Mapper
+from bisslog_schema.schema import UseCaseInfo, TriggerHttp, TriggerInfo
+from bisslog_schema.schema.triggers.trigger_mappable import TriggerMappable
+
+from .bisslog_flask_resolver import BisslogFlaskResolver
+
+
+class BisslogFlaskHttpResolver(BisslogFlaskResolver):
+    """
+    Flask HTTP resolver that dynamically registers use cases as routes based on metadata.
+
+    This resolver wraps use case callables and maps request data accordingly,
+    applying optional CORS configuration at the endpoint level.
+
+    Inherits
+    --------
+    BisslogFlaskResolver
+        Base resolver interface for trigger-based route binding.
+    """
+
+    @staticmethod
+    def _lambda_fn(*args, fn, __mapper__: Optional[Mapper], **kwargs):
+        """Wraps a use case function to extract and map request data.
+
+        Parameters
+        ----------
+        *args : tuple
+            Positional arguments passed by Flask (usually none).
+        fn : Callable
+            The actual use case function to invoke.
+        __mapper__ : Optional[Mapper]
+            Mapper to transform HTTP request parts into function arguments.
+        **kwargs : dict
+            Keyword arguments passed by Flask (URL params, etc.).
+
+        Returns
+        -------
+        flask.Response
+            A JSON response with the result of the use case.
+        """
+        if __mapper__ is None:
+            more_kwargs = {}
+            if request.method.lower() not in ["get"]:
+                more_kwargs.update(request.get_json(silent=True) or {})
+            return jsonify(fn(*args, **kwargs, **more_kwargs))
+
+        res_map = __mapper__.map({
+            "path_query": request.view_args or {},
+            "body": request.get_json(silent=True) or {},
+            "params": request.args.to_dict(),
+            "headers": request.headers,
+        })
+        res = fn(**res_map)
+
+        return jsonify(res)
+
+    @staticmethod
+    def _use_case_factory(
+            use_case_name: str,
+            fn: Callable,
+            mapper: Optional[Dict[str, str]] = None,
+            trigger: Optional[TriggerHttp] = None
+    ):
+        """
+        Factory to produce a Flask view function with optional mapping and CORS.
+
+        Parameters
+        ----------
+        use_case_name : str
+            Unique name of the use case.
+        fn : Callable
+            The function to be wrapped and exposed via HTTP.
+        mapper : dict, optional
+            Mapping schema for request fields, if applicable.
+        trigger : TriggerHttp, optional
+            Trigger options used to configure CORS.
+
+        Returns
+        -------
+        Callable
+            A Flask-compatible view function.
+        """
+        use_case_fn_copy = deepcopy(fn)
+        __mapper__ = Mapper(name=f"Mapper {use_case_name}", base=mapper) if mapper else None
+
+        def uc(*args, **kwargs):
+            return BisslogFlaskHttpResolver._lambda_fn(
+                *args, fn=use_case_fn_copy, __mapper__=__mapper__, **kwargs
+            )
+
+        # Apply CORS dynamically if allowed
+        if trigger and trigger.allow_cors:
+            if cross_origin is None:
+                raise ImportError("flask_cors is not installed, please install it")
+            cors_kwargs = {
+                "origins": trigger.allowed_origins or "*",
+                "methods": [trigger.method.upper()],
+                "allow_headers": ["Content-Type", "Authorization"],
+                "supports_credentials": True
+            }
+            return cross_origin(**cors_kwargs)(uc)
+
+        return uc
+
+    @classmethod
+    def _add_use_case(cls, app: Flask, use_case_info: UseCaseInfo, trigger: TriggerInfo,
+                      use_case_function):
+        """
+        Adds an HTTP endpoint to the Flask app for a given use case.
+
+        Parameters
+        ----------
+        app : Flask
+            The Flask application instance.
+        use_case_info : UseCaseInfo
+            Metadata describing the use case being added.
+        trigger : TriggerInfo
+            Metadata describing the trigger configuration (must be HTTP).
+        use_case_function : Callable
+            The use case logic to expose via HTTP.
+        """
+        if not isinstance(trigger.options, TriggerHttp):
+            return
+
+        method = trigger.options.method.upper()
+        path = trigger.options.path.replace("{", "<").replace("}", ">")
+
+        mapper = (
+            trigger.options.mapper
+            if isinstance(trigger.options, TriggerMappable)
+            else None
+        )
+        app.add_url_rule(
+            path,
+            endpoint=use_case_info.keyname + " " + path,
+            methods=[method],
+            view_func=cls._use_case_factory(
+                use_case_name=use_case_info.keyname,
+                fn=use_case_function,
+                mapper=mapper,
+                trigger=trigger.options
+            )
+        )
+
+    def __call__(self, app: Flask, use_case_info: UseCaseInfo,
+                 trigger_info: TriggerInfo, use_case_callable: Callable, **kwargs):
+        """Entry point to register a use case route using this resolver.
+
+        Parameters
+        ----------
+        app : Flask
+            The Flask app where the route will be registered.
+        use_case_info : UseCaseInfo
+            Metadata of the use case.
+        trigger_info : TriggerInfo
+            Trigger configuration for the route.
+        use_case_callable : Callable
+            The function to execute when the route is called.
+        """
+        self._add_use_case(app, use_case_info, trigger_info, use_case_callable)

bisslog_flask/initializer/bisslog_flask_resolver.py

@@ -0,0 +1,46 @@
+"""
+Abstract base class for Bisslog Flask route resolvers.
+
+This module defines a common interface for resolving use case routes
+in a Flask application. Subclasses implement logic to register routes
+based on different trigger types (e.g., HTTP, WebSocket).
+"""
+from abc import ABC, abstractmethod
+from typing import Callable
+
+from bisslog_schema.schema import UseCaseInfo, TriggerInfo
+
+from flask import Flask
+
+
+class BisslogFlaskResolver(ABC):
+    """Abstract base class for registering use case routes in a Flask application.
+
+    Implementations of this class handle the translation of trigger metadata
+    into concrete route registration logic, such as for HTTP or WebSocket endpoints.
+
+    Subclasses must implement the `__call__` method to perform the actual route binding."""
+
+    @abstractmethod
+    def __call__(self, app: Flask, use_case_info: UseCaseInfo,
+                 trigger_info: TriggerInfo, use_case_callable: Callable, **kwargs) -> Callable:
+        """
+        Registers a use case route in a Flask app based on the given trigger.
+
+        Parameters
+        ----------
+        app : Flask
+            The Flask application instance where the route should be registered.
+        use_case_info : UseCaseInfo
+            Metadata describing the use case, including name and key.
+        trigger_info : TriggerInfo
+            Trigger metadata (e.g., HTTP, WebSocket) describing how the route is activated.
+        use_case_callable : Callable
+            The function or class instance that implements the use case logic.
+
+        Raises
+        ------
+        NotImplementedError
+            If the method is not implemented by a subclass.
+        """
+        raise NotImplementedError

bisslog_flask/initializer/bisslog_flask_ws_resolver.py

@@ -0,0 +1,76 @@
+"""
+WebSocket resolver for Bisslog-based Flask applications using Flask-SocketIO.
+
+This module defines the `BisslogFlaskWebSocketResolver` class, which dynamically registers
+WebSocket-based use case triggers in a Flask app. The class uses metadata definitions to
+configure event routes (via `route_key`) and binds them to corresponding use case functions.
+"""
+from typing import Callable
+from flask import Flask, request
+
+try:
+    from flask_socketio import SocketIO
+except ImportError:
+    class SocketIO:
+        """Socket IO simulator while is not installed"""
+        def __init__(self, _, ** __):
+            raise ImportError("flask socketio is not installed, please install it")
+
+from bisslog.utils.mapping import Mapper
+from bisslog_schema.schema import UseCaseInfo, TriggerInfo
+from bisslog_schema.schema.triggers.trigger_websocket import TriggerWebsocket
+from .bisslog_flask_resolver import BisslogFlaskResolver
+
+
+class BisslogFlaskWebSocketResolver(BisslogFlaskResolver):
+    """
+    Resolver that registers WebSocket use cases using Flask-SocketIO.
+
+    This class maps WebSocket events (via route_key) to the use case callables.
+    If a SocketIO instance is not already attached to the Flask app,
+    a new one will be created and stored in `app.extensions["socketio"]`.
+    """
+
+    def __call__(self, app: Flask, use_case_info: UseCaseInfo,
+                 trigger_info: TriggerInfo, use_case_callable: Callable, **kwargs):
+        """
+        Register a WebSocket event handler for a use case.
+
+        Parameters
+        ----------
+        app : Flask
+            The Flask app instance.
+        use_case_info : UseCaseInfo
+            Metadata about the use case.
+        trigger_info : TriggerWebsocket
+            Trigger options containing the route_key and mapper.
+        use_case_callable : Callable
+            The actual use case function to call when the event is triggered.
+        kwargs : dict
+            Additional optional arguments (ignored here).
+        """
+        if not isinstance(trigger_info.options, TriggerWebsocket):
+            return
+
+        # Get or create SocketIO instance
+        socket_io_obj = app.extensions.get("socketio")
+        if socket_io_obj is None:
+            socket_io_obj = SocketIO(app, cors_allowed_origins="*")
+            app.extensions["socketio"] = socket_io_obj
+
+        route_key = trigger_info.options.route_key
+        mapper = Mapper(
+            name=f"mapper-ws-{use_case_info.keyname}-{route_key}",
+            base=trigger_info.options.mapper
+        ) if trigger_info.options.mapper else None
+
+        @socket_io_obj.on(route_key)
+        def on_event(data):
+            mapped_data = mapper.map({
+                "route_key": route_key,
+                "connection_id": request.sid,
+                "body": data,
+                "headers": dict(request.headers)
+            }) if mapper else data
+
+            return use_case_callable(**mapped_data) if mapper else use_case_callable(data)

bisslog_flask/initializer/init_flask_app_manager.py

@@ -0,0 +1,123 @@
+"""
+Flask application initializer for Bisslog-based services.
+
+This module defines a manager that reads service metadata and dynamically registers
+use case endpoints into a Flask application using resolvers for HTTP and WebSocket triggers.
+
+Classes
+-------
+InitFlaskAppManager : Initializes a Flask app with routes from use case metadata.
+
+Dependencies
+------------
+- Flask
+- bisslog_schema
+- BisslogFlaskResolver
+"""
+
+from typing import Optional, Callable
+
+from bisslog_schema import read_service_info_with_code
+from bisslog_schema.schema import UseCaseInfo, TriggerHttp, TriggerWebsocket
+from flask import Flask
+
+from .bisslog_flask_http_resolver import BisslogFlaskHttpResolver
+from .bisslog_flask_resolver import BisslogFlaskResolver
+from .bisslog_flask_ws_resolver import BisslogFlaskWebSocketResolver
+
+
+class InitFlaskAppManager:
+    """
+    Initializes a Flask app by registering routes from metadata using HTTP and WebSocket resolvers.
+
+    This manager reads metadata and code, then applies the appropriate processor (resolver)
+    to each use case according to its trigger type.
+
+    Parameters
+    ----------
+    http_processor : BisslogFlaskResolver
+        Resolver used to handle HTTP-triggered use cases.
+    websocket_processor : BisslogFlaskResolver
+        Resolver used to handle WebSocket-triggered use cases.
+    """
+
+    def __init__(self, http_processor: BisslogFlaskResolver,
+                 websocket_processor: BisslogFlaskResolver) -> None:
+        self._http_processor = http_processor
+        self._websocket_processor = websocket_processor
+
+    def __call__(
+            self,
+            metadata_file: Optional[str] = None,
+            use_cases_folder_path: Optional[str] = None,
+            app: Optional[Flask] = None,
+            *,
+            encoding: str = "utf-8",
+            secret_key: Optional[str] = None,
+            jwt_secret_key: Optional[str] = None,
+            **kwargs) -> Flask:
+        """
+        Loads metadata, discovers use case functions, registers routes and returns the Flask app.
+
+        This method reads metadata and code from the given paths, initializes the Flask app
+        (if not provided), configures security options, and applies HTTP or WebSocket processors
+        based on the trigger type for each use case.
+
+        Parameters
+        ----------
+        metadata_file : str, optional
+            Path to the metadata file (YAML/JSON).
+        use_cases_folder_path : str, optional
+            Directory where use case code is located.
+        app : Flask, optional
+            An existing Flask app instance to which routes will be added.
+            If not provided, a new app is created using the service name.
+        encoding : str, optional
+            File encoding for reading metadata (default is "utf-8").
+        secret_key : str, optional
+            Secret key to set in app config (used for session security).
+        jwt_secret_key : str, optional
+            JWT secret key to set in app config (used for token authentication).
+        **kwargs : Any
+            Additional keyword arguments (not currently used).
+
+        Returns
+        -------
+        Flask
+            The Flask app instance with registered use case routes.
+        """
+        full_service_data = read_service_info_with_code(
+            metadata_file=metadata_file,
+            use_cases_folder_path=use_cases_folder_path,
+            encoding=encoding
+        )
+        service_info = full_service_data.declared_metadata
+        use_cases = full_service_data.discovered_use_cases
+
+        # Initialize Flask app
+        if app is None:
+            app = Flask(service_info.name)
+
+        # Configure security
+        if secret_key is not None:
+            app.config["SECRET_KEY"] = secret_key
+        if jwt_secret_key is not None:
+            app.config["JWT_SECRET_KEY"] = jwt_secret_key
+
+        # Register each use case to the appropriate processor
+        for use_case_keyname in service_info.use_cases:
+            use_case_info: UseCaseInfo = service_info.use_cases[use_case_keyname]
+            use_case_callable: Callable = use_cases[use_case_keyname]
+
+            for trigger in use_case_info.triggers:
+                if isinstance(trigger.options, TriggerHttp):
+                    self._http_processor(
+                        app, use_case_info, trigger, use_case_callable, **kwargs)
+                if isinstance(trigger.options, TriggerWebsocket):
+                    self._websocket_processor(
+                        app, use_case_info, trigger, use_case_callable, **kwargs)
+
+        return app
+
+
+BisslogFlask = InitFlaskAppManager(BisslogFlaskHttpResolver(), BisslogFlaskWebSocketResolver())

bisslog_flask/socket_helper/socket_helper.py

@@ -0,0 +1,106 @@
+"""
+Helper class for sending notifications through WebSocket using Flask-SocketIO.
+
+This module provides a concrete implementation of the `WebSocketManager` interface,
+allowing you to send events, manage rooms, and communicate with WebSocket clients
+via Flask-SocketIO.
+"""
+
+from typing import Any
+
+from bisslog.ports.ws_manager import WebSocketManager
+
+
+class BisslogFlaskSocketHelper(WebSocketManager):
+    """
+    Flask-SocketIO implementation of the WebSocketManager interface.
+
+    This class adapts Flask-SocketIO's functionality to the `bisslog` WebSocket contract,
+    allowing event emission, room management, and direct message delivery using
+    a consistent interface.
+    """
+
+    def __init__(self, conn) -> None:
+        super().__init__(conn)
+
+    def emit(self, event: str, connection_id: str, payload: Any,
+             broadcast: bool = False, to: str = None):
+        """
+        Emit an event to a specific connection or to a room.
+
+        Parameters
+        ----------
+        event : str
+            Name of the event to emit.
+        connection_id : str
+            SocketIO session ID of the client.
+        payload : Any
+            Data to send.
+        broadcast : bool, optional
+            Whether to broadcast to all clients (default: False).
+        to : str, optional
+            Target room (if broadcasting).
+        """
+        self.conn.emit(
+            event,
+            payload,
+            to=to or connection_id,
+            broadcast=broadcast
+        )
+
+    def join_room(self, room: str, connection_id: str):
+        """
+        Add a connection to a room.
+
+        Parameters
+        ----------
+        room : str
+            Name of the room.
+        connection_id : str
+            Session ID of the connection to join the room.
+        """
+        self.conn.server.enter_room(connection_id, room)
+
+    def leave_room(self, room: str, connection_id: str):
+        """
+        Remove a connection from a room.
+
+        Parameters
+        ----------
+        room : str
+            Name of the room.
+        connection_id : str
+            Session ID of the connection to leave the room.
+        """
+        self.conn.server.leave_room(connection_id, room)
+
+    def rooms(self, connection_id: str):
+        """
+        Get a list of rooms the connection is part of.
+
+        Parameters
+        ----------
+        connection_id : str
+            Session ID of the client.
+
+        Returns
+        -------
+        list[str]
+            List of room names.
+        """
+        return list(self.conn.server.rooms(connection_id))
+
+    def send(self, event: str, payload: Any = None, connection_id: str = None):
+        """
+        Send a message with or without an event name.
+
+        Parameters
+        ----------
+        event : str
+            Event name or message label.
+        payload : Any, optional
+            Payload to send.
+        connection_id : str, optional
+            Target client (if None, broadcast).
+        """
+        self.conn.send(payload or event, to=connection_id)

bisslog_flask-0.0.1.dist-info/METADATA

@@ -0,0 +1,141 @@
+Metadata-Version: 2.4
+Name: bisslog_flask
+Version: 0.0.1
+Summary: It is an extension of the bisslog library to support processes with flask
+Author-email: Darwin Stiven Herrera Cartagena <darwinsherrerac@gmail.com>
+Project-URL: Homepage, https://github.com/darwinhc/bisslog-flask
+Keywords: hexagonal,adapters,bisslog,flask
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: bisslog>=0.0.7
+Requires-Dist: bisslog-schema>=0.0.3
+Requires-Dist: flask
+Provides-Extra: websocket
+Requires-Dist: flask-socketio; extra == "websocket"
+Provides-Extra: cors
+Requires-Dist: flask-cors>=6.0.0; extra == "cors"
+Dynamic: license-file
+
+
+# bisslog-flask
+
+[![PyPI](https://img.shields.io/pypi/v/bisslog-flask)](https://pypi.org/project/bisslog-flask/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](LICENSE)
+
+**bisslog-flask** is an extension of the bisslog library to support processes with Flask. It enables dynamic HTTP and WebSocket route registration from use case metadata, allowing developers to build clean, modular, and metadata-driven APIs with minimal boilerplate.
+
+Part of the bisslog ecosystem, it is designed to work seamlessly with domain-centric architectures like Hexagonal or Clean Architecture.
+
+## Features
+
+- 🔁 Dynamic route registration for HTTP and WebSocket triggers
+
+- 🧠 Metadata-driven setup – use YAML or JSON to declare your use cases
+
+- 🔒 Automatic CORS per endpoint using flask-cors
+
+- 🔌 Extensible resolver pattern – plug in your own processor
+
+- ⚙️ Mapper integration – maps HTTP request parts to domain function arguments
+
+
+
+## 📦 Installation
+
+~~~shell
+pip install bisslog-flask
+~~~
+
+
+
+
+## 🚀 Quickstart
+
+### Programmatically
+
+if you want to configure the app before bisslog touches it
+~~~python
+from flask import Flask
+from bisslog_flask import BisslogFlask
+
+app = Flask(__name__)
+BisslogFlask(
+    metadata_file="metadata.yml",
+    use_cases_folder_path="src/domain/use_cases",
+    app=app
+)
+
+if __name__ == "__main__":
+    app.run(debug=True)
+~~~
+
+or
+
+~~~python
+from bisslog_flask import BisslogFlask
+
+app = BisslogFlask(
+    metadata_file="metadata.yml",
+    use_cases_folder_path="src/domain/use_cases"
+)
+
+if __name__ == "__main__":
+    app.run(debug=True)
+~~~
+
+
+
+## 🔧 How It Works
+
+1. Loads metadata and discovers use case functions (or callables), then uses resolvers to register routes dynamically into a Flask app.
+
+
+## 🔐 CORS Handling
+
+CORS is applied only when allow_cors: true is specified in the trigger
+
+Fully dynamic: works even with dynamic Flask routes like /users/<id>
+
+Powered by `@cross_origin` from `flask-cors`
+
+
+## ✅ Requirements
+
+Python ≥ 3.7
+
+Flask ≥ 2.0
+
+bisslog-schema ≥ 0.0.3
+
+flask-cors
+
+(Optional) flask-socketio if using WebSocket triggers
+
+
+## 🧪 Testing Tip
+
+You can test the generated Flask app directly with `app.test_client()` if you take the programmatic way:
+
+```python
+from bisslog_flask import BisslogFlask
+
+def test_user_create():
+    app = BisslogFlask(metadata_file="metadata.yml", use_cases_folder_path="src/use_cases")
+    client = app.test_client()
+    response = client.post("/user", json={"name": "Ana", "email": "ana@example.com"})
+    assert response.status_code == 200
+```
+
+Not generating code or using the programmatic way you just need to test your use cases.
+
+
+
+## 📜 License
+
+This project is licensed under the MIT License. See the [LICENSE](LICENSE) file for details.
+
+
+

bisslog_flask-0.0.1.dist-info/RECORD

@@ -0,0 +1,13 @@
+bisslog_flask/__init__.py,sha256=BEf_UxFtcMfaM-Smh_bwc6Xn8pR8LcEjby3nCs0hdXE,758
+bisslog_flask/initializer/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+bisslog_flask/initializer/bisslog_flask_http_resolver.py,sha256=d-KFQwMXeRyq3_Cu5bxCF7CpnetfnKainChEbdxDk2c,6257
+bisslog_flask/initializer/bisslog_flask_resolver.py,sha256=QWjft6HZbBplbP1vVMNoPhGoSZBJubAotwLR76HVttw,1708
+bisslog_flask/initializer/bisslog_flask_ws_resolver.py,sha256=s-eDdk5HA6E_D8iZC6IN7RSW-96mzu8m8VGL3Xqm9PQ,2974
+bisslog_flask/initializer/init_flask_app_manager.py,sha256=QzO1dae3YFap2VEXK3gSexLkdfBGaLWrHK732z5s0K0,4682
+bisslog_flask/socket_helper/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+bisslog_flask/socket_helper/socket_helper.py,sha256=sR9xQSPWzijhPNRh8WRxDbzE7rqFqm4w0Vql4gBGiGU,3037
+bisslog_flask-0.0.1.dist-info/licenses/LICENSE,sha256=TSlM1hRIXc6yR3xpGzy2DMSSbds0svqHSetfNfQqCEk,1074
+bisslog_flask-0.0.1.dist-info/METADATA,sha256=w82no5oSrRtS7XEDT38gs6UYIrzyuBHK4eEJkpQptH0,3551
+bisslog_flask-0.0.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+bisslog_flask-0.0.1.dist-info/top_level.txt,sha256=Xk85d0SIhkUP1HjsXOtq2vlU7yQT3mFApyb5IVgtG6w,14
+bisslog_flask-0.0.1.dist-info/RECORD,,

bisslog_flask-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
+

bisslog_flask-0.0.1.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Darwin Herrera C.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

bisslog_flask-0.0.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+bisslog_flask