conclude 1.0.0__py3-none-any.whl

conclude/merge.py

@@ -0,0 +1,58 @@
+"""The merge itself: layers, lowest priority first.
+
+Design: every layer (defaults, a config file, environment variables,
+CLI flags) produces a dict of the *same* keys, using ``None`` (or
+"not present" -- simply omitting the key) to mean "this layer
+expresses no opinion". :func:`resolve` walks the layers from lowest
+to highest priority and lets later, non-``None`` values overwrite
+earlier ones. This avoids nested if/elif/else chains entirely --
+adding a new setting to an application built on conclude means adding
+one entry to its own ``DEFAULTS`` dict, one caster, and (if it should
+be settable that way) one CLI flag and one env var mapping, nothing
+else.
+"""
+
+from collections.abc import Mapping
+from typing import Any
+
+from conclude.infer import Caster
+
+
+def resolve(
+    cli: Mapping[str, Any],
+    env: Mapping[str, Any],
+    config_file: Mapping[str, Any],
+    defaults: Mapping[str, Any],
+    casters: Mapping[str, Caster],
+    *,
+    developer: Mapping[str, Any] | None = None,
+) -> dict[str, Any]:
+    """Merge ``defaults < config_file < env < developer < cli``,
+    casting each value as it lands. ``developer`` (the private,
+    project-local developer config layer -- see
+    :mod:`conclude.developer`) is optional and, when given, sits
+    between the environment and the CLI.
+
+    Returns a plain dict of fully-resolved, correctly-typed settings --
+    every key in ``defaults`` is present, plus any key from a layer
+    that ``casters`` knows how to cast (a layer key with no matching
+    caster is silently ignored, so a config file or environment can
+    carry unrelated keys without upsetting the merge).
+
+    A required-ness check (e.g. "this particular key must not still be
+    None once everything is merged") is a caller-level concern, not a
+    merging one -- ``resolve`` never raises for a still-``None`` result,
+    only for a caster itself raising on a value it was actually given
+    (e.g. an unparseable number).
+    """
+    merged: dict[str, Any] = {}
+    for layer in (defaults, config_file, env, developer or {}, cli):
+        for key, value in layer.items():
+            if key not in casters:
+                continue
+            if value is None:
+                continue
+            merged[key] = casters[key](value)
+    for key, value in defaults.items():
+        merged.setdefault(key, value)
+    return merged

conclude/naming.py

@@ -0,0 +1,58 @@
+"""Deriving the conventional name for a setting in each layer -- its
+CLI flag, its environment variable, its config-file key -- from its
+Python name alone, so an application writes that name exactly once
+(as a key in its defaults dict) instead of once per layer.
+"""
+
+import re
+
+_NON_IDENTIFIER_CHARS = re.compile(r"[^0-9a-zA-Z_]")
+
+
+def cli_flag_name(key: str) -> str:
+    """``"filter_col"`` -> ``"--filter-col"``."""
+    return "--" + key.replace("_", "-")
+
+
+def env_var_name(app_name: str, key: str) -> str:
+    """``("remind", "retries")`` -> ``"REMIND_RETRIES"``.
+
+    A hyphen (or any other character that can't appear in a shell
+    environment variable name) in either part is replaced with an
+    underscore first -- e.g. ``("my-app", "foo_bar")`` ->
+    ``"MY_APP_FOO_BAR"``, not the shell-illegal ``"MY-APP_FOO_BAR"``
+    a bare ``.upper()`` would otherwise produce. Common for the app
+    name in particular, since "my-app"-style hyphenated names are a
+    normal CLI-tool naming convention that an app's own ``name`` is
+    often taken straight from (e.g. its package name).
+
+    A leading underscore is added if the result would otherwise start
+    with a digit (``("123app", "foo")`` -> ``"_123APP_FOO"``, not the
+    equally shell-illegal ``"123APP_FOO"`` -- a shell identifier can't
+    start with a digit even though it can contain one).
+
+    One thing this can't fix: two app names that only differ by which
+    non-identifier character they use in the same position --
+    ``"my-app"`` and ``"my_app"``, say -- sanitize to the *same* env
+    var prefix. Not a concern for a single app calling this on its own
+    name, but worth knowing if you're generating names for several
+    apps at once.
+    """
+    name = f"{_sanitize(app_name)}_{_sanitize(key)}".upper()
+    if name[:1].isdigit():
+        name = f"_{name}"
+    return name
+
+
+def config_key_name(key: str) -> str:
+    """The config-file key for ``key`` -- always just ``key`` itself,
+    since a config file's keys already *are* your defaults dict's
+    keys. Provided for symmetry with :func:`cli_flag_name`/
+    :func:`env_var_name`, and so calling code never has to special-case
+    "no translation needed" for this one layer.
+    """
+    return key
+
+
+def _sanitize(text: str) -> str:
+    return _NON_IDENTIFIER_CHARS.sub("_", text)

conclude/paths.py

@@ -0,0 +1,26 @@
+"""The conventional per-app config file locations."""
+
+from pathlib import Path
+
+
+def default_config_home_path(app_name: str) -> Path:
+    """``~/.config/<app_name>/config.toml`` -- the usual user-global
+    config file location (XDG-style, minus actually honoring
+    ``$XDG_CONFIG_HOME``; pass your own path to the loading functions
+    instead if your app needs that).
+    """
+    return Path.home() / ".config" / app_name / "config.toml"
+
+
+def default_config_system_path(app_name: str) -> Path:
+    """``/etc/<app_name>/config.toml`` -- the conventional system-wide
+    config file location, shared by every user on the machine (the
+    lowest-priority config file: any user-global, project-local, env,
+    or CLI value overrides it).
+
+    Unlike the user-global path this is never read unless the app opts
+    in (``config_system_path=AUTO`` on :class:`conclude.App`), since
+    silently picking up machine-wide configuration is a decision about
+    the program, not something that should happen by default.
+    """
+    return Path("/etc") / app_name / "config.toml"

conclude/templates.py

@@ -0,0 +1,83 @@
+"""Rendering a setting's default value as plain text, an ``.env``
+value, or a TOML value -- the building blocks behind
+:meth:`conclude.App.format_env`, :meth:`conclude.App.format_toml`, and
+:meth:`conclude.App.format_cli`, which generate a ready-to-fill-in
+configuration template (or a bit of reference documentation) straight
+from an app's ``defaults``, so there's no hand-written example config
+to keep in sync with them.
+
+Unlike :mod:`conclude.formatters`, whose output is a shell-quoted CLI
+token, everything here renders for a *reader* or a *file*: unquoted
+``localhost``, not ``'localhost'``.
+"""
+
+import re
+import shlex
+from collections.abc import Callable
+from typing import Any
+
+from conclude.tomlwrite import toml_string
+
+# Characters that never need quoting in an .env value: word characters
+# (letters, digits, "_" -- Unicode-aware, so "café" stays bare) plus a
+# few punctuation marks that are unremarkable in every .env dialect.
+_ENV_BARE_RE = re.compile(r"[\w./:@%+,-]*")
+
+_ENV_DOUBLE_QUOTE_ESCAPES = {"\\": "\\\\", '"': '\\"', "\n": "\\n", "\t": "\\t", "\r": "\\r"}
+
+
+def plain_text(value: Any, formatter: Callable[[Any], str | None] | None = None) -> str | None:
+    """``value`` as unquoted, human-readable text, or ``None`` for
+    "no value" (an unset ``None`` setting).
+
+    A bool is ``true``/``false`` (never the bare-flag-or-nothing shape a
+    CLI formatter gives it); a list is comma-joined, matching what
+    :func:`conclude.cast_comma_list` casts back out of. ``formatter``,
+    if given, is an explicit per-setting :data:`conclude.Formatter`
+    override -- its (shell-quoted) output is unquoted again, so a
+    setting with a custom caster/formatter pair renders as text that
+    casts back to the same value.
+    """
+    if value is None:
+        return None
+    if isinstance(value, bool):
+        return "true" if value else "false"
+    if formatter is not None:
+        rendered = formatter(value)
+        if rendered is None:
+            return None
+        return " ".join(shlex.split(rendered))
+    if isinstance(value, (list, tuple)):
+        return ",".join(str(item) for item in value)
+    return str(value)
+
+
+def env_value(text: str) -> str:
+    """``text`` as the right-hand side of a ``NAME=value`` line that
+    :func:`conclude.load_dotenv` reads back as exactly ``text``: bare
+    when it's made only of unremarkable characters, single-quoted
+    (taken literally) when it has anything else, and double-quoted with
+    backslash escapes only when it contains a single quote or a
+    newline/tab/carriage return, which single quotes can't carry.
+    """
+    if _ENV_BARE_RE.fullmatch(text):
+        return text
+    if "'" not in text and not any(ch in text for ch in "\n\t\r"):
+        return f"'{text}'"
+    return '"' + "".join(_ENV_DOUBLE_QUOTE_ESCAPES.get(ch, ch) for ch in text) + '"'
+
+
+def toml_value(value: Any) -> str:
+    """``value`` as a native TOML value: ``true``/``false``, an integer
+    or float as-is, a list as an array, and anything else as a quoted
+    string.
+    """
+    if isinstance(value, bool):
+        return "true" if value else "false"
+    if isinstance(value, int):
+        return str(value)
+    if isinstance(value, float):
+        return repr(value)
+    if isinstance(value, (list, tuple)):
+        return "[" + ", ".join(toml_value(item) for item in value) + "]"
+    return toml_string(str(value))

conclude/tomlwrite.py

@@ -0,0 +1,29 @@
+"""Writing (not reading) small bits of TOML -- for an app feature like
+"print me a ready-to-paste config entry for what I just set up".
+"""
+
+import re
+
+_TOML_BARE_KEY_RE = re.compile(r"^[A-Za-z0-9_-]+$")
+_TOML_CONTROL_RE = re.compile(r"[\x00-\x1f\x7f]")
+
+
+def toml_string(s: str) -> str:
+    """``s`` as a double-quoted TOML basic string, with the characters
+    that need escaping there escaped.
+    """
+    escaped = s.replace("\\", "\\\\").replace('"', '\\"')
+    escaped = escaped.replace("\n", "\\n").replace("\t", "\\t").replace("\r", "\\r")
+    # Every other control character (and DEL) is illegal unescaped in a
+    # TOML basic string.
+    escaped = _TOML_CONTROL_RE.sub(lambda m: f"\\u{ord(m.group()):04X}", escaped)
+    return f'"{escaped}"'
+
+
+def toml_key(s: str) -> str:
+    """A TOML table/key name for ``s`` -- bare if that's valid syntax
+    (letters, digits, ``_``/``-``, non-empty), a quoted string key
+    otherwise (TOML allows arbitrary quoted keys, e.g. one containing a
+    space).
+    """
+    return s if _TOML_BARE_KEY_RE.match(s) else toml_string(s)

conclude-1.0.0.dist-info/METADATA

@@ -0,0 +1,260 @@
+Metadata-Version: 2.5
+Name: conclude
+Version: 1.0.0
+Summary: Set up your defaults; conclude infers the env vars, config-file keys, and CLI flags, and resolves them all into one settings object.
+Project-URL: Homepage, https://github.com/tanakapayam/conclude
+Project-URL: Documentation, https://github.com/tanakapayam/conclude/blob/main/docs/guide.md
+Project-URL: Repository, https://github.com/tanakapayam/conclude
+Project-URL: Issues, https://github.com/tanakapayam/conclude/issues
+Project-URL: Changelog, https://github.com/tanakapayam/conclude/blob/main/CHANGELOG.md
+Author: Payam Tanaka
+License-Expression: MIT
+License-File: LICENSE
+Keywords: cli,config,configuration,dotenv,environment-variables,settings,toml
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+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: Programming Language :: Python :: 3.14
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Typing :: Typed
+Requires-Python: >=3.11
+Provides-Extra: gitignore
+Requires-Dist: pathspec>=0.12; extra == 'gitignore'
+Description-Content-Type: text/markdown
+
+# conclude
+
+A setting that can come from a flag, an environment variable, or a
+config file usually gets written down three times: an argparse flag, an
+environment variable, and a config-file key -- each with its own name,
+its own type conversion, and its own copy of the default. Add a setting
+and you touch three places; rename one and the other two quietly drift.
+
+conclude has you write it once. Set up your defaults; conclude works
+out the rest. You write down a setting's name, its type, and its
+starting value -- as an entry in a plain dict -- and conclude infers
+the environment variable name, the config-file key, the CLI flag, and
+how to cast a raw value from any of those into the right type.
+
+```python
+import conclude
+
+DEFAULTS = {
+    "host": "localhost",
+    "port": 8080,
+    "debug": False,
+    "tags": conclude.opt(list),  # unset by default, but still a list when set
+}
+app = conclude.App("myapp", DEFAULTS)
+
+parser = app.build_arg_parser(prog="myapp")
+namespace = parser.parse_args()
+cli = {k: v for k, v in vars(namespace).items() if v is not None}
+print(app.resolve(cli))
+```
+
+```
+$ MYAPP_PORT=9000 myapp --debug --tags a,b
+{'host': 'localhost', 'port': 9000, 'debug': True, 'tags': ['a', 'b']}
+```
+
+That one dict gave you the CLI flags (`--host`, `--port`, `--debug`,
+`--tags`), the environment variables (`MYAPP_HOST`, `MYAPP_PORT`, ...),
+the config-file keys (a `[myapp]` table in `~/.config/myapp/config.toml`
+or `./.config.toml`), and a caster for each -- with no second list of
+names to keep in sync.
+
+## Where it fits
+
+Configuration libraries tend to start from different things. conclude
+starts from a dict of defaults and derives the rest:
+
+| Package           | Primary abstraction                                                      | Reach for it when...                                                              |
+| ----------------- | ------------------------------------------------------------------------ | --------------------------------------------------------------------------------- |
+| `argparse`        | CLI parser                                                               | you only need flags                                                               |
+| ConfigArgParse    | argparse plus config files and environment variables                     | you have an argparse CLI and want files and env vars added                        |
+| jsonargparse      | CLI and config built from type hints                                     | your program is functions, classes or dataclasses with type hints                 |
+| python-dotenv     | `.env` loader                                                            | you just need a `.env` in `os.environ`                                            |
+| python-decouple   | individual value reader (env, then file, then default)                   | you read a handful of values, Django-style                                        |
+| pydantic-settings | typed, validated settings model                                          | you want validation, nested models or secret-manager sources                      |
+| Dynaconf          | general-purpose layered configuration system                             | you want named environments, many file formats, or Vault                          |
+| Hydra / OmegaConf | hierarchical, composable configuration                                   | you compose config groups, run sweeps or manage experiments                       |
+| **conclude**      | **defaults → inferred env / TOML / CLI interfaces → layered resolution** | **you want all three interfaces from one dict, and safe private local overrides** |
+
+conclude deliberately does not do schema validation (values are cast,
+not validated), secret-manager backends, YAML or JSON files, or named
+environments; the table says where to look for those. For a dated,
+feature-by-feature comparison, see
+[How conclude compares](https://github.com/tanakapayam/conclude/blob/main/docs/comparison.md).
+
+## Design principles
+
+- **One source of truth.** The defaults dict. Flags, environment
+  variable names, config keys, casters and the generated templates are
+  all derived from it, so they can't drift apart.
+- **Opt in to anything unusual.** The system file, `.env` and the
+  developer file are off until you ask; the user and project files are
+  one `None` from off.
+- **Private files have to prove they're private.** The developer file
+  (and `.env`, if you ask) is read only when git is ignoring it.
+- **Quiet for ordinary situations, loud for broken setups.** A missing
+  local file is normal and silent, and `describe_sources()` explains
+  it; a malformed developer file or a missing `pathspec` raises.
+- **Standard library only.** `pathspec`, for the gitignore check, is an
+  optional extra.
+
+## The layers
+
+```
+1. CLI flags
+2. Developer config file (opt-in; private, gitignored, project-local,
+   TOML or dotenv -- beats the environment)
+3. Environment variables (with an opt-in `.env` file as a fallback)
+4. Config file(s), in this order (each overrides the previous):
+   a. /etc/<app>/config.toml            (system-wide; opt-in, off by default)
+   b. ~/.config/<app>/config.toml       (user-global, overrides system)
+   c. ./.config.toml                    (project-local, overrides user)
+   d. ./.config.*.toml                  (sibling files, sorted by name)
+5. Hardcoded defaults
+```
+
+Or, lowest priority to highest:
+
+```
+defaults < system < user < project < env < developer < CLI
+```
+
+Everything hangs off that one dict: the layers it feeds, and what
+conclude infers from it so you never write any of it twice:
+
+```
+                ┌── CLI
+defaults ───────┼── developer config (explicit opt-in, must be gitignored)
+       │        ├── environment
+       │        ├── .env (explicit opt-in)
+       │        └── config files
+       │
+       └── inference
+             ├── caster
+             ├── formatter
+             ├── CLI name
+             └── environment name
+```
+
+(The layers are listed highest priority first; `defaults` sits beneath
+all of them.) The user and project config files are on by default, and
+each is one `None` away from off. The system file, `.env`, and the
+developer file are off until you ask for them.
+
+## Local files: which one?
+
+Two of the layers are about your own machine, and each comes in two
+formats:
+
+| Format | Below the environment                     | Above the environment                      |
+| ------ | ----------------------------------------- | ------------------------------------------ |
+| TOML   | the system, user and project config files | the developer file, e.g. `.developer.toml` |
+| dotenv | `.env`                                    | the developer file, e.g. `.env.local`      |
+
+- **Non-secret local defaults you're happy to commit** -- use `.env`.
+  A real `export` in the shell still beats it, so it can't override a
+  deployment.
+- **Private values that must win over stray shell exports** (a local
+  `DATABASE_URL`, say) -- use the developer file. Make it TOML if only
+  your app reads it (it gets `[table]`s, including per-recipient ones);
+  make it dotenv, like `.env.local`, if docker compose, direnv or your
+  IDE need the same values.
+- **A private `.env` that stays below the environment** -- use `.env`
+  with `dotenv_require_gitignored=True`.
+
+The developer file's location lives in your committed `pyproject.toml`
+(any name works; the name decides the format, and only `.toml` means
+TOML):
+
+```toml
+[tool.conclude.developer]
+config = ".developer.toml"  # or ".env.local"
+```
+
+```python
+app = conclude.App(
+    "myapp",
+    DEFAULTS,
+    pyproject_path=conclude.AUTO,  # the developer file
+    dotenv_path=conclude.AUTO,  # .env
+)
+```
+
+The developer file is always guarded, and `.env` is when you ask: the
+file is used only if it exists, sits in a git working tree, and is
+gitignored. Otherwise it is skipped quietly, and `describe_sources()`
+says why. Details: [the `.env` file](https://github.com/tanakapayam/conclude/blob/main/docs/guide.md#6-local-development-a-env-file), [the developer file](https://github.com/tanakapayam/conclude/blob/main/docs/guide.md#8-a-private-developer-config-file).
+
+## What's in it
+
+- **Inference** of casters, formatters, CLI flags, env var names and
+  config keys from the defaults alone; `opt(type)` for a setting that
+  starts out unset ([guide, section 1](https://github.com/tanakapayam/conclude/blob/main/docs/guide.md#1-the-bare-minimum), [section 3](https://github.com/tanakapayam/conclude/blob/main/docs/guide.md#3-when-inference-isnt-quite-enough-casters-and-formatters)).
+- **Config-file tables**, including a positional shorthand that picks a
+  table per recipient/deck/profile ([section 4](https://github.com/tanakapayam/conclude/blob/main/docs/guide.md#4-a-positional-shorthand--per-recipient-config-tables)).
+- **`--print-invocation`** and `App.format_invocation()`: print the
+  command line that reproduces a resolved configuration
+  ([section 5](https://github.com/tanakapayam/conclude/blob/main/docs/guide.md#5-debugging-and-documentation---print-invocation)).
+- **A `.env` fallback**, optionally required to be gitignored, sitting
+  beneath real environment variables ([section 6](https://github.com/tanakapayam/conclude/blob/main/docs/guide.md#6-local-development-a-env-file)).
+- **A system-wide config file**, the lowest-priority file ([section 7](https://github.com/tanakapayam/conclude/blob/main/docs/guide.md#7-machine-wide-defaults-a-system-config-file)).
+- **A private developer file**, TOML or dotenv, that beats ambient
+  environment variables ([section 8](https://github.com/tanakapayam/conclude/blob/main/docs/guide.md#8-a-private-developer-config-file)).
+- **`describe_sources()`** for `--help`: which sources are in play, and
+  why a given one isn't ([section 9](https://github.com/tanakapayam/conclude/blob/main/docs/guide.md#9-turning-off-a-source-and-telling-the-user)).
+- **Templates and docs generated from your defaults**:
+  `format_env()`, `format_toml()`, `format_cli()`
+  ([section 10](https://github.com/tanakapayam/conclude/blob/main/docs/guide.md#10-generating-docs-and-templates)).
+- Standard library only, fully typed (`py.typed`), Python 3.11+. The
+  gitignore check (developer file, strict `.env`) uses the optional
+  `pathspec` package.
+
+## Install
+
+```
+pip install conclude
+```
+
+The developer config layer (and a `.env` you ask to be held to the same
+standard) needs one small pure-Python dependency, only to check that a
+private file is gitignored:
+
+```
+pip install 'conclude[gitignore]'
+```
+
+## Documentation
+
+- [Guide](https://github.com/tanakapayam/conclude/blob/main/docs/guide.md) -- builds a small CLI, `remind`, one
+  idea at a time.
+- [Reference](https://github.com/tanakapayam/conclude/blob/main/docs/reference.md) -- every class, method, and
+  module.
+- [Changelog](https://github.com/tanakapayam/conclude/blob/main/CHANGELOG.md).
+
+## Development
+
+```
+uv sync
+uv run pytest
+uv run ruff check . && uv run ruff format --check .
+uv run mypy
+uv build && uvx twine check --strict dist/*
+```
+
+CI runs these same commands on Python 3.11 through 3.14.
+
+## License
+
+MIT -- see [LICENSE](https://github.com/tanakapayam/conclude/blob/main/LICENSE).

conclude-1.0.0.dist-info/RECORD

@@ -0,0 +1,19 @@
+conclude/__init__.py,sha256=MKDasCQZ2cQJX4Ts9-8hvflyKhjc8eenAhLgZpfoxWs,8155
+conclude/app.py,sha256=hFGiacq_ID_nOwNf_mGlSMi0yZF2a7vBAiTIyZYwTE8,38572
+conclude/casters.py,sha256=crgvKmugrgG9ElCtRxajbqEj4tUQymPFc3qwcCs0V_8,11044
+conclude/developer.py,sha256=emRRrO0OCVNUoZc7Lr5ettah_bQXd1SdNyhiLvIusAM,9415
+conclude/env.py,sha256=BFMjiHZ2btIphmHZ4qnRDRlaGadUb29-hBfSPTBS4IE,7018
+conclude/files.py,sha256=if_XvwlGKvAob7GTa3LTlVYTaEEyDYcA0mfzCOGipwM,10383
+conclude/formatters.py,sha256=qTJJqVG6XV4k3YQCPNS2bneTfxy1LIya4LHOTaldOas,3724
+conclude/guard.py,sha256=2IhlxeivFaLcJ1mEYmADS2lObrxdZzlLLwAE6j1yn3c,7223
+conclude/infer.py,sha256=zsZ8iMZG5o-7nNwaZGff_AKFKuQAQ04sup_hDL2fZbE,4493
+conclude/merge.py,sha256=tlOLgz0APaVov65K2GamBIkQSz7oRFzMZXZ54F9Kqwk,2355
+conclude/naming.py,sha256=BLZkW9qbq4ReFfjEOFUwwkcouHoI5muP6sNf7aep3P0,2315
+conclude/paths.py,sha256=d4b0t-rYIk5p7mnzNqgaDR-sgA0RLX12HhHjMSDJeD8,1072
+conclude/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+conclude/templates.py,sha256=kMhOgFmXS-PGmJF_jVR6qJ-d-6LB-XOtC4oiaFqSatU,3376
+conclude/tomlwrite.py,sha256=oGTZbaOyyOmv42JJqG1GFLrs-vJNBmiF-jCFL_VxZXk,1076
+conclude-1.0.0.dist-info/METADATA,sha256=IQqX_hoDVcejBJ0qvPfsRXWeyelrS2bF2y-YK66Hlzg,12802
+conclude-1.0.0.dist-info/WHEEL,sha256=THafob7ofN-NsuMN7Mg4qZyHaQI7KkD-QlcQatYhXPo,87
+conclude-1.0.0.dist-info/licenses/LICENSE,sha256=EywLvILKrIuRUTXOSGJgDxKm1YH0g7zpbRG8vvzwMHA,1060
+conclude-1.0.0.dist-info/RECORD,,

conclude-1.0.0.dist-info/WHEEL

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

conclude-1.0.0.dist-info/licenses/LICENSE

@@ -0,0 +1,7 @@
+Copyright 2026 Payam Tanaka
+
+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.