typekit2 1.0.0__tar.gz → 2.0.1__tar.gz

{typekit2-1.0.0 → typekit2-2.0.1}/.gitignore

@@ -6,6 +6,7 @@ __pycache__/
 .env
 .venv/
 .codegraph/
+.omc/
 typekit2/__version__.py
 
 # C extensions
@@ -59,3 +60,4 @@ coverage.xml
 
 # Sphinx documentation
 docs/_build/
+/.omc

{typekit2-1.0.0 → typekit2-2.0.1}/CHANGELOG.md

@@ -6,8 +6,14 @@ this_file: CHANGELOG.md
 
 ## Unreleased
 
+### Fixed
+
+- Rewrote the `v1.0.0` and `v1.0.1` commits to strip a stray carriage return from the author identity, which GitHub Desktop could not parse.
+- Ignored local `.omc/` agent state so `publish.sh` sees a clean tree.
+
 ### Changed
 
+- Updated project links for the renamed `fontlaborg/typekit2-python` repository.
 - Renamed the distribution and import package from `typekit` to `typekit2`.
 - Replaced `setup.py` with standards-based `pyproject.toml` packaging.
 - Migrated the client from Python 2 to typed Python 3.10+.
@@ -22,8 +28,10 @@ this_file: CHANGELOG.md
 - Offline tests for authentication, transport, payloads, errors, parsing, and CLI behavior.
 - Tag-derived semantic versions using `hatch-vcs`.
 - `publish.sh` workflow using `uvx gitnextver`, `uv build`, and `uv publish`.
+- Compact `kit-fonts` discovery and read-only `request-get` escape-hatch commands.
+- Safe `plan-remove-fonts` and `remove-fonts` batch workflows with ID resolution, dry-run, full preservation checks, optional publish, and timeout reconciliation.
+- Official Adobe API Token page in setup and API documentation.
 
 ### Removed
 
 - Python 2-only code, live destructive tests, `setup.py`, and generated distutils manifest.
-

{typekit2-1.0.0 → typekit2-2.0.1}/PKG-INFO

@@ -1,9 +1,9 @@
 Metadata-Version: 2.5
 Name: typekit2
-Version: 1.0.0
+Version: 2.0.1
 Summary: Modern Python client and CLI for the Adobe Fonts (Typekit) API
 Project-URL: Documentation, https://fonts.adobe.com/docs/api
-Project-URL: Repository, https://github.com/fontlaborg/typekit-python
+Project-URL: Repository, https://github.com/fontlaborg/typekit2-python
 Author-email: Suchan Lee <lee.suchan@gmail.com>
 License-Expression: MIT
 License-File: LICENSE
@@ -51,6 +51,8 @@ cp .env.example .env
 export TYPEKIT_API_KEY='your-token'
 ```
 
+Create or copy the token from Adobe’s official [API Token page](https://fonts.adobe.com/account/tokens).
+
 `python-dotenv` loads `.env` without overriding an existing environment variable. Never commit `.env`; it is ignored.
 
 ## Python API
@@ -104,9 +106,26 @@ typekit2 family pcpv
 typekit2 variations pcpv
 typekit2 libraries
 typekit2 library full --page=1 --per-page=50
+typekit2 kit-fonts gav0zux --matching=halyard
+```
+
+### Safe batch removal
+
+Preview the exact slug/name/ID resolution and resulting family count without writing:
+
+```bash
+typekit2 plan-remove-fonts gav0zux halyard-display,halyard-micro,halyard-text
+```
+
+Apply the removal while proving every unrequested family ID remains, then publish:
+
+```bash
+typekit2 remove-fonts gav0zux halyard-display,halyard-micro,halyard-text --publish=true
 ```
 
-Mutating commands are explicit:
+The result reports the resolved IDs, before/after counts, preservation check, and publish status. Unknown names abort the whole operation before its first write. `--ignore-missing=true` makes reruns idempotent; `--dry-run=true` provides another preview path. A timed-out DELETE is reconciled against the draft before continuing, and a timed-out publish is reconciled against the published kit rather than retried blindly.
+
+Other mutating commands remain explicit:
 
 ```bash
 typekit2 create-kit Example --domains=example.com,www.example.com
@@ -127,6 +146,13 @@ typekit2 create-kit Example \
 
 Run `typekit2 --help` or `python -m typekit2 --help` for generated Fire help.
 
+All successful command results are JSON. Errors exit nonzero through Fire and never include the API key. For an API read not yet covered by a high-level command, use the authenticated read-only escape hatch:
+
+```bash
+typekit2 request-get families/pcpv
+typekit2 request-get libraries/full --params='{"page":2,"per_page":25}'
+```
+
 ## API behavior
 
 - Requests use `https://typekit.com/api/v1/json`.
@@ -159,3 +185,5 @@ Set `PUBLISH_SKIP_UPLOAD=1` to exercise the Git release and artifact verificatio
 ## License and provenance
 
 MIT. The project began as `typekit-python` by Suchan Lee; `typekit2` is its Python 3 modernization.
+
+Repository: [github.com/fontlaborg/typekit2-python](https://github.com/fontlaborg/typekit2-python)

{typekit2-1.0.0 → typekit2-2.0.1}/PLAN.md

@@ -16,9 +16,9 @@ The modernization target is a maintained Python 3 package whose library, CLI, do
 - Replace live account-mutating tests with deterministic request-level tests.
 - Document Adobe endpoints, parameter semantics, installation, API, CLI, and releases.
 - Add a guarded `gitnextver` and `uv publish` release workflow.
+- Add compact kit-family discovery and verified multi-family removal/publish workflows.
 
 ## Future work
 
 - Add opt-in live read-only smoke tests when a dedicated Adobe Fonts test account is available.
 - Add API resources only when they appear in Adobe’s authoritative reference.
-

{typekit2-1.0.0 → typekit2-2.0.1}/README.md

@@ -27,6 +27,8 @@ cp .env.example .env
 export TYPEKIT_API_KEY='your-token'
 ```
 
+Create or copy the token from Adobe’s official [API Token page](https://fonts.adobe.com/account/tokens).
+
 `python-dotenv` loads `.env` without overriding an existing environment variable. Never commit `.env`; it is ignored.
 
 ## Python API
@@ -80,9 +82,26 @@ typekit2 family pcpv
 typekit2 variations pcpv
 typekit2 libraries
 typekit2 library full --page=1 --per-page=50
+typekit2 kit-fonts gav0zux --matching=halyard
+```
+
+### Safe batch removal
+
+Preview the exact slug/name/ID resolution and resulting family count without writing:
+
+```bash
+typekit2 plan-remove-fonts gav0zux halyard-display,halyard-micro,halyard-text
+```
+
+Apply the removal while proving every unrequested family ID remains, then publish:
+
+```bash
+typekit2 remove-fonts gav0zux halyard-display,halyard-micro,halyard-text --publish=true
 ```
 
-Mutating commands are explicit:
+The result reports the resolved IDs, before/after counts, preservation check, and publish status. Unknown names abort the whole operation before its first write. `--ignore-missing=true` makes reruns idempotent; `--dry-run=true` provides another preview path. A timed-out DELETE is reconciled against the draft before continuing, and a timed-out publish is reconciled against the published kit rather than retried blindly.
+
+Other mutating commands remain explicit:
 
 ```bash
 typekit2 create-kit Example --domains=example.com,www.example.com
@@ -103,6 +122,13 @@ typekit2 create-kit Example \
 
 Run `typekit2 --help` or `python -m typekit2 --help` for generated Fire help.
 
+All successful command results are JSON. Errors exit nonzero through Fire and never include the API key. For an API read not yet covered by a high-level command, use the authenticated read-only escape hatch:
+
+```bash
+typekit2 request-get families/pcpv
+typekit2 request-get libraries/full --params='{"page":2,"per_page":25}'
+```
+
 ## API behavior
 
 - Requests use `https://typekit.com/api/v1/json`.
@@ -135,3 +161,5 @@ Set `PUBLISH_SKIP_UPLOAD=1` to exercise the Git release and artifact verificatio
 ## License and provenance
 
 MIT. The project began as `typekit-python` by Suchan Lee; `typekit2` is its Python 3 modernization.
+
+Repository: [github.com/fontlaborg/typekit2-python](https://github.com/fontlaborg/typekit2-python)

{typekit2-1.0.0 → typekit2-2.0.1}/WORK.md

@@ -12,11 +12,14 @@ this_file: WORK.md
 - Renamed the package to `typekit2` and implemented the modern client and CLI.
 - Added offline contract tests before implementation.
 - Added tag-derived versioning and a guarded publish workflow.
+- Updated the Git remote and package metadata for `fontlaborg/typekit2-python`.
+- Added compact family discovery, batch-removal preview, verified batch removal, read-only raw GET, and publish-timeout reconciliation to the Fire CLI.
 
 ### Verification
 
 - `ruff format --check` and `ruff check`: passed.
-- Offline suite: 31 tests passed with 95.67% branch-aware coverage.
+- Offline suite: 44 tests passed with 93.93% branch-aware coverage after the CLI workflow extension.
 - Fresh `uv build --no-sources`: wheel and sdist built successfully; metadata names `typekit2`, the wheel contains `typekit2/__main__.py` and generated `typekit2/__version__.py`, and no legacy `typekit/` package is present.
 - Installed-artifact smoke test from `/tmp`: both `typekit2 doctor` and `python -m typekit2 doctor` returned redacted JSON.
 - Disposable release rehearsal: `publish.sh` advanced a local test repository from `v0.1.0` to `v0.1.1`, pushed matching branch/tag refs to a local bare remote, built matching artifacts, and skipped only PyPI upload under `PUBLISH_SKIP_UPLOAD=1`.
+- Live read-only CLI checks listed the three Halyard variable families in `gav0zux` and produced a correct three-family removal preview without changing the kit.

{typekit2-1.0.0 → typekit2-2.0.1}/docs/API.md

@@ -8,7 +8,7 @@ The service and URL paths retain the Typekit name even though the product is now
 
 ## Authentication and transport
 
-Adobe requires authenticated requests to use HTTPS. `typekit2` sends `TYPEKIT_API_KEY` as `X-Typekit-Token`, following the [authentication reference](https://fonts.adobe.com/docs/api/auth). It deliberately avoids the documented query-string fallback because URLs are commonly retained in logs and traces.
+Create the credential on Adobe’s official [API Token page](https://fonts.adobe.com/account/tokens). Adobe requires authenticated requests to use HTTPS. `typekit2` sends `TYPEKIT_API_KEY` as `X-Typekit-Token`, following the [authentication reference](https://fonts.adobe.com/docs/api/auth). It deliberately avoids the documented query-string fallback because URLs are commonly retained in logs and traces.
 
 Form bodies follow Adobe’s [parameter encoding](https://fonts.adobe.com/docs/api/parameters): repeated values use `name[]`, while family objects use keys such as `families[0][id]`.
 
@@ -30,6 +30,14 @@ Form bodies follow Adobe’s [parameter encoding](https://fonts.adobe.com/docs/a
 | `list_libraries()` | `GET libraries` | Available font libraries |
 | `get_library(...)` | `GET libraries/:library` | Supports `page` and `per_page` |
 
+## Safe CLI workflows
+
+- `kit-fonts` returns compact family records and supports substring filtering across IDs, slugs, and names.
+- `plan-remove-fonts` resolves every requested ID, slug, or name before writing and returns the projected count.
+- `remove-fonts` issues narrow family DELETEs, then compares the complete before/after ID sets to prove unrelated families remain.
+- `remove-fonts --publish=true` publishes only after draft verification. Network errors are reconciled against current draft/published state because a mutating timeout has an indeterminate outcome.
+- `request-get` is a read-only raw escape hatch; raw POST or DELETE calls are intentionally not exposed.
+
 Reference pages: [kit manipulation](https://fonts.adobe.com/docs/api/kits), [font families](https://fonts.adobe.com/docs/api/v1/:format/families/:family), [libraries](https://fonts.adobe.com/docs/api/v1/:format/libraries), and [errors](https://fonts.adobe.com/docs/api/errors).
 
 ## Important semantics
@@ -42,4 +50,3 @@ Reference pages: [kit manipulation](https://fonts.adobe.com/docs/api/kits), [fon
 - The legacy analytics option is deprecated by Adobe and is intentionally not exposed.
 
 The upstream documentation is old in vocabulary but remains live and dated © 2026. `typekit2` documents only behavior supported by those current pages.
-

{typekit2-1.0.0 → typekit2-2.0.1}/pyproject.toml

@@ -29,7 +29,7 @@ classifiers = [
 
 [project.urls]
 Documentation = "https://fonts.adobe.com/docs/api"
-Repository = "https://github.com/fontlaborg/typekit-python"
+Repository = "https://github.com/fontlaborg/typekit2-python"
 
 [project.scripts]
 typekit2 = "typekit2.__main__:main"

{typekit2-1.0.0 → typekit2-2.0.1}/tests/test_cli.py

@@ -6,6 +6,7 @@ import json
 
 import pytest
 
+import typekit2.__main__ as cli_module
 from typekit2.__main__ import TypekitCLI, _serialize, parse_csv, parse_families
 
 
@@ -65,7 +66,7 @@ class FakeClient:
 
 def test_cli_commands_delegate_with_parsed_values(monkeypatch: pytest.MonkeyPatch) -> None:
     fake = FakeClient()
-    monkeypatch.setattr(TypekitCLI, "client", property(lambda _: fake))
+    monkeypatch.setattr(TypekitCLI, "_client", property(lambda _: fake))
     cli = TypekitCLI()
 
     assert cli.kits()["method"] == "list_kits"
@@ -83,3 +84,72 @@ def test_cli_commands_delegate_with_parsed_values(monkeypatch: pytest.MonkeyPatc
     assert cli.publish_kit("abc")["method"] == "publish_kit"
     assert cli.add_font("abc", "pcpv", "n4,i4")["args"][2] == ["n4", "i4"]
     assert cli.remove_font("abc", "pcpv")["method"] == "remove_font"
+
+
+def test_cli_uses_configured_timeout_and_exposes_batch_workflows(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    fake = FakeClient()
+    monkeypatch.setattr("typekit2.__main__.Typekit", lambda timeout: (fake, timeout))
+    cli = TypekitCLI(timeout=75)
+
+    assert cli._client == (fake, 75)
+
+
+def test_cli_batch_commands_parse_and_delegate(monkeypatch: pytest.MonkeyPatch) -> None:
+    fake = FakeClient()
+    monkeypatch.setattr(TypekitCLI, "_client", property(lambda _: fake))
+    monkeypatch.setattr(
+        cli_module,
+        "kit_fonts",
+        lambda client, kit_id, **kwargs: {"client": client, "kit_id": kit_id, **kwargs},
+    )
+    monkeypatch.setattr(
+        cli_module,
+        "plan_remove_fonts",
+        lambda client, kit_id, families: {"families": families},
+    )
+    monkeypatch.setattr(
+        cli_module,
+        "remove_fonts",
+        lambda client, kit_id, families, **kwargs: {"families": families, **kwargs},
+    )
+    cli = TypekitCLI()
+
+    assert cli.kit_fonts("abc", matching="halyard")["matching"] == "halyard"
+    assert cli.plan_remove_fonts("abc", "one,two")["families"] == ["one", "two"]
+    result = cli.remove_fonts("abc", "one,two", publish=True, publish_timeout=90)
+    assert result["families"] == ["one", "two"]
+    assert result["publish"] is True
+    assert result["publish_timeout"] == 90
+
+
+def test_cli_read_only_escape_hatch_parses_json_params(monkeypatch: pytest.MonkeyPatch) -> None:
+    fake = FakeClient()
+    monkeypatch.setattr(TypekitCLI, "_client", property(lambda _: fake))
+    cli = TypekitCLI()
+
+    result = cli.request_get("libraries/full", '{"page": 2}')
+
+    assert result["method"] == "request"
+    assert result["args"] == ("GET", "libraries/full")
+    assert result["kwargs"] == {"params": {"page": 2}}
+    with pytest.raises(ValueError, match="JSON object"):
+        cli.request_get("libraries/full", "[]")
+
+
+def test_main_exposes_command_instance_without_public_client(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    captured = {}
+    monkeypatch.setattr(
+        cli_module.fire,
+        "Fire",
+        lambda component, **kwargs: captured.update(component=component, kwargs=kwargs),
+    )
+
+    cli_module.main()
+
+    assert isinstance(captured["component"], TypekitCLI)
+    assert not hasattr(captured["component"], "client")
+    assert captured["kwargs"]["name"] == "typekit2"

{typekit2-1.0.0 → typekit2-2.0.1}/tests/test_client.py

@@ -217,3 +217,22 @@ def test_resource_methods_use_documented_paths_and_escaped_ids() -> None:
         "https://typekit.com/api/v1/json/kits/abc123",
     ]
     assert session.calls[4]["data"] == [("subset", "all"), ("variations", "n4")]
+
+
+def test_request_and_publish_allow_per_call_timeout() -> None:
+    session = FakeSession(FakeResponse({"published": "now"}))
+    client = Typekit(api_key="secret", session=session, timeout=7.5)
+
+    client.publish_kit("abc123", timeout=120)
+
+    assert session.calls[0]["timeout"] == 120
+
+
+def test_request_rejects_nonpositive_per_call_timeout_before_network() -> None:
+    session = FakeSession(FakeResponse({}))
+    client = Typekit(api_key="secret", session=session)
+
+    with pytest.raises(ValueError, match="greater than zero"):
+        client.request("GET", "kits", timeout=0)
+
+    assert session.calls == []

{typekit2-1.0.0 → typekit2-2.0.1}/tests/test_packaging.py

@@ -17,6 +17,9 @@ def test_pyproject_uses_typekit2_hatch_vcs_and_fire_entry_point() -> None:
     assert config["project"]["name"] == "typekit2"
     assert config["project"]["dynamic"] == ["version"]
     assert config["project"]["scripts"] == {"typekit2": "typekit2.__main__:main"}
+    assert config["project"]["urls"]["Repository"] == (
+        "https://github.com/fontlaborg/typekit2-python"
+    )
     assert config["tool"]["hatch"]["version"]["source"] == "vcs"
     assert (
         config["tool"]["hatch"]["build"]["hooks"]["vcs"]["version-file"]

typekit2-2.0.1/tests/test_workflows.py

@@ -0,0 +1,163 @@
+# this_file: tests/test_workflows.py
+
+from __future__ import annotations
+
+from copy import deepcopy
+
+import pytest
+
+from typekit2.exceptions import TypekitAPIError
+from typekit2.workflows import kit_fonts, plan_remove_fonts, remove_fonts
+
+
+def family(family_id: str, slug: str, name: str | None = None) -> dict:
+    return {
+        "id": family_id,
+        "slug": slug,
+        "name": name or slug.replace("-", " ").title(),
+        "subset": "default",
+        "variations": ["n4"],
+    }
+
+
+class FakeWorkflowClient:
+    def __init__(self, families: list[dict]) -> None:
+        self.families = deepcopy(families)
+        self.published = deepcopy(families)
+        self.remove_calls: list[tuple[str, str]] = []
+        self.publish_calls: list[tuple[str, float | None]] = []
+        self.remove_timeout_ids: set[str] = set()
+        self.publish_timeout = False
+        self.add_unexpected_family = False
+
+    def get_kit(self, kit_id: str, *, published: bool = False) -> dict:
+        selected = self.published if published else self.families
+        return {"kit": {"id": kit_id, "families": deepcopy(selected)}}
+
+    def get_published_kit(self, kit_id: str) -> dict:
+        return self.get_kit(kit_id, published=True)
+
+    def remove_font(self, kit_id: str, family_id: str) -> dict:
+        self.remove_calls.append((kit_id, family_id))
+        self.families = [item for item in self.families if item["id"] != family_id]
+        if self.add_unexpected_family:
+            self.families.append(family("unexpected", "unexpected-font"))
+            self.add_unexpected_family = False
+        if family_id in self.remove_timeout_ids:
+            raise TypekitAPIError("request timed out")
+        return {"ok": True}
+
+    def publish_kit(self, kit_id: str, *, timeout: float | None = None) -> dict:
+        self.publish_calls.append((kit_id, timeout))
+        self.published = deepcopy(self.families)
+        if self.publish_timeout:
+            raise TypekitAPIError("request timed out")
+        return {"published": "now"}
+
+    def request(self, method: str, path: str, **kwargs) -> dict:
+        return {"method": method, "path": path, **kwargs}
+
+
+HALYARD = [
+    family("ykgy", "halyard-display"),
+    family("hfhh", "halyard-micro"),
+    family("gvck", "halyard-text"),
+    family("bqky", "halyard-display-variable"),
+    family("nqbl", "halyard-micro-variable"),
+    family("cnlf", "halyard-text-variable"),
+    family("other", "other-font"),
+]
+
+
+def test_kit_fonts_returns_compact_sorted_filtered_records() -> None:
+    client = FakeWorkflowClient(HALYARD)
+
+    result = kit_fonts(client, "kit123", matching="variable")
+
+    assert result["kit_id"] == "kit123"
+    assert result["family_count"] == 3
+    assert [item["slug"] for item in result["families"]] == [
+        "halyard-display-variable",
+        "halyard-micro-variable",
+        "halyard-text-variable",
+    ]
+
+
+def test_plan_remove_fonts_resolves_slugs_ids_and_names_without_writing() -> None:
+    client = FakeWorkflowClient(HALYARD)
+
+    result = plan_remove_fonts(client, "kit123", ["halyard-display", "hfhh", "Halyard Text"])
+
+    assert result["status"] == "preview"
+    assert [item["id"] for item in result["remove"]] == ["ykgy", "hfhh", "gvck"]
+    assert result["before_family_count"] == 7
+    assert result["after_family_count"] == 4
+    assert client.remove_calls == []
+
+
+def test_remove_fonts_rejects_missing_identifier_before_writing() -> None:
+    client = FakeWorkflowClient(HALYARD)
+
+    with pytest.raises(ValueError, match="not present"):
+        remove_fonts(client, "kit123", ["halyard-display", "typo"])
+
+    assert client.remove_calls == []
+
+
+def test_remove_fonts_preserves_every_unrequested_family_and_publishes() -> None:
+    client = FakeWorkflowClient(HALYARD)
+
+    result = remove_fonts(
+        client,
+        "kit123",
+        ["halyard-display", "halyard-micro", "halyard-text"],
+        publish=True,
+        publish_timeout=120,
+    )
+
+    assert result["status"] == "removed"
+    assert result["before_family_count"] == 7
+    assert result["after_family_count"] == 4
+    assert result["unrelated_families_preserved"] is True
+    assert result["publish"] == {"status": "accepted", "response": {"published": "now"}}
+    assert client.publish_calls == [("kit123", 120)]
+    assert {item["slug"] for item in client.families} == {
+        "halyard-display-variable",
+        "halyard-micro-variable",
+        "halyard-text-variable",
+        "other-font",
+    }
+
+
+def test_remove_fonts_reconciles_delete_and_publish_timeouts() -> None:
+    client = FakeWorkflowClient(HALYARD)
+    client.remove_timeout_ids = {"ykgy"}
+    client.publish_timeout = True
+
+    result = remove_fonts(client, "kit123", ["ykgy"], publish=True)
+
+    assert result["removed"][0]["id"] == "ykgy"
+    assert result["publish"]["status"] == "confirmed-after-error"
+    assert "timed out" in result["publish"]["error"]
+
+
+def test_remove_fonts_can_preview_or_ignore_already_absent_families() -> None:
+    client = FakeWorkflowClient(HALYARD)
+
+    preview = remove_fonts(client, "kit123", ["halyard-display"], dry_run=True)
+    absent = remove_fonts(client, "kit123", ["missing"], ignore_missing=True)
+
+    assert preview["status"] == "preview"
+    assert absent["status"] == "no-changes"
+    assert absent["missing"] == ["missing"]
+    assert client.remove_calls == []
+
+
+def test_remove_fonts_fails_if_any_unrequested_family_changes() -> None:
+    client = FakeWorkflowClient(HALYARD)
+    client.add_unexpected_family = True
+
+    with pytest.raises(TypekitAPIError, match="unexpected kit changes") as error:
+        remove_fonts(client, "kit123", ["halyard-display"])
+
+    assert error.value.errors[0]["unexpectedly_added"] == ["unexpected"]

{typekit2-1.0.0 → typekit2-2.0.1}/typekit2/__main__.py

@@ -11,7 +11,8 @@ from typing import Any
 import fire
 from dotenv import load_dotenv
 
-from .client import Typekit
+from .client import DEFAULT_TIMEOUT, Typekit
+from .workflows import kit_fonts, plan_remove_fonts, remove_fonts
 
 
 def parse_csv(value: str | Sequence[str]) -> list[str]:
@@ -36,10 +37,16 @@ def parse_families(value: str | list[dict[str, Any]] | None) -> list[dict[str, A
 class TypekitCLI:
     """Read and manage Adobe Fonts kits and font metadata."""
 
+    def __init__(self, timeout: float = DEFAULT_TIMEOUT) -> None:
+        """Configure the default HTTP timeout in seconds."""
+        if timeout <= 0:
+            raise ValueError("timeout must be greater than zero")
+        self._timeout = timeout
+
     @property
-    def client(self) -> Typekit:
+    def _client(self) -> Typekit:
         """Create the API client lazily so help and doctor work without credentials."""
-        return Typekit()
+        return Typekit(timeout=self._timeout)
 
     def doctor(self) -> dict[str, str]:
         """Check whether TYPEKIT_API_KEY is available without revealing it."""
@@ -52,27 +59,27 @@ class TypekitCLI:
 
     def kits(self) -> list[dict[str, Any]]:
         """List kits owned by the authenticated user."""
-        return self.client.list_kits()
+        return self._client.list_kits()
 
     def kit(self, kit_id: str, published: bool = False) -> dict[str, Any]:
         """Get a draft kit or its published version."""
-        return self.client.get_kit(kit_id, published=published)
+        return self._client.get_kit(kit_id, published=published)
 
     def family(self, family: str) -> dict[str, Any]:
         """Get a font family by ID or slug."""
-        return self.client.get_font_family(family)
+        return self._client.get_font_family(family)
 
     def variations(self, family: str) -> list[str]:
         """List FVD variation codes for a font family."""
-        return self.client.get_font_variations(family)
+        return self._client.get_font_variations(family)
 
     def libraries(self) -> list[dict[str, Any]]:
         """List font libraries."""
-        return self.client.list_libraries()
+        return self._client.list_libraries()
 
     def library(self, library: str, page: int = 1, per_page: int = 100) -> dict[str, Any]:
         """Get one paginated font library."""
-        return self.client.get_library(library, page=page, per_page=per_page)
+        return self._client.get_library(library, page=page, per_page=per_page)
 
     def create_kit(
         self,
@@ -82,7 +89,7 @@ class TypekitCLI:
         segmented_css_names: bool | None = None,
     ) -> dict[str, Any]:
         """Create a draft kit; domains are CSV and families are a JSON list."""
-        return self.client.create_kit(
+        return self._client.create_kit(
             name,
             parse_csv(domains),
             parse_families(families),
@@ -98,7 +105,7 @@ class TypekitCLI:
         segmented_css_names: bool | None = None,
     ) -> dict[str, Any]:
         """Update supplied draft-kit fields."""
-        return self.client.update_kit(
+        return self._client.update_kit(
             kit_id,
             name=name,
             domains=parse_csv(domains) if domains is not None else None,
@@ -108,11 +115,11 @@ class TypekitCLI:
 
     def remove_kit(self, kit_id: str) -> dict[str, Any]:
         """Delete a kit. This is a live destructive action."""
-        return self.client.remove_kit(kit_id)
+        return self._client.remove_kit(kit_id)
 
-    def publish_kit(self, kit_id: str) -> dict[str, Any]:
+    def publish_kit(self, kit_id: str, timeout: float = 120.0) -> dict[str, Any]:
         """Publish the current draft kit to the CDN."""
-        return self.client.publish_kit(kit_id)
+        return self._client.publish_kit(kit_id, timeout=timeout)
 
     def add_font(
         self,
@@ -123,11 +130,51 @@ class TypekitCLI:
     ) -> dict[str, Any]:
         """Add or replace one font family in a draft kit."""
         parsed = parse_csv(variations) if variations is not None else None
-        return self.client.add_font(kit_id, family, parsed, subset)
+        return self._client.add_font(kit_id, family, parsed, subset)
 
     def remove_font(self, kit_id: str, family: str) -> dict[str, Any]:
         """Remove one font family from a draft kit."""
-        return self.client.remove_font(kit_id, family)
+        return self._client.remove_font(kit_id, family)
+
+    def kit_fonts(
+        self,
+        kit_id: str,
+        matching: str | None = None,
+        published: bool = False,
+    ) -> dict[str, Any]:
+        """List concise kit families, optionally filtered by ID, slug, or name."""
+        return kit_fonts(self._client, kit_id, matching=matching, published=published)
+
+    def plan_remove_fonts(self, kit_id: str, families: str) -> dict[str, Any]:
+        """Preview a batch removal using comma-separated IDs, slugs, or names."""
+        return plan_remove_fonts(self._client, kit_id, parse_csv(families))
+
+    def remove_fonts(
+        self,
+        kit_id: str,
+        families: str,
+        publish: bool = False,
+        dry_run: bool = False,
+        ignore_missing: bool = False,
+        publish_timeout: float = 120.0,
+    ) -> dict[str, Any]:
+        """Remove several families, preserve all others, and optionally publish."""
+        return remove_fonts(
+            self._client,
+            kit_id,
+            parse_csv(families),
+            publish=publish,
+            dry_run=dry_run,
+            ignore_missing=ignore_missing,
+            publish_timeout=publish_timeout,
+        )
+
+    def request_get(self, path: str, params: str | None = None) -> dict[str, Any]:
+        """Make an authenticated raw GET; params is an optional JSON object."""
+        parsed = json.loads(params) if params else None
+        if parsed is not None and not isinstance(parsed, dict):
+            raise ValueError("params must be a JSON object")
+        return self._client.request("GET", path, params=parsed)
 
 
 def _serialize(value: Any) -> str:
@@ -137,7 +184,7 @@ def _serialize(value: Any) -> str:
 
 def main() -> None:
     """Run the typekit2 CLI."""
-    fire.Fire(TypekitCLI, name="typekit2", serialize=_serialize)
+    fire.Fire(TypekitCLI(), name="typekit2", serialize=_serialize)
 
 
 if __name__ == "__main__":

{typekit2-1.0.0 → typekit2-2.0.1}/typekit2/__version__.py

@@ -1,3 +1,3 @@
 # this_file: typekit2/__version__.py
 # Generated by hatch-vcs. Do not edit or commit.
-__version__ = version = '1.0.0'
+__version__ = version = '2.0.1'

{typekit2-1.0.0 → typekit2-2.0.1}/typekit2/client.py

@@ -98,14 +98,18 @@ class Typekit:
         *,
         data: FormData | None = None,
         params: Mapping[str, Any] | None = None,
+        timeout: float | None = None,
     ) -> dict[str, Any]:
         """Make an authenticated request and return the decoded JSON object."""
+        request_timeout = self.timeout if timeout is None else timeout
+        if request_timeout <= 0:
+            raise ValueError("timeout must be greater than zero")
         kwargs: dict[str, Any] = {
             "headers": {
                 "User-Agent": f"typekit2/{__version__}",
                 "X-Typekit-Token": self.api_key,
             },
-            "timeout": self.timeout,
+            "timeout": request_timeout,
         }
         if data is not None:
             kwargs["data"] = data
@@ -184,9 +188,9 @@ class Typekit:
         """Delete a kit."""
         return self.request("DELETE", f"kits/{quote(kit_id, safe='')}")
 
-    def publish_kit(self, kit_id: str) -> dict[str, Any]:
+    def publish_kit(self, kit_id: str, *, timeout: float | None = None) -> dict[str, Any]:
         """Publish the current draft kit asynchronously."""
-        return self.request("POST", f"kits/{quote(kit_id, safe='')}/publish")
+        return self.request("POST", f"kits/{quote(kit_id, safe='')}/publish", timeout=timeout)
 
     def get_font_family(self, family: str) -> dict[str, Any]:
         """Return a font family by ID or slug."""

typekit2-2.0.1/typekit2/workflows.py

@@ -0,0 +1,193 @@
+# this_file: typekit2/workflows.py
+"""Safe, composable workflows built on the Adobe Fonts API client."""
+
+from __future__ import annotations
+
+from collections.abc import Sequence
+from typing import Any
+
+from .exceptions import TypekitAPIError
+
+
+def _load_families(client: Any, kit_id: str, *, published: bool = False) -> list[dict[str, Any]]:
+    payload = client.get_published_kit(kit_id) if published else client.get_kit(kit_id)
+    families = payload.get("kit", {}).get("families")
+    if not isinstance(families, list) or not all(isinstance(item, dict) for item in families):
+        raise TypekitAPIError("Adobe Fonts returned an invalid kit family list")
+    return families
+
+
+def _compact(family: dict[str, Any]) -> dict[str, Any]:
+    return {
+        key: family[key] for key in ("id", "slug", "name", "subset", "variations") if key in family
+    }
+
+
+def _identifiers(values: str | Sequence[str]) -> list[str]:
+    items = values.split(",") if isinstance(values, str) else list(values)
+    parsed = [str(item).strip() for item in items if str(item).strip()]
+    if not parsed:
+        raise ValueError("families must contain at least one ID, slug, or name")
+    return parsed
+
+
+def _resolve(
+    families: list[dict[str, Any]], identifiers: list[str]
+) -> tuple[list[dict[str, Any]], list[str]]:
+    lookup: dict[str, dict[str, dict[str, Any]]] = {}
+    for family in families:
+        for field in ("id", "slug", "name"):
+            value = family.get(field)
+            if isinstance(value, str):
+                lookup.setdefault(value.casefold(), {})[str(family.get("id"))] = family
+    resolved: list[dict[str, Any]] = []
+    missing: list[str] = []
+    seen: set[str] = set()
+    for identifier in identifiers:
+        matches = list(lookup.get(identifier.casefold(), {}).values())
+        if not matches:
+            missing.append(identifier)
+            continue
+        if len(matches) > 1:
+            raise ValueError(f"family identifier is ambiguous: {identifier}")
+        family = matches[0]
+        family_id = str(family["id"])
+        if family_id not in seen:
+            resolved.append(family)
+            seen.add(family_id)
+    return resolved, missing
+
+
+def _plan(
+    kit_id: str, families: list[dict[str, Any]], identifiers: list[str]
+) -> tuple[dict[str, Any], list[dict[str, Any]]]:
+    resolved, missing = _resolve(families, identifiers)
+    plan = {
+        "status": "preview",
+        "kit_id": kit_id,
+        "requested": identifiers,
+        "remove": [_compact(family) for family in resolved],
+        "missing": missing,
+        "before_family_count": len(families),
+        "after_family_count": len(families) - len(resolved),
+    }
+    return plan, resolved
+
+
+def kit_fonts(
+    client: Any,
+    kit_id: str,
+    *,
+    matching: str | None = None,
+    published: bool = False,
+) -> dict[str, Any]:
+    """Return a concise, optionally filtered family inventory for one kit."""
+    families = _load_families(client, kit_id, published=published)
+    if matching:
+        needle = matching.casefold()
+        families = [
+            family
+            for family in families
+            if any(
+                needle in str(family.get(field, "")).casefold() for field in ("id", "slug", "name")
+            )
+        ]
+    compact = sorted(
+        (_compact(family) for family in families), key=lambda item: item.get("slug", "")
+    )
+    return {
+        "kit_id": kit_id,
+        "published": published,
+        "matching": matching,
+        "family_count": len(compact),
+        "families": compact,
+    }
+
+
+def plan_remove_fonts(client: Any, kit_id: str, families: str | Sequence[str]) -> dict[str, Any]:
+    """Resolve a batch removal by ID, slug, or name without changing the kit."""
+    current = _load_families(client, kit_id)
+    plan, _ = _plan(kit_id, current, _identifiers(families))
+    return plan
+
+
+def _verify_removal(
+    before: list[dict[str, Any]],
+    after: list[dict[str, Any]],
+    removed: list[dict[str, Any]],
+) -> None:
+    before_ids = {str(family["id"]) for family in before}
+    removed_ids = {str(family["id"]) for family in removed}
+    after_ids = {str(family["id"]) for family in after}
+    expected_ids = before_ids - removed_ids
+    if after_ids != expected_ids:
+        raise TypekitAPIError(
+            "Post-removal verification found unexpected kit changes",
+            errors=[
+                {
+                    "still_present": sorted(removed_ids & after_ids),
+                    "unexpectedly_removed": sorted(expected_ids - after_ids),
+                    "unexpectedly_added": sorted(after_ids - expected_ids),
+                }
+            ],
+        )
+
+
+def _publish_verified(
+    client: Any, kit_id: str, after: list[dict[str, Any]], timeout: float
+) -> dict[str, Any]:
+    try:
+        response = client.publish_kit(kit_id, timeout=timeout)
+    except TypekitAPIError as error:
+        published = _load_families(client, kit_id, published=True)
+        expected_ids = {str(family["id"]) for family in after}
+        published_ids = {str(family["id"]) for family in published}
+        if published_ids == expected_ids:
+            return {"status": "confirmed-after-error", "error": str(error)}
+        raise TypekitAPIError(
+            "Publish outcome is indeterminate; the published kit does not match the verified draft",
+            errors=[{"original_error": str(error)}],
+        ) from error
+    return {"status": "accepted", "response": response}
+
+
+def remove_fonts(
+    client: Any,
+    kit_id: str,
+    families: str | Sequence[str],
+    *,
+    publish: bool = False,
+    dry_run: bool = False,
+    ignore_missing: bool = False,
+    publish_timeout: float = 120.0,
+) -> dict[str, Any]:
+    """Remove several families while proving all unrequested families remain."""
+    before = _load_families(client, kit_id)
+    plan, resolved = _plan(kit_id, before, _identifiers(families))
+    if plan["missing"] and not ignore_missing:
+        missing = ", ".join(plan["missing"])
+        raise ValueError(f"families are not present in kit {kit_id}: {missing}")
+    if dry_run:
+        return plan
+    if not resolved:
+        return {**plan, "status": "no-changes", "publish": {"status": "skipped"}}
+    for family in resolved:
+        try:
+            client.remove_font(kit_id, str(family["id"]))
+        except TypekitAPIError:
+            current_ids = {str(item["id"]) for item in _load_families(client, kit_id)}
+            if str(family["id"]) in current_ids:
+                raise
+    after = _load_families(client, kit_id)
+    _verify_removal(before, after, resolved)
+    result = {
+        **plan,
+        "status": "removed",
+        "removed": [_compact(family) for family in resolved],
+        "after_family_count": len(after),
+        "unrelated_families_preserved": True,
+        "publish": {"status": "skipped"},
+    }
+    if publish:
+        result["publish"] = _publish_verified(client, kit_id, after, publish_timeout)
+    return result