netrias_client 0.0.1__py3-none-any.whl

netrias_client/scripts.py

@@ -0,0 +1,313 @@
+"""Coordinate project command entry points.
+
+'why': centralize developer workflows for `uv run` execution
+"""
+from __future__ import annotations
+
+import argparse
+import logging
+import os
+import re
+import shutil
+import subprocess
+import sys
+import tempfile
+from collections.abc import Mapping, Sequence
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Final, cast
+
+_LOGGER = logging.getLogger("netrias_client.scripts")
+_COMMANDS: Final[tuple[tuple[str, ...], ...]] = (
+    ("pytest",),
+    ("ruff", "check", "."),
+    ("basedpyright", "."),
+)
+_REPO_ROOT: Final[Path] = Path(__file__).resolve().parents[2]
+_PYPROJECT_PATH: Final[Path] = _REPO_ROOT / "pyproject.toml"
+_PACKAGE_INIT_PATH: Final[Path] = Path(__file__).resolve().parent / "__init__.py"
+_DIST_PATH: Final[Path] = _REPO_ROOT / "dist"
+_VERSION_PATTERN: Final[re.Pattern[str]] = re.compile(r'^version\s*=\s*"(?P<value>[^"]+)"$', re.MULTILINE)
+_INIT_VERSION_PATTERN: Final[re.Pattern[str]] = re.compile(r'^__version__\s*=\s*"(?P<value>[^"]+)"$', re.MULTILINE)
+_REPOSITORY_CONFIG: Final[dict[str, tuple[str, str | None]]] = {
+    "testpypi": ("TEST_PYPI_TOKEN", "https://test.pypi.org/legacy/"),
+    "pypi": ("PYPI_TOKEN", None),
+}
+
+
+@dataclass(frozen=True)
+class ReleaseOptions:
+    """Capture release CLI arguments as structured options.
+
+    'why': keep parsing separate from orchestration logic
+    """
+
+    version: str | None
+    bump: str
+    repository: str | None
+
+
+def check() -> None:
+    """Run the combined test and lint pipeline invoked by `uv run check`.
+
+    'why': provide a single entry point that exits early on the first failure
+    """
+
+    _ensure_logging()
+    for command in _COMMANDS:
+        _run_command_or_raise(command)
+
+
+def live_check() -> None:
+    """Execute the live service smoke test harness.
+
+    'why': exercise production endpoints without duplicating CLI plumbing
+    """
+
+    _run_command_or_raise(("python", "-m", "netrias_client.live_test.test"))
+
+
+def release(argv: Sequence[str] | None = None) -> None:
+    """Run the release pipeline: bump version, validate, build, publish.
+
+    'why': streamline TestPyPI/PyPI releases from a single script
+    """
+
+    options = _parse_release_args(argv)
+    _ensure_logging()
+    target_version = _determine_target_version(options)
+    _update_versions(target_version)
+    _LOGGER.info("version synchronized → %s", target_version)
+    check()
+    artifacts = _build_distributions()
+    _verify_artifacts(artifacts)
+    if options.repository:
+        _publish_artifacts(options.repository)
+
+
+def _ensure_logging() -> None:
+    """Provision a minimalist logging configuration for script execution."""
+
+    if not _LOGGER.handlers:
+        logging.basicConfig(level=logging.INFO, format="%(message)s")
+
+
+def _run_command(command: Sequence[str], *, env: Mapping[str, str] | None = None, display_command: Sequence[str] | None = None) -> int:
+    """Run `command` and return its exit status without raising on failure.
+
+    'why': centralize subprocess logging and leave error handling to callers
+    """
+
+    shown = display_command or command
+    _LOGGER.info("→ %s", " ".join(shown))
+    completed = subprocess.run(command, check=False, env=dict(env) if env else None)
+    return completed.returncode
+
+
+def _run_command_or_raise(
+    command: Sequence[str],
+    *,
+    env: Mapping[str, str] | None = None,
+    display_command: Sequence[str] | None = None,
+) -> None:
+    """Execute `command` and abort immediately on failure.
+
+    'why': surface the first failing command to halt composite workflows
+    """
+
+    exit_code = _run_command(command, env=env, display_command=display_command)
+    if exit_code != 0:
+        raise SystemExit(exit_code)
+
+
+def _parse_release_args(argv: Sequence[str] | None) -> ReleaseOptions:
+    """Parse CLI arguments into a `ReleaseOptions` instance.
+
+    'why': isolate argparse wiring for straightforward testing
+    """
+
+    parser = argparse.ArgumentParser(prog="uv run release")
+    group = parser.add_mutually_exclusive_group()
+    _ = group.add_argument("--version", help="Explicit semantic version to publish")
+    _ = group.add_argument("--bump", choices=("patch", "minor", "major"), default="patch", help="Increment the current version")
+    _ = parser.add_argument("--publish", choices=("testpypi", "pypi"), dest="repository", help="Publish artifacts after verification")
+    namespace = parser.parse_args(list(argv) if argv is not None else sys.argv[1:])
+    version_arg = cast(str | None, getattr(namespace, "version", None))
+    bump_arg = cast(str | None, getattr(namespace, "bump", None))
+    repository_arg = cast(str | None, getattr(namespace, "repository", None))
+    bump = bump_arg or "patch"
+    return ReleaseOptions(version=version_arg, bump=bump, repository=repository_arg)
+
+
+def _determine_target_version(options: ReleaseOptions) -> str:
+    """Decide the release version based on explicit input or a bump type.
+
+    'why': ensure both pyproject and package versions stay aligned
+    """
+
+    current = _read_version(_PYPROJECT_PATH, _VERSION_PATTERN)
+    _assert_versions_match(current)
+    if options.version:
+        return options.version
+    return _bump_semver(current, options.bump)
+
+
+def _assert_versions_match(expected: str) -> None:
+    """Verify the package and pyproject versions are identical before bumping.
+
+    'why': prevent partial version updates that ship inconsistent metadata
+    """
+
+    package_version = _read_version(_PACKAGE_INIT_PATH, _INIT_VERSION_PATTERN)
+    if package_version != expected:
+        message = " ".join(
+            [
+                f"Package version mismatch: pyproject.toml has {expected}",
+                f"but src/netrias_client/__init__.py has {package_version}",
+            ]
+        )
+        raise RuntimeError(message)
+
+
+def _read_version(path: Path, pattern: re.Pattern[str]) -> str:
+    """Extract a version string from `path` using `pattern`.
+
+    'why': share parsing logic between pyproject and package metadata
+    """
+
+    text = path.read_text(encoding="utf-8")
+    match = pattern.search(text)
+    if match is None:
+        raise RuntimeError(f"Could not locate version string in {path}")
+    return match.group("value")
+
+
+def _bump_semver(version: str, bump: str) -> str:
+    """Return a new semantic version string incremented by `bump` type.
+
+    'why': keep release increments predictable without external tooling
+    """
+
+    major_str, minor_str, patch_str = version.split(".")
+    major, minor, patch = int(major_str), int(minor_str), int(patch_str)
+    if bump == "major":
+        return f"{major + 1}.0.0"
+    if bump == "minor":
+        return f"{major}.{minor + 1}.0"
+    return f"{major}.{minor}.{patch + 1}"
+
+
+def _update_versions(version: str) -> None:
+    """Write `version` to pyproject.toml and the package __init__ module.
+
+    'why': guarantee distribution metadata matches the Python package
+    """
+
+    _replace_version(_PYPROJECT_PATH, _VERSION_PATTERN, f'version = "{version}"')
+    _replace_version(_PACKAGE_INIT_PATH, _INIT_VERSION_PATTERN, f'__version__ = "{version}"')
+
+
+def _replace_version(path: Path, pattern: re.Pattern[str], replacement: str) -> None:
+    """Swap the first version match in `path` with `replacement`.
+
+    'why': avoid manual editing and keep formatting stable
+    """
+
+    text = path.read_text(encoding="utf-8")
+    updated, count = pattern.subn(replacement, text, count=1)
+    if count != 1:
+        raise RuntimeError(f"Failed to update version in {path}")
+    _ = path.write_text(updated, encoding="utf-8")
+
+
+def _build_distributions() -> list[Path]:
+    """Build wheel and sdist artifacts and return their paths.
+
+    'why': provide a clean slate before handing artifacts to verifiers
+    """
+
+    if _DIST_PATH.exists():
+        shutil.rmtree(_DIST_PATH)
+    _run_command_or_raise(("uv", "build"))
+    return sorted(_DIST_PATH.glob("*"))
+
+
+def _verify_artifacts(artifacts: Sequence[Path]) -> None:
+    """Run metadata checks and a local install smoke test for `artifacts`.
+
+    'why': catch packaging issues before publishing to a remote index
+    """
+
+    dist_files = [
+        path
+        for path in artifacts
+        if path.suffix == ".whl" or tuple(path.suffixes[-2:]) == (".tar", ".gz")
+    ]
+    if not dist_files:
+        raise RuntimeError("No distribution artifacts produced; run `uv build` first")
+    _run_command_or_raise(("uv", "run", "twine", "check", *[str(path) for path in dist_files]))
+    _smoke_test_artifacts(dist_files)
+
+
+def _smoke_test_artifacts(artifacts: Sequence[Path]) -> None:
+    """Install the wheel into a temp venv and import the package.
+
+    'why': validate that the built wheel installs and exposes metadata
+    """
+
+    wheel = next((path for path in artifacts if path.suffix == ".whl"), None)
+    if wheel is None:
+        raise RuntimeError("Wheel artifact missing; expected *.whl after build")
+    with tempfile.TemporaryDirectory() as tmp_dir:
+        env_path = Path(tmp_dir) / "venv"
+        _create_virtualenv(env_path)
+        python_path = _resolve_python(env_path)
+        if not python_path.exists():
+            raise RuntimeError(f"Smoke test interpreter missing: {python_path}")
+        _LOGGER.info("smoke test interpreter → %s", python_path)
+        _run_command_or_raise((str(python_path), "-m", "pip", "install", str(wheel)))
+        _run_command_or_raise((str(python_path), "-c", "import netrias_client as pkg; print(pkg.__version__)"))
+
+
+def _create_virtualenv(target: Path) -> None:
+    """Create a fresh virtual environment at `target` with pip installed.
+
+    'why': isolate smoke tests from the developer environment
+    """
+
+    _run_command_or_raise(("uv", "venv", str(target), "--seed"))
+
+
+def _resolve_python(env_path: Path) -> Path:
+    """Locate the Python executable underneath `env_path`.
+
+    'why': handle platform differences without duplicating logic
+    """
+
+    bin_dir = env_path / ("Scripts" if sys.platform == "win32" else "bin")
+    candidates = ("python", "python3", "python.exe")
+    for candidate in candidates:
+        python_path = bin_dir / candidate
+        if python_path.exists():
+            return python_path
+    raise RuntimeError(f"Python executable not found under {bin_dir}")
+
+
+def _publish_artifacts(repository: str) -> None:
+    """Publish artifacts to the requested repository via `uv publish`.
+
+    'why': keep credential handling opinionated yet minimal
+    """
+
+    if repository not in _REPOSITORY_CONFIG:
+        raise RuntimeError(f"Unsupported repository '{repository}'")
+    env_var, publish_url = _REPOSITORY_CONFIG[repository]
+    token = os.environ.get(env_var)
+    if not token:
+        raise RuntimeError(f"Set {env_var} before publishing to {repository}")
+    command: list[str] = ["uv", "publish", "--username", "__token__", "--password", token]
+    display: list[str] = ["uv", "publish", "--username", "__token__", "--password", "******"]
+    if publish_url:
+        command.extend(["--publish-url", publish_url])
+        display.extend(["--publish-url", publish_url])
+    _run_command_or_raise(tuple(command), display_command=tuple(display))

netrias_client-0.0.1.dist-info/METADATA

@@ -0,0 +1,222 @@
+Metadata-Version: 2.4
+Name: netrias_client
+Version: 0.0.1
+Summary: Python client for the Netrias harmonization API
+Project-URL: Homepage, https://github.com/netrias/netrias_client
+Project-URL: Repository, https://github.com/netrias/netrias_client
+Project-URL: Documentation, https://github.com/netrias/netrias_client#readme
+Author-email: Chris Harman <charman@netrias.com>
+License: MIT License
+        
+        Copyright (c) 2025 Netrias
+        
+        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.
+License-File: LICENSE
+Keywords: api,cde,client,harmonization,netrias
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.10
+Requires-Dist: boto3
+Requires-Dist: httpx
+Provides-Extra: dev
+Requires-Dist: basedpyright; extra == 'dev'
+Requires-Dist: pytest-asyncio>=0.23; extra == 'dev'
+Requires-Dist: pytest>=7; extra == 'dev'
+Requires-Dist: python-dotenv>=1.0; extra == 'dev'
+Requires-Dist: ruff>=0.5.0; extra == 'dev'
+Requires-Dist: twine>=5.0; extra == 'dev'
+Requires-Dist: ty; extra == 'dev'
+Requires-Dist: typing-extensions; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# Netrias Client
+
+Python toolkit for working with the Netrias recommendation and harmonization services. The client wraps the HTTP APIs with strong typing, logging, and guard rails so analytics code can focus on describing data rather than orchestrating requests.
+
+## Highlights
+- **Stateful client facade** – instantiate `NetriasClient` and call `client.configure(...)` once.
+- **Column discovery helpers** – derive column samples from CSV files, invoke the recommendation service, and normalize responses into `MappingDiscoveryResult` models.
+- **Adapter utilities** – convert discovery output into harmonization-ready manifest payloads while applying confidence filters and CDE overrides.
+- **Asynchronous harmonization loop** – submit jobs, poll for completion, download results, and version output files automatically to avoid accidental overwrites.
+- **Extended timing logs** – discovery and harmonization emit duration metrics so you can spot slow calls quickly during live runs.
+
+## Installation
+
+The project targets Python 3.12+.
+
+```bash
+pip install netrias_client
+
+# optional AWS helpers (gateway bypass)
+pip install netrias_client[aws]
+```
+
+We recommend managing environments with [uv](https://github.com/astral-sh/uv):
+
+```bash
+# create or update a project that depends on netrias_client
+uv add netrias_client
+
+# install optional AWS helpers (gateway bypass)
+uv add netrias_client[aws]
+```
+
+For local development within this repository:
+
+```bash
+uv sync --group dev              # install development tooling
+uv sync --group aws --group dev  # include optional AWS dependencies
+```
+
+## Configuration
+
+All client entry points require explicit configuration. Create a `NetriasClient`, then provide the API key; discovery and harmonization endpoints remain fixed by the library.
+
+```python
+from pathlib import Path
+
+from netrias_client import NetriasClient
+from netrias_client._models import LogLevel
+
+client = NetriasClient()
+client.configure(
+    api_key="<netrias api key>",
+    # Optional overrides:
+    timeout=21600.0,               # seconds (default: 6 hours)
+    log_level=LogLevel.INFO,
+    confidence_threshold=0.80,     # discovery adapter filter, 0.0–1.0
+    discovery_use_gateway_bypass=True,  # toggle Lambda bypass (default: True)
+    log_directory=Path("logs/netrias"),  # optional per-client log files
+)
+```
+
+Configuration errors raise `ClientConfigurationError`. Calling `configure` again replaces the active settings snapshot and reinitializes the dedicated logger (refreshing file handlers when `log_directory` is supplied).
+
+## End-to-End Workflow
+
+The typical harmonization flow contains three steps:
+
+```python
+from pathlib import Path
+
+from netrias_client import NetriasClient
+
+client = NetriasClient()
+client.configure(api_key="<netrias api key>")
+
+csv_path = Path("/path/to/source.csv")
+schema = "ccdi"
+
+# 1. Ask the recommendation service for potential targets.
+manifest_payload = client.discover_mapping_from_csv(
+    source_csv=csv_path,
+    target_schema=schema,
+)
+
+# 2. Kick off harmonization directly with the manifest payload.
+result = client.harmonize(source_path=csv_path, manifest=manifest_payload)
+print(result.status)
+print(result.description)
+print(result.file_path)
+```
+
+- `client.discover_mapping_from_csv(...)` samples up to 25 values per column (configurable), calls the API, and returns a manifest-ready payload (including static metadata such as CDE routes/IDs where configured).
+- `client.harmonize(...)` submits a job and polls `GET /v1/jobs/{jobId}` until the backend returns success or failure. Downloaded CSVs are written next to the source file (versioned as `data.harmonized.v1.csv`, etc.). Pass `manifest_output_path=` if you also want to persist the manifest JSON for inspection.
+
+### Timing Logs
+
+Both discovery and harmonization log elapsed seconds for the full operation and for timeout/transport failures. Sample output:
+
+```
+INFO netrias_client: discover mapping start: schema=ccdi columns=12
+INFO netrias_client: discover mapping complete: schema=ccdi suggestions=0 duration=47.12s
+INFO netrias_client: harmonize start: file=data.csv
+INFO netrias_client: harmonize finished: file=data.csv status=succeeded duration=182.45s
+```
+
+Use these metrics to separate slow API responses from downstream processing overhead.
+
+## Adapter Notes
+
+Discovery results are normalized to manifest payloads automatically; unmatched columns are logged so you can expand coverage. Confidence thresholds come from `configure(confidence_threshold=...)` and default to 0.8.
+
+## Gateway Bypass (Temporary)
+
+The module `netrias_client._gateway_bypass` exposes `invoke_cde_recommendation_alias(...)`, a stopgap helper that calls the `cde-recommendation` Lambda alias directly. This avoids API Gateway’s short timeout window but requires AWS credentials with `lambda:InvokeFunction` permission and the `boto3` dependency.
+
+```python
+from netrias_client._gateway_bypass import invoke_cde_recommendation_alias
+
+result = invoke_cde_recommendation_alias(
+    target_schema="ccdi",
+    columns={"study_name": ["foo", "bar"]},
+    alias="prod",
+    region_name="us-east-2",
+)
+```
+
+Install `boto3` (or `netrias-client[aws]` if provided) before importing the bypass module, and rotate IAM credentials frequently. Once API Gateway limits are raised, prefer the standard discovery flow again.
+
+## Testing & Tooling
+
+The repository ships with pytest-based integration tests plus lint/type tooling.
+
+
+```bash
+uv run pytest
+uv run ruff check
+uv run basedpyright
+uv build                 # produce wheel + sdist
+```
+
+Live verification scripts are located under `live_test/` and require a populated `.env` file containing `NETRIAS_API_KEY` (and optionally harmonization overrides while services converge).
+
+## Project Layout
+
+```
+src/netrias_client/
+    __init__.py          # re-exported public surface
+    _adapter.py          # discovery → manifest conversion
+    _client.py           # NetriasClient facade and state management
+    _config.py           # settings validation helpers
+    _core.py             # harmonization workflow
+    _discovery.py        # discovery wrappers and CSV sampling
+    _errors.py           # exception taxonomy
+    _http.py             # HTTP primitives (submit/poll/download)
+    _io.py               # streaming helpers
+    _logging.py          # standardized logger setup
+    _models.py           # dataclasses for structured responses
+    _validators.py       # filesystem and payload validation
+```
+
+Tests reside under `src/netrias_client/tests/` and are excluded from the published wheel to keep installs slim; run them locally via `uv run pytest`.
+
+## Contributing
+
+1. `uv sync --group dev` (add `--group aws` if needed) to create the virtual environment.
+2. `uv run pytest` to ensure the suite passes prior to committing.
+3. Follow the repo conventions: keep functions focused, prefer typed interfaces, and favor logging key transitions over verbose chatter.
+
+Pull requests should include updated documentation or fixtures when they alter API behavior or the manifest contract.

netrias_client-0.0.1.dist-info/RECORD

@@ -0,0 +1,19 @@
+netrias_client/__init__.py,sha256=bQ0oTDltyN1IbMZxpo_wQlGqiL3yGkGJD5MKez4PbcI,200
+netrias_client/_adapter.py,sha256=dXJqrpkaAOiZI25gZm0RzFrSFaG4VefvLiM66oI4ziU,9241
+netrias_client/_client.py,sha256=_WVxCOhmCXHG2olDp-eMIKVfHpTt8bibpMQaMRfMSCE,8508
+netrias_client/_config.py,sha256=jY12kLOJ3OMn1YF7QeEq6nU2BaXCpPteoXDz7eprB8I,3098
+netrias_client/_core.py,sha256=f77gwaHfu7lRK2eCSuwumfpU0UXQasZ9D2VVkbPQ68E,18741
+netrias_client/_discovery.py,sha256=YVlA6dGBT4eSUBjyy82aM_Sm_4YK5ulZH_xqk5UJgZk,14380
+netrias_client/_errors.py,sha256=7fdLkoxoz5C55NEFd7ItL8otfJdP1rXsunEAZBzs-VA,960
+netrias_client/_gateway_bypass.py,sha256=dMoEXuDvkGzDnpQ9lYXH6xY8VX-8ghI54-IM-CLQmoA,6441
+netrias_client/_http.py,sha256=h8Kc-8LxIkiRqnKU2RDb4xGf4jdg9jK9bXIH3WDB9xI,4011
+netrias_client/_io.py,sha256=XXIRG5zo1XN_6jk2N8J--czKrOIEeZoAQWzT1Ihgs1M,822
+netrias_client/_logging.py,sha256=5-lhBgp2hWp2K5ZTzz_ZwhJn_sxhSe_t__kdhuMTJnQ,1317
+netrias_client/_models.py,sha256=w_t-rpenLFZiBzLCdRlXaKPqgCrHCjAVoeXjPYF7wIY,1736
+netrias_client/_validators.py,sha256=DvbaQ1Wkf4-W_H5A2PGiC-AxPN2tfpRFpH8vjETGIno,5894
+netrias_client/scripts.py,sha256=jAdREIRbyuSvuvZt6tbRZ9ELfOzQyW9ZQcf2j2HIlsE,11113
+netrias_client-0.0.1.dist-info/METADATA,sha256=5Lx4lh3G_65ThePIeNWWg6W0PHH__8Vg52pJ5hEuMis,9620
+netrias_client-0.0.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+netrias_client-0.0.1.dist-info/entry_points.txt,sha256=q7Uj2UATtRzlxefJNziCJQ9RXScH8MQzzWvA86Hfytc,162
+netrias_client-0.0.1.dist-info/licenses/LICENSE,sha256=XzmWyunEynTK9hABeKX_9VEd1WcKSDQAM4IXIS-n8WU,1064
+netrias_client-0.0.1.dist-info/RECORD,,

netrias_client-0.0.1.dist-info/WHEEL

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

netrias_client-0.0.1.dist-info/entry_points.txt

@@ -0,0 +1,5 @@
+[console_scripts]
+check = netrias_client.scripts:check
+live_check = netrias_client.scripts:live_check
+release = netrias_client.scripts:release
+test = pytest:main

netrias_client-0.0.1.dist-info/licenses/LICENSE

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