flaskion 2.0.0a1__py3-none-any.whl

flaskion/__init__.py

@@ -0,0 +1,18 @@
+"""Public Flaskion runtime API.
+
+The runtime deliberately exposes only the small application boundary needed by
+interface adapters. Application code can use ordinary dataclasses, functions,
+services, and repository protocols without inheriting from framework classes.
+"""
+
+from flaskion.application import Application
+from flaskion.errors import DuplicateUseCase, FlaskionError, UseCaseNotRegistered
+
+__all__ = [
+    "Application",
+    "DuplicateUseCase",
+    "FlaskionError",
+    "UseCaseNotRegistered",
+]
+
+__version__ = "2.0.0a1"

flaskion/application.py

@@ -0,0 +1,49 @@
+from collections.abc import Callable
+from typing import Any, TypeVar
+
+from flaskion.errors import DuplicateUseCase, UseCaseNotRegistered
+
+Message = TypeVar("Message")
+Result = TypeVar("Result")
+Handler = Callable[[Any], Any]
+
+
+class Application:
+    """Register and invoke application use cases by message type.
+
+    A message can be any Python object, normally a small dataclass. A handler
+    can be a function, a bound service method, or any callable object. Flaskion
+    imposes no base classes on messages, handlers, services, or repositories.
+    """
+
+    def __init__(self) -> None:
+        self._handlers: dict[type[Any], Handler] = {}
+
+    def register(self, message_type: type[Message], handler: Callable[[Message], Result]) -> None:
+        """Register one handler for a message type."""
+        if message_type in self._handlers:
+            raise DuplicateUseCase(message_type)
+        self._handlers[message_type] = handler
+
+    def use_case(
+        self, message_type: type[Message]
+    ) -> Callable[[Callable[[Message], Result]], Callable[[Message], Result]]:
+        """Optionally register a function with decorator syntax."""
+
+        def register(handler: Callable[[Message], Result]) -> Callable[[Message], Result]:
+            self.register(message_type, handler)
+            return handler
+
+        return register
+
+    def handle(self, message: Message) -> Any:
+        """Invoke the handler registered for the message's concrete type."""
+        try:
+            handler = self._handlers[type(message)]
+        except KeyError as exc:
+            raise UseCaseNotRegistered(type(message)) from exc
+        return handler(message)
+
+    def registered_messages(self) -> tuple[type[Any], ...]:
+        """Return registered message types for diagnostics and tests."""
+        return tuple(self._handlers)

flaskion/errors.py

@@ -0,0 +1,14 @@
+class FlaskionError(Exception):
+    """Base class for errors raised by the Flaskion runtime itself."""
+
+
+class UseCaseNotRegistered(FlaskionError):
+    def __init__(self, message_type: type[object]) -> None:
+        self.message_type = message_type
+        super().__init__(f"No use case is registered for {message_type.__name__}")
+
+
+class DuplicateUseCase(FlaskionError):
+    def __init__(self, message_type: type[object]) -> None:
+        self.message_type = message_type
+        super().__init__(f"A use case is already registered for {message_type.__name__}")

flaskion/mcp/__init__.py

@@ -0,0 +1,10 @@
+"""Optional MCP adapter support for Flaskion applications.
+
+Install ``flaskion[mcp]`` before importing this package. Importing the
+main :mod:`flaskion` package does not load FastMCP.
+"""
+
+from flaskion.mcp.errors import MCPTransportError
+from flaskion.mcp.server import MCPServer, ToolAnnotations
+
+__all__ = ["MCPServer", "MCPTransportError", "ToolAnnotations"]

flaskion/mcp/_compat.py

@@ -0,0 +1,12 @@
+"""The deliberately small boundary around version-sensitive FastMCP imports."""
+
+try:
+    from fastmcp import Client, FastMCP
+    from fastmcp.exceptions import ToolError
+except ImportError as exc:  # pragma: no cover - exercised without the optional extra
+    raise ImportError(
+        "Flaskion MCP support requires the optional dependency. "
+        'Install it with `pip install "flaskion[mcp]"`.'
+    ) from exc
+
+__all__ = ["Client", "FastMCP", "ToolError"]

flaskion/mcp/errors.py

@@ -0,0 +1,6 @@
+from flaskion.errors import FlaskionError
+
+
+class MCPTransportError(FlaskionError):
+    """A safe error raised when an MCP client cannot establish a transport."""
+

flaskion/mcp/server.py

@@ -0,0 +1,91 @@
+from collections.abc import Callable, Iterable
+from dataclasses import dataclass
+from typing import Any, Literal, TypeVar
+
+from flaskion import Application
+from flaskion.mcp._compat import FastMCP, ToolError
+
+Function = TypeVar("Function", bound=Callable[..., Any])
+
+
+@dataclass(frozen=True)
+class ToolAnnotations:
+    """Stable, commonly useful behavior hints for an MCP tool."""
+
+    read_only: bool = False
+    destructive: bool = True
+    idempotent: bool = False
+    open_world: bool = True
+
+    def as_fastmcp(self) -> dict[str, bool]:
+        return {
+            "readOnlyHint": self.read_only,
+            "destructiveHint": self.destructive,
+            "idempotentHint": self.idempotent,
+            "openWorldHint": self.open_world,
+        }
+
+
+class MCPServer:
+    """Expose a Flaskion application through an optional FastMCP adapter.
+
+    Tool functions remain explicit adapter code. They construct application
+    messages, call :meth:`handle`, and map results to transport-safe values.
+    """
+
+    def __init__(
+        self,
+        name: str,
+        application: Application,
+        *,
+        application_errors: Iterable[type[Exception]] = (),
+    ) -> None:
+        self.application = application
+        self.application_errors = tuple(application_errors)
+        self._server = FastMCP(name)
+
+    def handle(self, message: object) -> Any:
+        """Invoke a use case and translate declared application errors safely."""
+        try:
+            return self.application.handle(message)
+        except self.application_errors as exc:
+            raise ToolError(str(exc)) from exc
+
+    def tool(
+        self,
+        *,
+        name: str,
+        description: str | None = None,
+        annotations: ToolAnnotations | None = None,
+    ) -> Callable[[Function], Function]:
+        """Register a typed function as a tool without exposing FastMCP."""
+
+        def register(function: Function) -> Function:
+            self._server.tool(
+                name=name,
+                description=description,
+                annotations=annotations.as_fastmcp() if annotations else None,
+            )(function)
+            return function
+
+        return register
+
+    def run(
+        self,
+        transport: Literal["stdio", "http"] = "stdio",
+        *,
+        host: str = "127.0.0.1",
+        port: int = 8000,
+    ) -> None:
+        """Run over local stdio or Streamable HTTP at ``/mcp``."""
+        if transport == "stdio":
+            self._server.run(transport="stdio")
+            return
+        if transport != "http":
+            raise ValueError("MCP transport must be 'stdio' or 'http'")
+        self._server.run(transport="http", host=host, port=port)
+
+    @property
+    def native(self) -> Any:
+        """Return the underlying server for advanced adapter-only extensions."""
+        return self._server

flaskion/mcp/testing.py

@@ -0,0 +1,53 @@
+from typing import Any
+
+from flaskion.mcp._compat import Client, ToolError
+from flaskion.mcp.errors import MCPTransportError
+from flaskion.mcp.server import MCPServer
+
+
+class MCPTestClient:
+    """An in-memory client for testing a Flaskion MCP server."""
+
+    def __init__(self, server: MCPServer | str) -> None:
+        self._remote = isinstance(server, str)
+        self._client = Client(server if self._remote else server.native)
+
+    @classmethod
+    def remote(cls, url: str) -> "MCPTestClient":
+        """Connect to a Streamable HTTP endpoint for network integration tests."""
+        return cls(url)
+
+    async def __aenter__(self) -> "MCPTestClient":
+        try:
+            await self._client.__aenter__()
+        except Exception as exc:
+            if not self._remote:
+                raise
+            raise MCPTransportError("Unable to connect to the MCP server.") from exc
+        return self
+
+    async def __aexit__(self, *args: object) -> None:
+        await self._client.__aexit__(*args)
+
+    async def list_tools(self) -> Any:
+        try:
+            return await self._client.list_tools()
+        except Exception as exc:
+            self._raise_transport_error(exc)
+
+    async def call_tool(
+        self, name: str, arguments: dict[str, Any] | None = None, *, raise_on_error: bool = True
+    ) -> Any:
+        try:
+            return await self._client.call_tool(
+                name, arguments or {}, raise_on_error=raise_on_error
+            )
+        except ToolError:
+            raise
+        except Exception as exc:
+            self._raise_transport_error(exc)
+
+    def _raise_transport_error(self, error: Exception) -> None:
+        if not self._remote:
+            raise error
+        raise MCPTransportError("MCP transport request failed.") from error

flaskion-2.0.0a1.dist-info/METADATA

@@ -0,0 +1,215 @@
+Metadata-Version: 2.4
+Name: flaskion
+Version: 2.0.0a1
+Summary: An opinionated application framework and scaffolder for Flask
+Author-email: Graham Patrick <graham@skyaisoftware.com>
+Project-URL: Homepage, https://github.com/GrahamMorbyDev/flaskion
+Project-URL: Issues, https://github.com/GrahamMorbyDev/flaskion/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+Requires-Dist: click>=8.1
+Requires-Dist: flask>=3.1
+Requires-Dist: jinja2>=3.1
+Provides-Extra: mcp
+Requires-Dist: fastmcp<5,>=4; extra == "mcp"
+
+# Flaskion
+
+Flaskion is a Laravel-inspired application framework and project scaffolder for Flask. The `2.0.0a1` runtime adds a small interface-independent use-case boundary while retaining the Flask project generators from Phase 1.
+
+Flaskion 2 is being designed as an AI-native application framework. The
+generic Task List uses Flaskion's optional MCP API as a third adapter beside
+HTTP and CLI; authentication and remote deployment integration remain future
+work.
+
+## Current features
+
+- Flask application factory and explicit extension initialization
+- `flaskion.Application` for registering and invoking plain Python use cases
+- Constructor-based service and repository dependencies without a DI container
+- Optional `flaskion.mcp` API backed by FastMCP 4
+- Local stdio and remote Streamable HTTP serving with MCP test support
+- Separate web and JSON API blueprints
+- SQLite, MySQL, or PostgreSQL project configuration
+- SQLAlchemy and Flask-Migrate
+- Conflict-safe model, controller, schema, resource, and authentication generators
+- Session authentication scaffold with CSRF-protected forms
+- Cross-platform virtual-environment invocation
+
+## Installation
+
+```bash
+pipx install flaskion
+# or
+pip install flaskion
+# Optional MCP adapter support
+pip install "flaskion[mcp]"
+```
+
+Flaskion requires Python 3.11 or newer. The core package and optional MCP
+integration share the same supported Python floor.
+
+## Create a project
+
+```bash
+flaskion make:new myproject --db=sqlite
+cd myproject
+source .venv/bin/activate
+flask run
+```
+
+On Windows, activate the environment with `.venv\Scripts\activate`.
+
+Use `--db=mysql` or `--db=postgres` to install and configure the matching SQLAlchemy driver. Use `--no-install` to create files without creating an environment or installing dependencies.
+
+The default creation flow:
+
+1. builds the project in a staging directory;
+2. writes a random development secret and a database URL to `.env`;
+3. initializes Git;
+4. creates `.venv` and installs dependencies;
+5. initializes the Alembic migration repository;
+6. moves the complete project into its final directory.
+
+If a setup command fails, Flaskion reports the command and removes the incomplete staging directory.
+
+## Generated project structure
+
+```text
+myproject/
+├── app/
+│   ├── __init__.py           # Application factory
+│   ├── application.py        # Interface-independent use-case registration
+│   ├── config.py             # Environment-backed configuration
+│   ├── extensions.py         # Unbound Flask extensions
+│   ├── controllers/
+│   ├── models/
+│   ├── routes/
+│   ├── schemas/
+│   ├── static/
+│   └── templates/
+├── migrations/               # Created by `flask db init`
+├── .env.example
+├── requirements.txt
+└── run.py
+```
+
+## Commands
+
+| Command | Description |
+|---|---|
+| `flaskion make:new NAME` | Create a project; accepts `--db` and `--no-install` |
+| `flaskion make:model NAME` | Create and explicitly register a SQLAlchemy model |
+| `flaskion make:schema NAME` | Create a Marshmallow SQLAlchemy schema |
+| `flaskion make:controller NAME` | Create a web controller; accepts `--api` for JSON stubs |
+| `flaskion make:resource NAME` | Atomically create model, controller, schema, and routes; accepts `--api` |
+| `flaskion make:auth` | Create session authentication and CSRF-protected templates |
+
+Generators refuse to overwrite existing files. Multi-file generation is planned before writing, so a conflict does not leave a partially changed project. Names such as `CardGrader`, `card-grader`, and `card_grader` normalize to consistent Python module and class names.
+
+Generated API controller methods return explicit `501 Not Implemented` JSON until application behavior is supplied. Flaskion does not generate pretend persistence logic.
+
+## Database migrations
+
+The normal project-creation flow runs `flask db init`. Create and apply revisions with:
+
+```bash
+flask db migrate -m "Initial schema"
+flask db upgrade
+```
+
+When a project is created with `--no-install`, install its dependencies and run `flask db init` yourself before creating the first revision.
+
+## Authentication scaffold
+
+```bash
+flaskion make:auth
+```
+
+This creates a user model, schema, controller, and login/register/dashboard templates. Forms carry Flask-WTF CSRF tokens, login clears prior session data, passwords must contain at least 12 characters, and logout is POST-only.
+
+This remains starter authentication, not a complete identity product. Production applications still need requirements appropriate to their threat model, such as email verification, password reset, rate limiting, secure-cookie deployment settings, and authorization policies.
+
+## Development
+
+Install the development dependency group with a compatible environment manager, then run:
+
+```bash
+python -m unittest discover -v
+ruff check .
+python -m build
+```
+
+When running directly from a source checkout with the `src/` layout, use an editable install or set `PYTHONPATH=src:.`.
+
+## Runtime usage
+
+Use cases do not inherit from Flaskion classes. Register a plain function, bound service method, or callable object against any message type:
+
+```python
+from dataclasses import dataclass
+
+from flaskion import Application
+
+
+@dataclass(frozen=True)
+class Greet:
+    name: str
+
+
+application = Application()
+application.register(Greet, lambda message: f"Hello, {message.name}")
+
+assert application.handle(Greet("Ada")) == "Hello, Ada"
+```
+
+The decorator form `@application.use_case(Greet)` is available but optional. Services and repository protocols are application-owned; Flaskion does not require base classes or a universal repository abstraction.
+
+## Task List example
+
+The canonical example is under [`examples/task_list`](examples/task_list). It implements create, list, and complete through one `TaskService`, a repository protocol, and a SQLite adapter. HTTP, CLI, and MCP receive the same `Application` instance and invoke the same handlers.
+
+```bash
+PYTHONPATH=src:. flask --app examples.task_list.run run
+PYTHONPATH=src:. python -m examples.task_list.cli create "Write documentation"
+PYTHONPATH=src:. python -m examples.task_list.cli list
+PYTHONPATH=src:. python -m examples.task_list.cli complete 1
+PYTHONPATH=src:. flaskion mcp:serve --app examples.task_list.mcp_server:mcp
+```
+
+Install the MCP adapter with `pip install -e '.[mcp]'`. MCP remains optional:
+FastMCP is imported only by
+`flaskion.mcp`'s private compatibility boundary, never by Task List code.
+
+For a remotely connectable development endpoint, use Streamable HTTP:
+
+```bash
+PYTHONPATH=src:. flaskion mcp:serve \
+  --app examples.task_list.mcp_server:mcp \
+  --transport http --host 127.0.0.1 --port 8000
+```
+
+The MCP endpoint is `http://127.0.0.1:8000/mcp`. Inspect it locally with:
+
+```bash
+npx -y @modelcontextprotocol/inspector --web http://127.0.0.1:8000/mcp
+```
+
+Loopback is the safe default. Binding to a public interface exposes an
+unauthenticated MCP endpoint until Flaskion's remote authentication boundary is
+implemented; use network controls and do not treat the development command as
+a production deployment configuration.
+
+The example intentionally does not include jobs, events, authentication policy, generic middleware, or a dependency-injection container.
+
+## Architecture documents
+
+- [Flaskion 2 architecture](docs/FLASKION_2_ARCHITECTURE.md)
+- [Flaskion 2 roadmap](docs/FLASKION_2_ROADMAP.md)
+- [MCP architecture](docs/MCP_ARCHITECTURE.md)

flaskion-2.0.0a1.dist-info/RECORD

@@ -0,0 +1,51 @@
+flaskion/__init__.py,sha256=oc7ko6xL4Q8Ir3ZXI6oEixqG69pMRMjyeBSCU_Thyak,532
+flaskion/application.py,sha256=WuET75beWgzBIMp7EjWQ_ujifiWQIW9BKohrUgj4vMo,1827
+flaskion/errors.py,sha256=BYwUhpEYVf6lkSVxh84za07Qbzv2ddreKuzPuoes8po,564
+flaskion/mcp/__init__.py,sha256=FbMENzMH4tATJXfNynO6cB1tdYzoSYMNI22S9xgOdGg,362
+flaskion/mcp/_compat.py,sha256=5JCdiz8kO6rH2JwOL0hYddz_pjjuTvAXZnVtjKheUXg,464
+flaskion/mcp/errors.py,sha256=1XAnF4idmrdiEhnRqR6QZW5QKG7rjlFv_6DlOOMjJNs,164
+flaskion/mcp/server.py,sha256=qfLiqT8gs_k12TXFmKI0FPhdYJ2pV1T1nLkz65VnL5o,2841
+flaskion/mcp/testing.py,sha256=B2nA8tbzmOJzRnITEcuVZylDPkh8Rrcg1-FRFLg0fgw,1789
+flaskion_cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+flaskion_cli/cli.py,sha256=NsGe6cBb4Xx-iuOsnsVfVIcJQ3DucYzRMziIswoHvfU,15442
+flaskion_cli/cli_templates/api_controller_template.py.jinja,sha256=bZUx5CbPUsaMTRG1kTANiTZ7l5wMfszCnLwHGu49KRY,818
+flaskion_cli/cli_templates/api_route_template.py.jinja,sha256=fSZ4aWP85RjUF4bcA7WEyTt4EO5cfU8pQ25CabMQoA8,875
+flaskion_cli/cli_templates/auth_controller_template.py.jinja,sha256=SL_fCorysK30_blgpUIPYPQ6UNYvn62HK9NhWXMWqF4,2141
+flaskion_cli/cli_templates/controller_template.py.jinja,sha256=rNx6Bzp5dOYtrC1JiY2qDRRMWyoIoPJGFv0nGbxzRgQ,760
+flaskion_cli/cli_templates/model_template.py.jinja,sha256=-9r9E9x8PwwZQtMUhDs-vDrdeLFE5C7TRCP9ok3X_2k,242
+flaskion_cli/cli_templates/schema_template.py.jinja,sha256=kXSVa_z6IEdIuRKNPgk_n8qetAFRaM20_gAlSIaYH-o,506
+flaskion_cli/cli_templates/user_model_template.py.jinja,sha256=WitpGhhttKKlQc3XwwZ1B64QMnQzbSFqbMzVkh1O9hY,386
+flaskion_cli/cli_templates/user_schema_template.py.jinja,sha256=iyZkzOx3CRWCTb2CqZ7oMmLTZBnKNHiaFfyrtClbwu0,149
+flaskion_cli/cli_templates/web_route_template.py.jinja,sha256=kJpuVC266SWTMQZk3K3shkm6NCdz_bivDyl2CrJ02Y4,894
+flaskion_cli/cli_templates/html/auth/dashboard.html.jinja,sha256=SgwHQryDgGsV5XVpUo8ZNSDcq9fyVOHu3bpvWRem4-w,1829
+flaskion_cli/cli_templates/html/auth/login.html.jinja,sha256=M0Bi-_o9wPs2wn77IlNIT8CkGfP9d_Ir7_4SA_pwjwI,2967
+flaskion_cli/cli_templates/html/auth/register.html.jinja,sha256=tJGSMiEaj8Pa41rww41ipew4_Q-pLwLugehScKAJ9jk,2867
+flaskion_cli/flaskion_template/.env.example,sha256=Z2UjA6vBL4xUtx4nxfM8OC8x6nAkZ0z3mui8gXFwRus,161
+flaskion_cli/flaskion_template/.gitattributes,sha256=Gh2-F2vCM7SZ01pX23UT8pQcmauXWfF3gwyRSb6ZAFs,66
+flaskion_cli/flaskion_template/.gitignore,sha256=Z3xGk7_aeueVvLKemX1jvtuY0oxLCjzx0TG4DYVegoQ,399
+flaskion_cli/flaskion_template/requirements.txt,sha256=brmAW2hNofJ0APKGCEm-_3D0Ukm4nRXk2X2Ta2L08_k,150
+flaskion_cli/flaskion_template/run.py,sha256=THqClv-8M4OWaX9dQJnr9SlsWHbkRLhRRE2m7f4bEP4,150
+flaskion_cli/flaskion_template/app/__init__.py,sha256=DOK-AZEFJYeL6utJFVBamjLad2rEzYnaJDEJOSok0eE,960
+flaskion_cli/flaskion_template/app/application.py,sha256=aJFjiGgbuxaSnyTYK87KCqqTOm2iZMT1slnY8zy-Sas,169
+flaskion_cli/flaskion_template/app/config.py,sha256=Y3h3XRIB-zMGZgfUgEzqSlvVR1KYd7K8XPve8Dsejcw,522
+flaskion_cli/flaskion_template/app/extensions.py,sha256=NHDG1iGGDiVhTL0Edan1qORxGbbTuZiMR59AmUtWSPs,120
+flaskion_cli/flaskion_template/app/controllers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+flaskion_cli/flaskion_template/app/controllers/api_controller.py,sha256=r_iK1axSLva0EWEHi4rCnb4rIaKMcqpW4cTzXZxAjWs,103
+flaskion_cli/flaskion_template/app/controllers/hello_controller.py,sha256=nfG8zcgZho4nnjgopmhnpM-TFiVLJ-uPNGU6umpguzs,138
+flaskion_cli/flaskion_template/app/models/__init__.py,sha256=SOZuzAzL6-PvI1BwHBij3iZvIzxoCewBo19iZBbLfd8,268
+flaskion_cli/flaskion_template/app/models/example.py,sha256=HDP-_gJIW6x8wj42tHaVIndiVxZXatlV_N5Uhm2sKok,716
+flaskion_cli/flaskion_template/app/models/mixin.py,sha256=PSyGkcFcd6IboPgWidF7Og0d6-BUC9iPfBe3vVtJDTM,419
+flaskion_cli/flaskion_template/app/routes/__init__.py,sha256=XkOW1lzN8c2Hmu2QTaW1hbFAJQAj39MQb_-fYucXVmk,225
+flaskion_cli/flaskion_template/app/routes/api_routes.py,sha256=cXfn9Fs1N-QpFJ2r7d0tD313aq1AC_5P9uUO1dBrMQY,336
+flaskion_cli/flaskion_template/app/routes/web_routes.py,sha256=S1B4lnhVFg1iOajcJsLraKGJnNDBPviE3UPq4peWD6E,288
+flaskion_cli/flaskion_template/app/schemas/__init__.py,sha256=5KNtQtkzlhCsJHGgi-fd9bAL81HUR29if7YfJUiG-E8,49
+flaskion_cli/flaskion_template/app/schemas/example_schema.py,sha256=_zkucaMYnCzeSlOxxN0XM3mSTYCejmAlOdFa-jVBjDI,463
+flaskion_cli/flaskion_template/app/static/css/style.css,sha256=RIf-YAJxf_l8h_14sN43nWkhv8tNAzh9xVFiq5KjcKE,1078
+flaskion_cli/flaskion_template/app/static/images/logo.png,sha256=-kob2gwFL63ddvePWqwMqBjxTDUrHuhxSsVwJsdMcnM,243656
+flaskion_cli/flaskion_template/app/templates/base.html,sha256=xP0Sh70Nj59BPSg0OcNNYn1Fo-ivNRNlHQDWZOjm4-U,654
+flaskion_cli/flaskion_template/app/templates/hello.html,sha256=nzQbSAxkY-mkRO4IZgbQaw17OZ7m6IcaqAgCfroy0WE,425
+flaskion-2.0.0a1.dist-info/METADATA,sha256=OHiNQbe0wD2soyk197L3Yei9YSWeJSYSXiF0pPhaWmw,8336
+flaskion-2.0.0a1.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+flaskion-2.0.0a1.dist-info/entry_points.txt,sha256=9jiIsU12_kGt5smQfLBKBSWQaNXSFpmX1RhfGApl40A,50
+flaskion-2.0.0a1.dist-info/top_level.txt,sha256=fr3p2GQtTgwP4tZW12G6FvAH-yBI--ywcskqopvKONo,22
+flaskion-2.0.0a1.dist-info/RECORD,,

flaskion-2.0.0a1.dist-info/WHEEL

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

flaskion-2.0.0a1.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+flaskion = flaskion_cli.cli:cli

flaskion-2.0.0a1.dist-info/top_level.txt

@@ -0,0 +1,2 @@
+flaskion
+flaskion_cli