uictlapi 0.1.1__tar.gz

uictlapi-0.1.1/LICENSE

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

uictlapi-0.1.1/PKG-INFO

@@ -0,0 +1,110 @@
+Metadata-Version: 2.4
+Name: uictlapi
+Version: 0.1.1
+Summary: Curl-like CLI for the UniFi Controller / UniFi OS Web UI API, with login and CSRF handled for you.
+Author-email: Roman Akinfeev <akinfold@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/akinfold/uictlapi
+Project-URL: Repository, https://github.com/akinfold/uictlapi
+Project-URL: Issues, https://github.com/akinfold/uictlapi/issues
+Keywords: unifi,ubiquiti,api,cli,networking,controller,docker
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: System Administrators
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Internet
+Classifier: Topic :: System :: Networking
+Classifier: Topic :: Utilities
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: click>=8.0.0
+Requires-Dist: requests>=2.25.0
+Requires-Dist: requests-unifi-auth>=0.1.5
+Provides-Extra: test
+Requires-Dist: pytest>=7.0.0; extra == "test"
+Requires-Dist: pytest-cov>=4.0.0; extra == "test"
+Requires-Dist: ruff>=0.8.0; extra == "test"
+Dynamic: license-file
+
+# uictlapi
+
+[![PYPI](https://img.shields.io/pypi/v/uictlapi)](https://pypi.org/project/uictlapi/)
+[![Docker Image](https://img.shields.io/docker/v/akinfold/uictlapi?label=docker&sort=semver)](https://hub.docker.com/r/akinfold/uictlapi)
+[![MIT license](https://img.shields.io/badge/License-MIT-blue.svg)](https://github.com/akinfold/uictlapi/blob/main/LICENSE)
+
+Curl-like CLI for the UniFi Controller / UniFi OS Web UI API — with login and CSRF
+handled for you.
+
+Auth and CSRF come from
+[`requests-unifi-auth`](https://github.com/akinfold/requests-unifi-auth). This package is
+only the HTTP CLI: any Web UI / proxy URL, any method. It is **not** a typed UniFi SDK and
+does not invent domain commands (`routes apply`, inventory, multi-controller orchestration).
+
+Live auth/CSRF compatibility against real controllers is tracked in
+[`requests-unifi-auth` COMPATIBILITY.md](https://github.com/akinfold/requests-unifi-auth/blob/main/COMPATIBILITY.md).
+
+## Installation
+
+### pip
+
+```bash
+pip install uictlapi
+```
+
+Requires `requests-unifi-auth>=0.1.5`.
+
+### Docker
+
+```bash
+docker run --rm akinfold/uictlapi:latest --help
+```
+
+## Usage
+
+Auth string: `user:pass@host` (or `@/path/to/file` containing the same).
+
+```bash
+# Read traffic routes (policy-based routing)
+uictlapi get -a 'user:pass@192.168.1.1' --no-verify \
+  'https://192.168.1.1/proxy/network/v2/api/site/default/trafficroutes'
+
+# Same via Docker
+docker run --rm akinfold/uictlapi:latest get -a 'user:pass@192.168.1.1' --no-verify \
+  'https://192.168.1.1/proxy/network/v2/api/site/default/trafficroutes'
+
+# POST JSON body (from string or @file)
+uictlapi post -a 'user:pass@192.168.1.1' --no-verify \
+  -j '{"enabled":true}' \
+  'https://192.168.1.1/proxy/network/v2/api/site/default/some-endpoint'
+
+uictlapi --version
+```
+
+Common flags mirror curl-ish habits: `-H` / `-p` / `-d` / `-j` / `-o` / `--show-headers` /
+`--status-only` / `--no-verify` / `-t`. Exit status `1` on HTTP ≥ 400, `2` on transport errors.
+
+## Releasing
+
+Version lives in `pyproject.toml` and `src/uictlapi/__init__.py`. Bump on `main` first
+(GitHub Actions → **Bump version**, or locally with `bump-my-version`), then:
+
+```bash
+git tag vX.Y.Z
+git push origin vX.Y.Z
+```
+
+The **Publish** workflow runs tests, uploads to PyPI, pushes multi-arch Docker images
+(`X.Y.Z`, `X.Y`, and `latest` when appropriate), and creates a GitHub Release.
+
+## License
+
+MIT

uictlapi-0.1.1/README.md

@@ -0,0 +1,73 @@
+# uictlapi
+
+[![PYPI](https://img.shields.io/pypi/v/uictlapi)](https://pypi.org/project/uictlapi/)
+[![Docker Image](https://img.shields.io/docker/v/akinfold/uictlapi?label=docker&sort=semver)](https://hub.docker.com/r/akinfold/uictlapi)
+[![MIT license](https://img.shields.io/badge/License-MIT-blue.svg)](https://github.com/akinfold/uictlapi/blob/main/LICENSE)
+
+Curl-like CLI for the UniFi Controller / UniFi OS Web UI API — with login and CSRF
+handled for you.
+
+Auth and CSRF come from
+[`requests-unifi-auth`](https://github.com/akinfold/requests-unifi-auth). This package is
+only the HTTP CLI: any Web UI / proxy URL, any method. It is **not** a typed UniFi SDK and
+does not invent domain commands (`routes apply`, inventory, multi-controller orchestration).
+
+Live auth/CSRF compatibility against real controllers is tracked in
+[`requests-unifi-auth` COMPATIBILITY.md](https://github.com/akinfold/requests-unifi-auth/blob/main/COMPATIBILITY.md).
+
+## Installation
+
+### pip
+
+```bash
+pip install uictlapi
+```
+
+Requires `requests-unifi-auth>=0.1.5`.
+
+### Docker
+
+```bash
+docker run --rm akinfold/uictlapi:latest --help
+```
+
+## Usage
+
+Auth string: `user:pass@host` (or `@/path/to/file` containing the same).
+
+```bash
+# Read traffic routes (policy-based routing)
+uictlapi get -a 'user:pass@192.168.1.1' --no-verify \
+  'https://192.168.1.1/proxy/network/v2/api/site/default/trafficroutes'
+
+# Same via Docker
+docker run --rm akinfold/uictlapi:latest get -a 'user:pass@192.168.1.1' --no-verify \
+  'https://192.168.1.1/proxy/network/v2/api/site/default/trafficroutes'
+
+# POST JSON body (from string or @file)
+uictlapi post -a 'user:pass@192.168.1.1' --no-verify \
+  -j '{"enabled":true}' \
+  'https://192.168.1.1/proxy/network/v2/api/site/default/some-endpoint'
+
+uictlapi --version
+```
+
+Common flags mirror curl-ish habits: `-H` / `-p` / `-d` / `-j` / `-o` / `--show-headers` /
+`--status-only` / `--no-verify` / `-t`. Exit status `1` on HTTP ≥ 400, `2` on transport errors.
+
+## Releasing
+
+Version lives in `pyproject.toml` and `src/uictlapi/__init__.py`. Bump on `main` first
+(GitHub Actions → **Bump version**, or locally with `bump-my-version`), then:
+
+```bash
+git tag vX.Y.Z
+git push origin vX.Y.Z
+```
+
+The **Publish** workflow runs tests, uploads to PyPI, pushes multi-arch Docker images
+(`X.Y.Z`, `X.Y`, and `latest` when appropriate), and creates a GitHub Release.
+
+## License
+
+MIT

uictlapi-0.1.1/pyproject.toml

@@ -0,0 +1,144 @@
+[build-system]
+requires = ["setuptools>=61.0", "wheel", "build"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "uictlapi"
+version = "0.1.1"
+description = "Curl-like CLI for the UniFi Controller / UniFi OS Web UI API, with login and CSRF handled for you."
+readme = "README.md"
+authors = [{name = "Roman Akinfeev", email = "akinfold@gmail.com"}]
+license = {text = "MIT"}
+requires-python = ">=3.8"
+dependencies = [
+    "click>=8.0.0",
+    "requests>=2.25.0",
+    "requests-unifi-auth>=0.1.5",
+]
+keywords = ["unifi", "ubiquiti", "api", "cli", "networking", "controller", "docker"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Environment :: Console",
+    "Intended Audience :: Developers",
+    "Intended Audience :: System Administrators",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Internet",
+    "Topic :: System :: Networking",
+    "Topic :: Utilities",
+]
+
+[project.urls]
+Homepage = "https://github.com/akinfold/uictlapi"
+Repository = "https://github.com/akinfold/uictlapi"
+Issues = "https://github.com/akinfold/uictlapi/issues"
+
+[project.scripts]
+uictlapi = "uictlapi.cli:cli"
+
+[project.optional-dependencies]
+test = [
+    "pytest>=7.0.0",
+    "pytest-cov>=4.0.0",
+    "ruff>=0.8.0",
+]
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+pythonpath = ["src"]
+python_files = ["test_*.py"]
+python_classes = ["Test*"]
+python_functions = ["test_*"]
+addopts = [
+    "--strict-markers",
+    "--strict-config",
+    "-ra",
+    "--showlocals",
+    "--tb=short",
+]
+
+[tool.coverage.run]
+source = ["src/"]
+omit = [
+    "*/tests/*",
+    "*/test_*",
+]
+
+[tool.bumpversion]
+current_version = "0.1.1"
+parse = "(?P<major>\\d+)\\.(?P<minor>\\d+)\\.(?P<patch>\\d+)"
+serialize = ["{major}.{minor}.{patch}"]
+search = "{current_version}"
+replace = "{new_version}"
+regex = false
+ignore_missing_version = false
+# Tag separately and push vX.Y.Z to trigger publish.yml
+tag = false
+sign_tags = false
+tag_name = "v{new_version}"
+tag_message = "Release v{new_version}"
+allow_dirty = false
+commit = true
+message = "Bump version to {new_version}"
+commit_args = ""
+
+[[tool.bumpversion.files]]
+filename = "src/uictlapi/__init__.py"
+
+[[tool.bumpversion.files]]
+filename = "pyproject.toml"
+
+[tool.ruff]
+exclude = [
+    ".bzr",
+    ".direnv",
+    ".eggs",
+    ".git",
+    ".git-rewrite",
+    ".hg",
+    ".ipynb_checkpoints",
+    ".mypy_cache",
+    ".nox",
+    ".pants.d",
+    ".pyenv",
+    ".pytest_cache",
+    ".pytype",
+    ".ruff_cache",
+    ".svn",
+    ".tox",
+    ".venv",
+    ".vscode",
+    "__pypackages__",
+    "_build",
+    "buck-out",
+    "build",
+    "dist",
+    "node_modules",
+    "site-packages",
+    "venv",
+]
+line-length = 88
+indent-width = 4
+target-version = "py38"
+
+[tool.ruff.lint]
+select = ["E4", "E7", "E9", "F"]
+ignore = []
+fixable = ["ALL"]
+unfixable = []
+dummy-variable-rgx = "^(_+|(_+[a-zA-Z0-9_]*[a-zA-Z0-9]+?))$"
+
+[tool.ruff.format]
+quote-style = "double"
+indent-style = "space"
+skip-magic-trailing-comma = false
+line-ending = "auto"

uictlapi-0.1.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

uictlapi-0.1.1/src/uictlapi/__init__.py

@@ -0,0 +1,5 @@
+__version__ = "0.1.1"
+
+__all__ = [
+    "__version__",
+]

uictlapi-0.1.1/src/uictlapi/cli.py

@@ -0,0 +1,265 @@
+import re
+import sys
+import json
+from typing import Tuple, Dict, List, Optional
+
+import click
+import requests
+
+from requests_unifi_auth import UnifiControllerAuth
+
+from . import __version__
+
+AUTH_REGEXP = re.compile(r'^(?P<username>[^:]+):(?P<password>[^@]+)@(?P<host>[^\s]+)\s*')
+"""Match auth strings like 'foo:bar@192.168.1.1'."""
+
+
+def _parse_kv(pairs: Tuple[str, ...]) -> Dict[str, str]:
+    result: Dict[str, str] = {}
+    for p in pairs or ():
+        if "=" in p:
+            k, v = p.split("=", 1)
+            result[k.strip()] = v.strip()
+        else:
+            # allow header-like "Key: Value"
+            if ":" in p:
+                k, v = p.split(":", 1)
+                result[k.strip()] = v.strip()
+            else:
+                # fallback: treat as flag-like header with empty value
+                result[p.strip()] = ""
+    return result
+
+
+def _parse_auth(auth: Optional[str]) -> Optional[Tuple[str, str, str]]:
+    if not auth:
+        return None
+
+    if auth.startswith('@'):
+        # allow @filename to load auth data from file
+        path = auth[1:]
+        with open(path, "r", encoding="utf-8") as f:
+            auth = f.read()
+
+    match = AUTH_REGEXP.match(auth)
+    if match:
+        user, password, host = match.groups()
+        return user, password, host
+
+    return None
+
+
+def _merge_params(params_list: Tuple[str, ...]) -> Dict[str, str]:
+    return _parse_kv(params_list)
+
+
+def _load_json(json_text: Optional[str]) -> Optional[object]:
+    if not json_text:
+        return None
+    # allow @filename to load json from file
+    if json_text.startswith("@"):
+        path = json_text[1:]
+        with open(path, "r", encoding="utf-8") as f:
+            return json.load(f)
+    try:
+        return json.loads(json_text)
+    except json.JSONDecodeError:
+        # treat as plain string
+        return json_text
+
+
+def _request(
+    method: str,
+    url: str,
+    headers: Dict[str, str],
+    params: Dict[str, str],
+    data: List[str],
+    json_body,
+    auth: Tuple[str, str, str],
+    timeout: Optional[float],
+    allow_redirects: bool,
+    verify: bool,
+):
+    kwargs = {
+        "headers": headers or None,
+        "params": params or None,
+        "timeout": timeout,
+        "allow_redirects": allow_redirects,
+        "verify": verify,
+    }
+    if auth:
+        kwargs["auth"] = UnifiControllerAuth(*auth)
+    if json_body is not None:
+        kwargs["json"] = json_body
+    elif data:
+        # if multiple data entries, send last one as body; for form data, user can pass key=value headers
+        if len(data) == 1:
+            v = data[0]
+            if v.startswith("@"):
+                with open(v[1:], "rb") as f:
+                    kwargs["data"] = f.read()
+            else:
+                kwargs["data"] = v
+        else:
+            # multiple data entries -> send as form-encoded dict
+            kwargs["data"] = _parse_kv(tuple(data))
+
+    resp = requests.request(method=method, url=url, **kwargs)
+    return resp
+
+
+def _print_response(resp: requests.Response, show_headers: bool, pretty: bool, output: Optional[str], status_only: bool):
+    if status_only:
+        click.echo(str(resp.status_code))
+        return
+
+    if show_headers:
+        click.echo(f"HTTP/{resp.raw.version if hasattr(resp.raw, 'version') else '1.1'} {resp.status_code} {resp.reason}")
+        for k, v in resp.headers.items():
+            click.echo(f"{k}: {v}")
+        click.echo("")
+
+    content_type = resp.headers.get("Content-Type", "")
+    body_bytes = resp.content
+
+    if output:
+        mode = "wb"
+        with open(output, mode) as f:
+            f.write(body_bytes)
+        click.echo(f"Wrote response body to {output}")
+        return
+
+    # try to decode as text
+    try:
+        text = resp.text
+    except Exception:
+        text = None
+
+    if pretty and ("application/json" in content_type or (text and (text.strip().startswith("{") or text.strip().startswith("[")))):
+        try:
+            parsed = resp.json()
+            click.echo(json.dumps(parsed, indent=2, ensure_ascii=False))
+            return
+        except Exception:
+            pass
+
+    # fallback to raw text or binary print as repr
+    if text is not None:
+        click.echo(text)
+    else:
+        click.echo(repr(body_bytes))
+
+
+def common_options(func):
+    options = [
+        click.option("-H", "--header", multiple=True, help="Header, e.g. -H 'Accept: application/json' or -H 'X-Api-Key=VALUE'"),
+        click.option("-p", "--param", "params", multiple=True, help="Query param, e.g. -p 'key=value'"),
+        click.option("-d", "--data", "data", multiple=True, help="Request body or form field. Use @filename to read file"),
+        click.option("-j", "--json", "json_text", help="JSON body as string or @filename to read"),
+        click.option("-a", "--auth", help="Auth data as user:pass@host. For example: 'foo:bar@192.168.1.1'. Use @filename to read data from file."),
+        click.option("-t", "--timeout", type=float, default=30.0, show_default=True, help="Request timeout in seconds"),
+        click.option("--no-allow-redirects", "allow_redirects", flag_value=False, default=True, help="Disable redirects"),
+        click.option("--no-verify", "verify", flag_value=False, default=True, help="Disable SSL verification"),
+        click.option("-o", "--output", help="Write response body to file"),
+        click.option("--no-pretty", "pretty", flag_value=False, default=True, help="Disable pretty printing of JSON"),
+        click.option("--show-headers/--no-show-headers", default=False, help="Show response headers"),
+        click.option("--status-only", is_flag=True, default=False, help="Only print response HTTP status code"),
+    ]
+    for opt in reversed(options):
+        func = opt(func)
+    return func
+
+
+@click.group()
+@click.version_option(version=__version__, prog_name="uictlapi")
+def cli():
+    """Curl-like CLI for the UniFi Controller / UniFi OS Web UI API."""
+    pass
+
+
+@cli.command()
+@common_options
+@click.argument("url")
+def get(url, header, params, data, json_text, auth, timeout, allow_redirects, verify, output, pretty, show_headers, status_only):
+    """HTTP GET"""
+    _run("GET", url, header, params, data, json_text, auth, timeout, allow_redirects, verify, output, pretty, show_headers, status_only)
+
+
+@cli.command()
+@common_options
+@click.argument("url")
+def post(url, header, params, data, json_text, auth, timeout, allow_redirects, verify, output, pretty, show_headers, status_only):
+    """HTTP POST"""
+    _run("POST", url, header, params, data, json_text, auth, timeout, allow_redirects, verify, output, pretty, show_headers, status_only)
+
+
+@cli.command()
+@common_options
+@click.argument("url")
+def put(url, header, params, data, json_text, auth, timeout, allow_redirects, verify, output, pretty, show_headers, status_only):
+    """HTTP PUT"""
+    _run("PUT", url, header, params, data, json_text, auth, timeout, allow_redirects, verify, output, pretty, show_headers, status_only)
+
+
+@cli.command()
+@common_options
+@click.argument("url")
+def delete(url, header, params, data, json_text, auth, timeout, allow_redirects, verify, output, pretty, show_headers, status_only):
+    """HTTP DELETE"""
+    _run("DELETE", url, header, params, data, json_text, auth, timeout, allow_redirects, verify, output, pretty, show_headers, status_only)
+
+
+@cli.command()
+@common_options
+@click.argument("url")
+def head(url, header, params, data, json_text, auth, timeout, allow_redirects, verify, output, pretty, show_headers, status_only):
+    """HTTP HEAD"""
+    _run("HEAD", url, header, params, data, json_text, auth, timeout, allow_redirects, verify, output, pretty, show_headers, status_only)
+
+
+@cli.command()
+@common_options
+@click.argument("url")
+def options(url, header, params, data, json_text, auth, timeout, allow_redirects, verify, output, pretty, show_headers, status_only):
+    """HTTP OPTIONS"""
+    _run("OPTIONS", url, header, params, data, json_text, auth, timeout, allow_redirects, verify, output, pretty, show_headers, status_only)
+
+
+@cli.command()
+@common_options
+@click.argument("url")
+def patch(url, header, params, data, json_text, auth, timeout, allow_redirects, verify, output, pretty, show_headers, status_only):
+    """HTTP PATCH"""
+    _run("PATCH", url, header, params, data, json_text, auth, timeout, allow_redirects, verify, output, pretty, show_headers, status_only)
+
+
+def _run(method, url, header, params, data, json_text, auth, timeout, allow_redirects, verify, output, pretty, show_headers, status_only):
+    headers = _parse_kv(header)
+    params_d = _merge_params(params)
+    json_body = _load_json(json_text)
+    auth_data = _parse_auth(auth)
+    try:
+        resp = _request(
+            method=method,
+            url=url,
+            headers=headers,
+            params=params_d,
+            data=list(data),
+            json_body=json_body,
+            auth=auth_data,
+            timeout=timeout,
+            allow_redirects=allow_redirects,
+            verify=verify,
+        )
+    except requests.RequestException as e:
+        click.echo(f"Request failed: {e}", err=True)
+        sys.exit(2)
+
+    _print_response(resp, show_headers=show_headers, pretty=pretty, output=output, status_only=status_only)
+    # exit with non-zero if status >= 400
+    if resp.status_code >= 400:
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    cli()

uictlapi-0.1.1/src/uictlapi.egg-info/PKG-INFO

@@ -0,0 +1,110 @@
+Metadata-Version: 2.4
+Name: uictlapi
+Version: 0.1.1
+Summary: Curl-like CLI for the UniFi Controller / UniFi OS Web UI API, with login and CSRF handled for you.
+Author-email: Roman Akinfeev <akinfold@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/akinfold/uictlapi
+Project-URL: Repository, https://github.com/akinfold/uictlapi
+Project-URL: Issues, https://github.com/akinfold/uictlapi/issues
+Keywords: unifi,ubiquiti,api,cli,networking,controller,docker
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: System Administrators
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Internet
+Classifier: Topic :: System :: Networking
+Classifier: Topic :: Utilities
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: click>=8.0.0
+Requires-Dist: requests>=2.25.0
+Requires-Dist: requests-unifi-auth>=0.1.5
+Provides-Extra: test
+Requires-Dist: pytest>=7.0.0; extra == "test"
+Requires-Dist: pytest-cov>=4.0.0; extra == "test"
+Requires-Dist: ruff>=0.8.0; extra == "test"
+Dynamic: license-file
+
+# uictlapi
+
+[![PYPI](https://img.shields.io/pypi/v/uictlapi)](https://pypi.org/project/uictlapi/)
+[![Docker Image](https://img.shields.io/docker/v/akinfold/uictlapi?label=docker&sort=semver)](https://hub.docker.com/r/akinfold/uictlapi)
+[![MIT license](https://img.shields.io/badge/License-MIT-blue.svg)](https://github.com/akinfold/uictlapi/blob/main/LICENSE)
+
+Curl-like CLI for the UniFi Controller / UniFi OS Web UI API — with login and CSRF
+handled for you.
+
+Auth and CSRF come from
+[`requests-unifi-auth`](https://github.com/akinfold/requests-unifi-auth). This package is
+only the HTTP CLI: any Web UI / proxy URL, any method. It is **not** a typed UniFi SDK and
+does not invent domain commands (`routes apply`, inventory, multi-controller orchestration).
+
+Live auth/CSRF compatibility against real controllers is tracked in
+[`requests-unifi-auth` COMPATIBILITY.md](https://github.com/akinfold/requests-unifi-auth/blob/main/COMPATIBILITY.md).
+
+## Installation
+
+### pip
+
+```bash
+pip install uictlapi
+```
+
+Requires `requests-unifi-auth>=0.1.5`.
+
+### Docker
+
+```bash
+docker run --rm akinfold/uictlapi:latest --help
+```
+
+## Usage
+
+Auth string: `user:pass@host` (or `@/path/to/file` containing the same).
+
+```bash
+# Read traffic routes (policy-based routing)
+uictlapi get -a 'user:pass@192.168.1.1' --no-verify \
+  'https://192.168.1.1/proxy/network/v2/api/site/default/trafficroutes'
+
+# Same via Docker
+docker run --rm akinfold/uictlapi:latest get -a 'user:pass@192.168.1.1' --no-verify \
+  'https://192.168.1.1/proxy/network/v2/api/site/default/trafficroutes'
+
+# POST JSON body (from string or @file)
+uictlapi post -a 'user:pass@192.168.1.1' --no-verify \
+  -j '{"enabled":true}' \
+  'https://192.168.1.1/proxy/network/v2/api/site/default/some-endpoint'
+
+uictlapi --version
+```
+
+Common flags mirror curl-ish habits: `-H` / `-p` / `-d` / `-j` / `-o` / `--show-headers` /
+`--status-only` / `--no-verify` / `-t`. Exit status `1` on HTTP ≥ 400, `2` on transport errors.
+
+## Releasing
+
+Version lives in `pyproject.toml` and `src/uictlapi/__init__.py`. Bump on `main` first
+(GitHub Actions → **Bump version**, or locally with `bump-my-version`), then:
+
+```bash
+git tag vX.Y.Z
+git push origin vX.Y.Z
+```
+
+The **Publish** workflow runs tests, uploads to PyPI, pushes multi-arch Docker images
+(`X.Y.Z`, `X.Y`, and `latest` when appropriate), and creates a GitHub Release.
+
+## License
+
+MIT

uictlapi-0.1.1/src/uictlapi.egg-info/SOURCES.txt

@@ -0,0 +1,12 @@
+LICENSE
+README.md
+pyproject.toml
+src/uictlapi/__init__.py
+src/uictlapi/cli.py
+src/uictlapi.egg-info/PKG-INFO
+src/uictlapi.egg-info/SOURCES.txt
+src/uictlapi.egg-info/dependency_links.txt
+src/uictlapi.egg-info/entry_points.txt
+src/uictlapi.egg-info/requires.txt
+src/uictlapi.egg-info/top_level.txt
+tests/test_cli.py

uictlapi-0.1.1/src/uictlapi.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

uictlapi-0.1.1/src/uictlapi.egg-info/entry_points.txt

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

uictlapi-0.1.1/src/uictlapi.egg-info/requires.txt

@@ -0,0 +1,8 @@
+click>=8.0.0
+requests>=2.25.0
+requests-unifi-auth>=0.1.5
+
+[test]
+pytest>=7.0.0
+pytest-cov>=4.0.0
+ruff>=0.8.0

uictlapi-0.1.1/src/uictlapi.egg-info/top_level.txt

@@ -0,0 +1 @@
+uictlapi

uictlapi-0.1.1/tests/test_cli.py

@@ -0,0 +1,166 @@
+import json
+from uictlapi import cli
+
+
+def test_parse_kv_basic():
+    res = cli._parse_kv(("a=1", "b: 2", "flag"))
+    assert res == {"a": "1", "b": "2", "flag": ""}
+
+
+def test_parse_auth_direct_and_file(tmp_path):
+    assert cli._parse_auth("user:pass@host") == ("user", "pass", "host")
+    p = tmp_path / "auth.txt"
+    p.write_text("foo:bar@192.0.2.1")
+    assert cli._parse_auth("@" + str(p)) == ("foo", "bar", "192.0.2.1")
+
+
+def test_parse_auth_invalid():
+    assert cli._parse_auth("invalidstring") is None
+
+
+def test_load_json_string_and_file_and_plain(tmp_path):
+    assert cli._load_json('{"x":1}') == {"x": 1}
+    p = tmp_path / "data.json"
+    p.write_text('["a", 1]')
+    assert cli._load_json("@" + str(p)) == ["a", 1]
+    assert cli._load_json("not a json") == "not a json"
+
+
+def test_request_uses_json_and_auth(monkeypatch):
+    captured = {}
+
+    def fake_request(method, url, **kwargs):
+        captured["method"] = method
+        captured["url"] = url
+        captured["kwargs"] = kwargs
+
+        class Dummy:
+            pass
+
+        return Dummy()
+
+    # make UnifiControllerAuth return a sentinel object
+    monkeypatch.setattr(cli, "UnifiControllerAuth", lambda u, p, h: ("AUTHOBJ", u, p, h))
+    monkeypatch.setattr(cli.requests, "request", fake_request)
+
+    cli._request(
+        method="POST",
+        url="http://example.test",
+        headers={"H": "v"},
+        params={"q": "1"},
+        data=[],
+        json_body={"a": 1},
+        auth=("u", "p", "h"),
+        timeout=5,
+        allow_redirects=True,
+        verify=False,
+    )
+
+    assert captured["method"] == "POST"
+    assert captured["url"] == "http://example.test"
+    assert captured["kwargs"]["json"] == {"a": 1}
+    assert "data" not in captured["kwargs"]
+    assert captured["kwargs"]["auth"] == ("AUTHOBJ", "u", "p", "h")
+
+
+def test_request_data_file_and_multiple(monkeypatch, tmp_path):
+    calls = []
+
+    def fake_request(method, url, **kwargs):
+        calls.append(kwargs)
+
+        class Dummy:
+            pass
+
+        return Dummy()
+
+    monkeypatch.setattr(cli, "UnifiControllerAuth", lambda u, p, h: None)
+    monkeypatch.setattr(cli.requests, "request", fake_request)
+
+    f = tmp_path / "bin.dat"
+    f.write_bytes(b"binarycontent")
+
+    # single data file -> bytes body
+    cli._request(
+        method="PUT",
+        url="http://x.test",
+        headers={},
+        params={},
+        data=[f"@{f}"],
+        json_body=None,
+        auth=None,
+        timeout=None,
+        allow_redirects=True,
+        verify=True,
+    )
+    assert calls[0]["data"] == b"binarycontent"
+
+    # multiple data entries -> dict
+    calls.clear()
+    cli._request(
+        method="PUT",
+        url="http://x.test",
+        headers={},
+        params={},
+        data=["k=1", "v:2"],
+        json_body=None,
+        auth=None,
+        timeout=None,
+        allow_redirects=True,
+        verify=True,
+    )
+    assert calls[0]["data"] == {"k": "1", "v": "2"}
+
+
+def _make_dummy_response(status=200, content=b'{"ok":true}', headers=None, reason="OK"):
+    class Raw:
+        version = "1.1"
+
+    class DummyResp:
+        def __init__(self):
+            self.status_code = status
+            self.reason = reason
+            self.headers = headers or {"Content-Type": "application/json"}
+            self.content = content
+            self.raw = Raw()
+
+        def json(self):
+            return json.loads(self.content.decode("utf-8"))
+
+        @property
+        def text(self):
+            try:
+                return self.content.decode("utf-8")
+            except Exception:
+                return None
+
+    return DummyResp()
+
+
+def test_print_response_pretty_and_headers(capsys):
+    r = _make_dummy_response()
+    cli._print_response(r, show_headers=True, pretty=True, output=None, status_only=False)
+    out = capsys.readouterr().out
+    assert "HTTP/" in out
+    assert '"ok": true' in out
+
+
+def test_print_response_output_and_status_only(tmp_path, capsys):
+    r = _make_dummy_response(content=b"binarydata", headers={"Content-Type": "application/octet-stream"})
+    out_file = tmp_path / "out.bin"
+    cli._print_response(r, show_headers=False, pretty=False, output=str(out_file), status_only=False)
+    assert out_file.read_bytes() == b"binarydata"
+
+    # status_only prints only status code
+    cli._print_response(_make_dummy_response(status=404, content=b""), show_headers=False, pretty=False, output=None, status_only=True)
+    out = capsys.readouterr().out
+    assert "404" in out
+
+def test_cli_version():
+    from click.testing import CliRunner
+    from uictlapi import __version__
+    from uictlapi.cli import cli as cli_group
+
+    result = CliRunner().invoke(cli_group, ["--version"])
+    assert result.exit_code == 0
+    assert __version__ in result.output