django-spec-cli 0.1.0__py3-none-any.whl

django_spec_cli/spec_command.py

@@ -0,0 +1,344 @@
+"""``SpecCommand`` - a registry of specs as one management command."""
+
+from __future__ import annotations
+
+import argparse
+import inspect
+from collections.abc import Mapping
+from typing import Any, TextIO, cast
+
+from django.core.exceptions import ImproperlyConfigured
+from django.core.management.base import BaseCommand, CommandError, CommandParser
+from django.utils.translation import gettext
+from django_service_specs import (
+    DEFAULT_POOL_SEEDS,
+    ActionUnavailable,
+    AdditionalInputRequired,
+    DispatchError,
+    InvalidArguments,
+    Parameters,
+    PoolSeeds,
+    PrincipalUnavailable,
+    RegisteredSpec,
+    SelectorSpec,
+    ServiceError,
+    ServiceSpec,
+    ServiceValidationError,
+    SpecRegistry,
+    coerce_flat,
+    dispatch,
+    kernel_spec,
+    present,
+    refusal_messages,
+    relax_partial,
+    resolve_principal,
+    server_owned_keys,
+    unguarded_specs,
+)
+
+from django_spec_cli.argv.add_spec_arguments import add_spec_arguments
+from django_spec_cli.argv.describe_parameters import describe_parameters
+from django_spec_cli.argv.parsed_arguments import parsed_arguments
+from django_spec_cli.argv.utils import option_string
+from django_spec_cli.exit_code_for import exit_code_for
+from django_spec_cli.render.render_result import render_result
+from django_spec_cli.render.wants_table import wants_table
+from django_spec_cli.report.unguarded_message import unguarded_message
+from django_spec_cli.types.exit_code import ExitCode
+
+_OWN_OPTIONS = frozenset({"--as-user", "--json", "--table"})
+"""The options every subcommand owns, which no spec parameter may map to."""
+
+
+class SpecCommand(BaseCommand):
+    """A management command serving every spec in a registry, one subcommand each.
+
+    Declared by subclassing, in the project's own ``management/commands/``
+    module, which names the registry::
+
+        class Command(SpecCommand):
+            registry = notes_registry
+
+    The registry is the subclass's to name, so one project can expose two
+    registries under two command names. It is read when the parser is built,
+    and a command naming none is refused then, as ``ImproperlyConfigured``.
+    ``pool_seeds`` names the seeds the specs' callables are resolved with, as
+    ``SpecView.pool_seeds`` does, for a registry whose callables read one.
+
+    It is run as ``manage.py <command> <spec> --as-user USER [--json|--table]
+    [--option value ...]``, or ``manage.py <command> --explain``:
+
+    - **One subcommand per registry entry**, named after the entry with each
+      ``_`` shown as ``-``. Its options are the spec's parameters, as
+      [`add_spec_arguments`][django_spec_cli.argv.add_spec_arguments.add_spec_arguments]
+      spells them, less any key the server fills
+      ([`server_owned_keys`][django_service_specs.specs.server_owned_keys.server_owned_keys]).
+      No option is matched by a prefix: an abbreviation is refused rather
+      than read as whichever option it begins.
+    - **``--as-user`` is required.** Its value goes through
+      [`resolve_as_user`][django_spec_cli.spec_command.SpecCommand.resolve_as_user],
+      and the user it returns is the principal ``dispatch`` runs the spec
+      for, with the permission checks enforced: the command passes no
+      ``Grant``, and opens no transaction of its own.
+    - The result goes through the spec's presenter and is written as a table
+      or as JSON Lines: ``--table`` and ``--json`` choose, then the
+      ``SPEC_CLI_OUTPUT`` setting, then whether stdout is a
+      terminal ([`wants_table`][django_spec_cli.render.wants_table.wants_table]).
+    - A refusal ends the run with a ``CommandError`` carrying its message and
+      an [`ExitCode`][django_spec_cli.types.exit_code.ExitCode].
+    - ``--explain`` runs no spec: it lists the ones that authorize nothing,
+      as the system check does.
+
+    The command is a mistake-prevention and attribution surface, **never an
+    authorization boundary**: whoever can run ``manage.py`` can run any code
+    the project can, and names any user they like with ``--as-user``. What
+    it guarantees is that a run is attributed to a user and checked against
+    the permissions that user holds.
+
+    Sync only: it dispatches with ``dispatch``, never ``adispatch``.
+    """
+
+    registry: SpecRegistry
+    pool_seeds: PoolSeeds = DEFAULT_POOL_SEEDS
+    help = "Run one operation of a registry of specs, as the user --as-user names."
+
+    _command_label: str
+    _parser: CommandParser
+    _entries: dict[str, RegisteredSpec]
+
+    def create_parser(self, prog_name: str, subcommand: str, **kwargs: Any) -> CommandParser:
+        """Django's parser, with this command's options added and no option read by its prefix."""
+        self._command_label = subcommand
+        parser = super().create_parser(prog_name, subcommand, **kwargs)
+        # Django's own options are on this parser, and a prefix of one is no
+        # more an option here than on a subcommand.
+        parser.allow_abbrev = False
+        self._parser = parser
+        return parser
+
+    def add_arguments(self, parser: CommandParser) -> None:
+        """``--explain``, then one subcommand per registry entry, each with its spec's options.
+
+        Every subcommand is built here, on every run: one spec's options are
+        a handful of ``add_argument`` calls, and building them eagerly is
+        what lets ``--help`` list every spec.
+
+        Raises:
+            ImproperlyConfigured: the class names no ``SpecRegistry``; two
+                entries are one subcommand, ``a_b`` and ``a-b``; or a spec
+                parameter maps to an option the command owns - ``--as-user``,
+                ``--json``, ``--table``, or one of Django's own, such as
+                ``--settings``, which ``manage.py`` reads from anywhere on
+                the line.
+        """
+        registry = getattr(self, "registry", None)
+        if not isinstance(registry, SpecRegistry):
+            cls = type(self)
+            raise ImproperlyConfigured(
+                f"{cls.__module__}.{cls.__qualname__} names no registry: declare "
+                f"registry = SpecRegistry(...) on the class (got {registry!r})."
+            )
+        parser.add_argument(
+            "--explain",
+            action="store_true",
+            help="List the specs this command serves that authorize nothing, and run none.",
+        )
+        # Every option string the command owns: its subcommands' own and
+        # Django's. ``manage.py`` reads ``--settings`` and ``--pythonpath``
+        # from anywhere on the line, so a spec option of either name would
+        # configure Django instead. Read from argparse's map of option
+        # strings, which carries no public reader, so Django's list is never
+        # copied here to drift.
+        reserved = _OWN_OPTIONS | frozenset(parser._option_string_actions)
+        subparsers = parser.add_subparsers(dest="spec_name", metavar="spec", title="specs")
+        self._entries = {}
+        for entry in registry:
+            name = entry.name.replace("_", "-")
+            if name in self._entries:
+                raise ImproperlyConfigured(
+                    f"The specs {self._entries[name].name!r} and {entry.name!r} are both the "
+                    f"subcommand {name!r}; register one of them under another name."
+                )
+            self._entries[name] = entry
+            spec = kernel_spec(entry.spec)
+            parameters = _sendable(spec)
+            summary = _summary(spec, entry.name)
+            subparser = subparsers.add_parser(
+                name,
+                help=summary.replace("%", "%%"),
+                description=summary,
+                epilog=_unsendable(parameters),
+                # Without it, ``--as-user 7`` beside a parameter ``as_user_id``
+                # is one typo from ``--as-user-i 7``, which argparse would read
+                # as ``--as-user-id``.
+                allow_abbrev=False,
+            )
+            subparser.add_argument(
+                "--as-user",
+                dest="as_user",
+                required=True,
+                metavar="USER",
+                help="The user the operation runs as, and is checked and recorded for.",
+            )
+            formats = subparser.add_mutually_exclusive_group()
+            formats.add_argument(
+                "--json",
+                dest="output_format",
+                action="store_const",
+                const="json",
+                help="Write the result as JSON Lines, one row per line.",
+            )
+            formats.add_argument(
+                "--table",
+                dest="output_format",
+                action="store_const",
+                const="table",
+                help="Write the result as a table.",
+            )
+            add_spec_arguments(subparser, parameters, reserved=reserved)
+
+    def resolve_as_user(self, value: str) -> Any:
+        """The user ``--as-user VALUE`` names, or ``PrincipalUnavailable``.
+
+        By primary key, through
+        [`resolve_principal`][django_service_specs.authorization.resolve_principal.resolve_principal],
+        which refuses a missing row, a malformed key and a deactivated
+        account. A project whose runbooks name people by username or email
+        overrides this method with that lookup.
+
+        The contract is: return an authenticated user, or raise
+        [`PrincipalUnavailable`][django_service_specs.authorization.principal_unavailable.PrincipalUnavailable],
+        which ends the run with ``ExitCode.PRINCIPAL_UNAVAILABLE``. Anything
+        else an override raises is a bug in the lookup, and propagates. An
+        override need not refuse a deactivated user itself: ``dispatch``
+        refuses one whatever the lookup returns. A lookup answering ``None``
+        or an anonymous user is refused the same way, by the command. There is
+        no fallback to an anonymous user and no user of the command's own.
+        """
+        return resolve_principal(value)
+
+    def handle(self, *args: Any, **options: Any) -> None:
+        name = options["spec_name"]
+        if options["explain"]:
+            if name is not None:
+                self._parser.error("--explain runs no spec; leave out the spec name.")
+            self._explain()
+            return
+        if name is None:
+            self._parser.error(
+                f"manage.py {self._command_label} serves no spec: its registry is empty."
+                if not self._entries
+                else "name a spec to run, or pass --explain. --help lists the specs."
+            )
+        entry = self._entries[name]
+        spec = kernel_spec(entry.spec)
+        parameters = spec.parameters()
+        raw = parsed_arguments(argparse.Namespace(**options), parameters)
+        # Read before the run, not after it: a setting that names no format
+        # raises, and raising once a write has committed reports a failure for
+        # an operation that happened, which a script retries.
+        # Django's ``OutputWrapper`` is an ``io.TextIOBase`` rather than a
+        # ``typing.TextIO``, and answers the ``write`` and ``isatty`` both
+        # functions read for the stream it wraps.
+        stdout = cast("TextIO", self.stdout)
+        table = wants_table(stdout, requested=options["output_format"])
+        try:
+            principal = self.resolve_as_user(options["as_user"])
+            # A lookup is the project's, and ``filter(...).first()`` is the
+            # obvious one: a typo then answers ``None``, which an open spec
+            # would run for. Each condition is held by its own test:
+            # test_a_lookup_answering_none_is_refused and
+            # test_a_lookup_answering_an_anonymous_user_is_refused.
+            if principal is None or not getattr(principal, "is_authenticated", False):
+                raise PrincipalUnavailable(
+                    f"The user {options['as_user']!r} resolved to nobody who can sign in."
+                )
+            result = dispatch(
+                entry.spec,
+                principal=principal,
+                arguments=coerce_flat(parameters, raw),
+                pool_seeds=self.pool_seeds,
+            )
+        except (DispatchError, ServiceError) as error:
+            raise CommandError(_message(error), returncode=int(exit_code_for(error))) from error
+        if result.kind == "not_found":
+            raise CommandError(gettext("Not found."), returncode=int(ExitCode.NOT_FOUND))
+        render_result(present(entry.spec, result), spec.output(), stdout, table=table)
+
+    def _explain(self) -> None:
+        label = self._command_label
+        if not self._entries:
+            self.stdout.write(f"manage.py {label} serves no spec: its registry is empty.")
+            return
+        found = unguarded_specs(self.registry)
+        if not found:
+            self.stdout.write(
+                f"Every spec manage.py {label} serves declares a permission check other than "
+                "Unrestricted."
+            )
+        for unguarded in found:
+            self.stdout.write(unguarded_message(unguarded, label))
+
+
+def _sendable(spec: ServiceSpec | SelectorSpec) -> Parameters:
+    """What a caller may send, as the shape check reads it: required only where dispatch demands it.
+
+    Relaxed for ``partial`` by the shape check's own reading, so ``--help``
+    marks ``(required)`` exactly where an omission is refused
+    (test_a_partial_spec_requires_only_what_names_its_row), and without the
+    keys the server fills, whose value a caller's would never replace
+    (test_a_key_the_server_fills_is_no_option).
+    """
+    owned = server_owned_keys(spec)
+    relaxed = relax_partial(spec, spec.parameters())
+    return Parameters.of(*(param for param in relaxed if param.name not in owned))
+
+
+def _summary(spec: ServiceSpec | SelectorSpec, name: str) -> str:
+    """The first paragraph of what the spec's callable says about itself, and whether it reads or writes.
+
+    Only a function's or a method's own docstring: a ``partial`` or a
+    callable object answers with its class's, which describes the class and
+    not the operation. With none, the registered name stands in. Both halves
+    of the guard are held by test_only_a_function_s_or_a_method_s_own_docstring_is_read:
+    its bound method (``ismethod``) and its ``partial`` (the guard itself).
+    """
+    call = spec.selector if isinstance(spec, SelectorSpec) else spec.service
+    kind = "read" if isinstance(spec, SelectorSpec) else "write"
+    doc = call.__doc__ if inspect.isfunction(call) or inspect.ismethod(call) else None
+    first = " ".join(inspect.cleandoc(doc).split("\n\n")[0].split()) if doc else name
+    return f"{first} ({kind})"
+
+
+def _unsendable(parameters: Parameters) -> str | None:
+    """The epilog naming the parameters no option can send, or ``None`` when there are none."""
+    names = [d.name for d in describe_parameters(parameters) if not d.argv]
+    return f"Takes arguments a command line cannot send: {', '.join(names)}." if names else None
+
+
+def _message(error: DispatchError | ServiceError) -> str:
+    """A refusal as the text a person reads: its message, and each refused field on a line."""
+    if isinstance(error, InvalidArguments):
+        return _with_fields(error.message, error.detail)
+    # Two conditions, each held by a case of test_a_service_s_refusal_is_its_exit_code:
+    # [other] for the type (a plain ServiceError has no ``detail``) and
+    # [validation] for the detail (a string is one message, not a tree).
+    if isinstance(error, ServiceValidationError) and isinstance(error.detail, Mapping | list):
+        return _with_fields(error.message, error.detail)
+    if isinstance(error, ActionUnavailable):
+        return f"{error.message} (code: {error.code})"
+    # Two conditions, each held by a case of test_a_service_s_refusal_is_its_exit_code:
+    # [other] for the type (a plain ServiceError has no ``schema``) and
+    # [input_bare] for the schema (with none there is nothing to name).
+    if isinstance(error, AdditionalInputRequired) and error.schema:
+        options = ", ".join(option_string(key) for key in error.schema)
+        return f"{error.message} Run it again with: {options}"
+    return str(error.message)
+
+
+def _with_fields(header: Any, detail: Any) -> str:
+    """``header``, then each message in ``detail`` on its own line, after its path."""
+    rows = [
+        f"{'.'.join(path)}: {text}" if path else text for path, text in refusal_messages(detail)
+    ]
+    return "\n".join([str(header), *rows])

django_spec_cli/types/__init__.py

@@ -0,0 +1,7 @@
+"""Value types: the exit status a command's run ends with."""
+
+from django_spec_cli.types.exit_code import ExitCode
+
+__all__ = [
+    "ExitCode",
+]

django_spec_cli/types/exit_code.py

@@ -0,0 +1,49 @@
+"""``ExitCode`` - what a ``SpecCommand``'s exit status says about the run."""
+
+from __future__ import annotations
+
+from enum import IntEnum
+
+
+class ExitCode(IntEnum):
+    """The exit status of a [`SpecCommand`][django_spec_cli.spec_command.SpecCommand] run, a public contract.
+
+    A script branches on these, so a member's number never changes and a
+    number is never reused. Each says who refused and what the caller can do
+    about it, read the way the HTTP transport reads the same refusals:
+
+    | Code | Member | The run | Raised for |
+    | --- | --- | --- | --- |
+    | 0 | `SUCCESS` | ran, and its result was written | |
+    | 1 | `ERROR` | failed in a way nobody declared | anything else, with a traceback |
+    | 2 | `USAGE` | never started: the command line was malformed | argparse's own refusals |
+    | 3 | `INVALID_ARGUMENTS` | was refused its arguments | `InvalidArguments`, `ServiceValidationError`, any other `DispatchError` |
+    | 4 | `NOT_PERMITTED` | was refused to the principal | `NotPermitted` |
+    | 5 | `PRINCIPAL_UNAVAILABLE` | had nobody to run as | `PrincipalUnavailable` |
+    | 6 | `NOT_FOUND` | found no row to act on | a `not_found` result, `ServiceNotFound` |
+    | 7 | `CONFLICT` | was refused by the row's current state | `ServiceConflict`, `ActionUnavailable` |
+    | 8 | `INPUT_REQUIRED` | needs a value it was not given | `AdditionalInputRequired` |
+    | 9 | `REFUSED` | was refused by the operation's own rule | any other `ServiceError` |
+
+    ``INPUT_REQUIRED`` has its own code because a command line cannot ask:
+    the operator re-runs the command with the option the message names, and
+    a script that knows it may answer does so. ``ActionUnavailable`` is a
+    conflict, as its base is; its ``code`` is in the message.
+
+    ``USAGE`` is the command line's: ``manage.py`` exits 2 on a malformed
+    line. Through ``call_command`` Django raises every parser error as a
+    ``CommandError`` with ``returncode`` 1 instead, and the command's own
+    usage errors take the same path, so a caller there reads a usage error
+    by its message.
+    """
+
+    SUCCESS = 0
+    ERROR = 1
+    USAGE = 2
+    INVALID_ARGUMENTS = 3
+    NOT_PERMITTED = 4
+    PRINCIPAL_UNAVAILABLE = 5
+    NOT_FOUND = 6
+    CONFLICT = 7
+    INPUT_REQUIRED = 8
+    REFUSED = 9

django_spec_cli/version.py

@@ -0,0 +1,7 @@
+"""The single source of truth for this package's version."""
+
+from __future__ import annotations
+
+__version__: str = "0.1.0"
+
+__all__ = ["__version__"]

django_spec_cli-0.1.0.dist-info/METADATA

@@ -0,0 +1,113 @@
+Metadata-Version: 2.5
+Name: django-spec-cli
+Version: 0.1.0
+Summary: Run a django-service-specs registry from manage.py: one subcommand per spec, options generated from its parameters, exit codes for every refusal.
+Project-URL: Homepage, https://github.com/Artui/django-spec-cli
+Project-URL: Repository, https://github.com/Artui/django-spec-cli
+Project-URL: Issues, https://github.com/Artui/django-spec-cli/issues
+Author-email: Artur Veres <artur8118@gmail.com>
+License: MIT
+License-File: LICENSE
+Keywords: cli,dispatch,django,management-command,services,specs
+Classifier: Development Status :: 2 - Pre-Alpha
+Classifier: Environment :: Web Environment
+Classifier: Framework :: Django
+Classifier: Framework :: Django :: 4.2
+Classifier: Framework :: Django :: 5.0
+Classifier: Framework :: Django :: 5.1
+Classifier: Framework :: Django :: 5.2
+Classifier: Framework :: Django :: 6.0
+Classifier: Framework :: Django :: 6.1
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.10
+Requires-Dist: django-service-specs>=0.10.0
+Requires-Dist: django>=4.2
+Description-Content-Type: text/markdown
+
+# django-spec-cli
+
+[![CI](https://github.com/Artui/django-spec-cli/workflows/tests/badge.svg)](https://github.com/Artui/django-spec-cli/actions/workflows/tests.yml)
+[![PyPI](https://img.shields.io/pypi/v/django-spec-cli.svg)](https://pypi.org/project/django-spec-cli/)
+[![Python versions](https://img.shields.io/pypi/pyversions/django-spec-cli.svg)](https://pypi.org/project/django-spec-cli/)
+[![Django versions](https://img.shields.io/pypi/djversions/django-spec-cli.svg)](https://pypi.org/project/django-spec-cli/)
+[![Docs](https://img.shields.io/badge/docs-artui.github.io-blue.svg)](https://artui.github.io/django-spec-cli/)
+[![Coverage](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/Artui/django-spec-cli/gh-pages/coverage.json)](https://github.com/Artui/django-spec-cli/actions/workflows/tests.yml)
+[![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)](https://github.com/astral-sh/ruff)
+[![License](https://img.shields.io/pypi/l/django-spec-cli.svg)](LICENSE)
+
+Run a [`django-service-specs`](https://github.com/Artui/django-service-specs)
+registry from `manage.py`: one subcommand per spec, an option for each of its
+parameters, a principal named on the command line, and an exit code for every
+refusal.
+
+It is the kernel's management-command transport, moved out of the kernel with
+its history so the kernel carries no transport. The command line, the exit
+codes and the `SpecCommand` subclass contract are the ones the kernel shipped;
+the import path, the system check ids and the setting key are this package's.
+
+## Install
+
+```bash
+pip install django-spec-cli
+```
+
+Python 3.10 or later, Django 4.2 or later, and `django-service-specs` 0.10.0 or
+later, which it installs.
+
+## Quickstart
+
+Subclass `SpecCommand` in one of your apps' `management/commands/` modules and
+name a registry; the module's name is the command's:
+
+```python
+# yourapp/management/commands/notes.py
+from django_spec_cli import SpecCommand
+
+from yourapp.specs import notes  # a django_service_specs.SpecRegistry
+
+
+class Command(SpecCommand):
+    registry = notes
+```
+
+```console
+$ python manage.py notes rename-note --as-user 1 --pk 1 --title Final --json
+{"id":1,"title":"Final"}
+```
+
+The run goes through the kernel's `dispatch`, so the permission checks are
+enforced for the user `--as-user` names. `--explain` lists the specs that
+authorize nothing.
+
+## The system check
+
+List `"django_spec_cli"` in `INSTALLED_APPS` and `manage.py check` reports
+every open spec a `SpecCommand` serves as `django_spec_cli.W001`, and a command
+that could not be loaded as `django_spec_cli.W003`. The command itself needs no
+app listed.
+
+Until the kernel removes its own copy of the command, kernel 0.10.x still
+registers `django_service_specs.W001` and `W003` over its own `SpecCommand`. A
+project listing both `"django_service_specs"` and `"django_spec_cli"` sees both
+ids: each walk reports the commands subclassing its own class, and a command
+that cannot be loaded is reported by each. A project that moves its imports
+here and lists only `"django_service_specs"` gets no check for the moved
+commands, so list `"django_spec_cli"`.
+
+## Documentation
+
+<https://artui.github.io/django-spec-cli/>
+
+## License
+
+MIT. See [LICENSE](LICENSE).

django_spec_cli-0.1.0.dist-info/RECORD

@@ -0,0 +1,28 @@
+django_spec_cli/__init__.py,sha256=U4p6xCjWczZuNmMn-uzhbWLAe9vir0HqS2JHQ4HpJLI,1176
+django_spec_cli/apps.py,sha256=EbrYxNJNne6Pb3BacNdI72t5kUeMBGf4TE3714klLpU,1164
+django_spec_cli/checks.py,sha256=ijY2pD-IwTE8aukUJq12BGhW7hSxlUSpJdPqsHnsHXA,6444
+django_spec_cli/exit_code_for.py,sha256=0dGnxKNTb208Z1MX6wrBAFGI6mzDTTmu8XxnmFub_wE,2076
+django_spec_cli/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+django_spec_cli/settings.py,sha256=EUigKdFmZ3jqS2VxAWH8wj2viyfbP6ozOVjk3rt4QaM,1444
+django_spec_cli/spec_command.py,sha256=RJmYdIZosrO5rMbSsU17eQvVv_3fZB7Htqw2sXM9WtY,16467
+django_spec_cli/version.py,sha256=IGt2-6r71nTeUfPEK_x1lNeMEBrz0uYGAfUvfX0lTVs,152
+django_spec_cli/argv/__init__.py,sha256=ziDCgFVROkRj1FQ44BDJEDm1BeqZKNmpmBg8WTTiiDA,496
+django_spec_cli/argv/add_spec_arguments.py,sha256=0QMg6fhEvCSXvV-lVDC0pUw3Eu9wfdEhVmr79H1QkF0,8145
+django_spec_cli/argv/describe_parameters.py,sha256=vP3pZcb43aZSxfXCGd_bZadJgl9DFRQLhjQi9ln3zMA,3424
+django_spec_cli/argv/parameter_descriptor.py,sha256=MwMruNhDzU0WQPmcyqV7x0R_QNyBmmwP2Tcn5DkTmTk,2624
+django_spec_cli/argv/parsed_arguments.py,sha256=JotsSaHQLoKyuQp98n7DgPfQXK08Xqu_oc6wzV_Y0wg,2299
+django_spec_cli/argv/utils.py,sha256=4Cnyvx-bdHaTH1c2p1vTwJqkVbgqqNn9Vp3poTqHSS0,836
+django_spec_cli/render/__init__.py,sha256=z5GsGciCYcd-qMzNXV9V0GtCo-KV6HOXlFzo82MDcoI,449
+django_spec_cli/render/render_json_lines.py,sha256=Gue2rASL8Xn1fqtxB_LuUE9qcTyGsUUJhl_hFOp45qM,2031
+django_spec_cli/render/render_result.py,sha256=KEF3Um9yEl4WzhTSThK_hGy9yFNxw9OLfKV1lHH4fic,3291
+django_spec_cli/render/render_table.py,sha256=lUlT729OQI5BSbYzO8KWa19T7WAFNk0JgXlXOxQytR0,9130
+django_spec_cli/render/utils.py,sha256=OgbsBsZ-0_KhHvV50h8r2DPyqRIqaKcuDHRCluzI43o,537
+django_spec_cli/render/wants_table.py,sha256=FWTtgG1lJXTUxXxG31LIzV6YY3CkQYhHSKyWkt9RDxs,1723
+django_spec_cli/report/__init__.py,sha256=Jt58bnjKYTuqmcZ_aF47mtMEV_AVhyi1Wa0tcVcjUWM,216
+django_spec_cli/report/unguarded_message.py,sha256=-cWPjS2cnHMt0Rb1qq7kRU6k-p99sUovXFzGU7h2nQc,1177
+django_spec_cli/types/__init__.py,sha256=Eey5XTKebuSbCkfQ6EiP3qN3iEP6_kYl1Ctqcti1Em4,147
+django_spec_cli/types/exit_code.py,sha256=QgDRQkhMzdesIaJg04ee214VduxPnGCThTXMgQ6PLzI,2296
+django_spec_cli-0.1.0.dist-info/METADATA,sha256=yfTtvsTD3VDj7pdRLFdhkRV5gEsp1JBCUvP5dBayYRQ,4912
+django_spec_cli-0.1.0.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+django_spec_cli-0.1.0.dist-info/licenses/LICENSE,sha256=0rCDnUPa87Fm67SxYMrdqEdLV6UiMENH6NCPLZ_KT5M,1068
+django_spec_cli-0.1.0.dist-info/RECORD,,

django_spec_cli-0.1.0.dist-info/WHEEL

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

django_spec_cli-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Artur Veres
+
+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.