Support Python 3.8 and compatible editable packaging

Author: rsgalloway

.github/workflows/tests.yml

@@ -7,7 +7,7 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        python: ['3.10', '3.12', '3.13']
+        python: ['3.8', '3.10', '3.12', '3.13']
     steps:
       - uses: actions/checkout@v4
       - uses: actions/setup-python@v5

README.md

@@ -6,11 +6,11 @@ BYO workers belong in the separate worker package, not this client.
 
 ## Development install
 
-Requires Python 3.10+ and a modern pip (21.3+ for editable installs).
+Requires Python 3.8+ and a modern pip (21.3+ for editable installs).
 Use a supported interpreter explicitly; the system `python3` may be older.
 
 ```bash
-python3.12 -m venv .venv
+python3 -m venv .venv
 source .venv/bin/activate
 python -m pip install --upgrade pip
 python -m pip install -e '.[dev]'
@@ -20,9 +20,10 @@ python -m twine check dist/*
 ```
 
 If pip reports that editable mode requires `setup.py`, check `python --version`
-and `python -m pip --version`. Python 3.8 is unsupported. Create a new environment
-with Python 3.10+ and upgrade pip there; upgrading pip alone cannot change its
-Python interpreter. A `setup.py` compatibility shim is not needed.
+and `python -m pip --version`. Upgrade pip inside the active environment:
+`python -m pip install --upgrade pip`. Python 3.8 is supported; pip will select
+the latest pip and dependencies compatible with that interpreter. A `setup.py`
+compatibility shim is not needed.
 
 With [uv](https://docs.astral.sh/uv/), a supported Python can also be provisioned
 without changing the system Python. Preserve an existing environment by using a

pyproject.toml

@@ -1,15 +1,14 @@
 [build-system]
-requires = ["setuptools>=77", "wheel"]
+requires = ["setuptools>=61", "wheel"]
 build-backend = "setuptools.build_meta"
 
 [project]
 name = "subfork"
 version = "0.1.0a1"
 description = "Python API client for Subfork graph authoring and execution"
 readme = "README.md"
-license = "BSD-3-Clause"
-license-files = ["LICENSE"]
-requires-python = ">=3.10"
+license = {file = "LICENSE"}
+requires-python = ">=3.8"
 dependencies = ["httpx>=0.28,<1"]
 classifiers = [
   "Development Status :: 3 - Alpha",
@@ -21,6 +20,9 @@ classifiers = [
 [project.optional-dependencies]
 dev = ["pytest>=8,<10", "build>=1,<2", "twine>=6,<7"]
 
+[tool.setuptools]
+license-files = ["LICENSE"]
+
 [tool.setuptools.packages.find]
 where = ["src"]
 

src/subfork/client.py

@@ -3,7 +3,7 @@
 
 import math
 import os
-from typing import Any
+from typing import Any, Optional
 
 import httpx
 
@@ -12,8 +12,8 @@
 
 
 class Subfork:
-    def __init__(self, api_key: str | None = None, *, base_url: str = 'https://subfork.com',
-                 timeout: float = 30, transport: httpx.BaseTransport | None = None):
+    def __init__(self, api_key: Optional[str] = None, *, base_url: str = 'https://subfork.com',
+                 timeout: float = 30, transport: Optional[httpx.BaseTransport] = None):
         key = os.environ.get('SUBFORK_API_KEY') if api_key is None else api_key
         if not key or any(char.isspace() for char in key):
             raise ValueError('Provide an API key or set SUBFORK_API_KEY; keys cannot contain whitespace.')

src/subfork/errors.py

@@ -1,4 +1,5 @@
 """Public client errors; credentials and raw responses are never attached."""
+from typing import Optional
 
 
 class SubforkError(Exception):
@@ -10,7 +11,7 @@ class TransportError(SubforkError):
 
 
 class APIError(SubforkError):
-    def __init__(self, message: str, *, status_code: int, retry_after: str | None = None):
+    def __init__(self, message: str, *, status_code: int, retry_after: Optional[str] = None):
         super().__init__(message)
         self.status_code = status_code
         self.retry_after = retry_after

src/subfork/resources.py

@@ -3,7 +3,7 @@
 
 import math
 import time
-from typing import TYPE_CHECKING, Any
+from typing import TYPE_CHECKING, Any, Dict, List, Optional
 from urllib.parse import quote
 
 from .errors import ExecutionTimeout
@@ -24,63 +24,63 @@ def __init__(self, client: Subfork):
 
 
 class Nodes(Resource):
-    def list(self, *, include_all_versions: bool = False) -> list[dict[str, Any]]:
+    def list(self, *, include_all_versions: bool = False) -> List[Dict[str, Any]]:
         return self._client._request('GET', '/nodes', params={'include_all_versions': include_all_versions})
 
-    def get(self, node_id: str) -> dict[str, Any]:
+    def get(self, node_id: str) -> Dict[str, Any]:
         return self._client._request('GET', '/nodes/' + segment(node_id))
 
 
 class Graphs(Resource):
-    def list(self) -> list[dict[str, Any]]:
+    def list(self) -> List[Dict[str, Any]]:
         return self._client._request('GET', '/graphs')
 
-    def get(self, graph_id: str) -> dict[str, Any]:
+    def get(self, graph_id: str) -> Dict[str, Any]:
         return self._client._request('GET', '/graphs/' + segment(graph_id))
 
-    def validate(self, definition: dict[str, Any], *, name: str | None = None) -> dict[str, Any]:
+    def validate(self, definition: Dict[str, Any], *, name: Optional[str] = None) -> Dict[str, Any]:
         return self._client._request('POST', '/graphs/validate', json={
             'name': name if name is not None else definition.get('name', 'Untitled Graph'), 'definition': definition})
 
-    def create(self, *, name: str, definition: dict[str, Any], description: str = '', tags: list[str] | None = None) -> dict[str, Any]:
+    def create(self, *, name: str, definition: Dict[str, Any], description: str = '', tags: Optional[List[str]] = None) -> Dict[str, Any]:
         return self._client._request('POST', '/graphs', json={
             'name': name, 'description': description, 'definition': definition, 'tags': tags or []})
 
-    def update(self, graph_id: str, *, name: str, definition: dict[str, Any], description: str = '') -> dict[str, Any]:
+    def update(self, graph_id: str, *, name: str, definition: Dict[str, Any], description: str = '') -> Dict[str, Any]:
         return self._client._request('PUT', '/graphs/' + segment(graph_id), json={
             'name': name, 'description': description, 'definition': definition})
 
-    def published(self) -> list[dict[str, Any]]:
+    def published(self) -> List[Dict[str, Any]]:
         return self._client._request('GET', '/graphs/published')
 
-    def versions(self, graph_id: str) -> list[dict[str, Any]]:
+    def versions(self, graph_id: str) -> List[Dict[str, Any]]:
         return self._client._request('GET', '/graphs/' + segment(graph_id) + '/versions')
 
-    def published_version(self, graph_id: str, version: str) -> dict[str, Any]:
+    def published_version(self, graph_id: str, version: str) -> Dict[str, Any]:
         return self._client._request('GET', '/graphs/published/' + segment(graph_id) + '/versions/' + segment(version))
 
-    def interface(self, graph_id: str) -> dict[str, Any]:
+    def interface(self, graph_id: str) -> Dict[str, Any]:
         return self._client._request('GET', '/graphs/' + segment(graph_id) + '/interface-preview')
 
-    def publish(self, graph_id: str, *, version: str, interface: dict[str, Any] | None = None, comment: str = '') -> dict[str, Any]:
-        payload: dict[str, Any] = {'version': version, 'comment': comment}
+    def publish(self, graph_id: str, *, version: str, interface: Optional[Dict[str, Any]] = None, comment: str = '') -> Dict[str, Any]:
+        payload: Dict[str, Any] = {'version': version, 'comment': comment}
         if interface is not None:
             payload['interface'] = interface
         return self._client._request('POST', '/graphs/' + segment(graph_id) + '/versions', json=payload)
 
-    def execute(self, graph_id: str, *, version: str = 'draft', inputs: dict[str, Any] | None = None) -> dict[str, Any]:
+    def execute(self, graph_id: str, *, version: str = 'draft', inputs: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
         return self._client._request('POST', '/graphs/' + segment(graph_id) + '/execute',
                                      params={'version': version}, json={'inputs': inputs or {}})
 
 
 class Executions(Resource):
-    def get(self, execution_id: str) -> dict[str, Any]:
+    def get(self, execution_id: str) -> Dict[str, Any]:
         return self._client._request('GET', '/executions/' + segment(execution_id))
 
-    def cancel(self, execution_id: str) -> dict[str, Any]:
+    def cancel(self, execution_id: str) -> Dict[str, Any]:
         return self._client._request('POST', '/executions/' + segment(execution_id) + '/cancel')
 
-    def wait(self, execution_id: str, *, timeout: float = 120, poll_interval: float = 2) -> dict[str, Any]:
+    def wait(self, execution_id: str, *, timeout: float = 120, poll_interval: float = 2) -> Dict[str, Any]:
         if not math.isfinite(timeout) or timeout <= 0 or not math.isfinite(poll_interval) or poll_interval <= 0:
             raise ValueError('timeout and poll_interval must be positive finite numbers.')
         deadline = time.monotonic() + timeout