theclassifier 0.1.0__tar.gz → 0.2.0__tar.gz

theclassifier-0.2.0/PKG-INFO

@@ -0,0 +1,260 @@
+Metadata-Version: 2.4
+Name: theclassifier
+Version: 0.2.0
+Summary: Classify text through an API or locally, and train models from your own examples
+Author: TrueState
+License-Expression: Apache-2.0
+Project-URL: Homepage, https://theclassifier.ai
+Project-URL: Documentation, https://theclassifier.ai/docs
+Project-URL: Repository, https://github.com/truestate-ai/theclassifier
+Project-URL: Issues, https://github.com/truestate-ai/theclassifier/issues
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests<3,>=2.32
+Provides-Extra: local
+Requires-Dist: torch<3,>=2.6; extra == "local"
+Requires-Dist: transformers<6,>=4.56; extra == "local"
+Requires-Dist: peft<1,>=0.17; extra == "local"
+Requires-Dist: accelerate<2,>=1; extra == "local"
+Requires-Dist: huggingface-hub<2,>=0.34; extra == "local"
+Requires-Dist: safetensors>=0.5; extra == "local"
+Provides-Extra: train
+Requires-Dist: theclassifier[local]; extra == "train"
+Requires-Dist: pandas<4,>=2; extra == "train"
+Requires-Dist: numpy<3,>=1.26; extra == "train"
+Provides-Extra: serve
+Requires-Dist: theclassifier[local]; extra == "serve"
+Requires-Dist: fastapi<1,>=0.115; extra == "serve"
+Requires-Dist: uvicorn<1,>=0.30; extra == "serve"
+Provides-Extra: dev
+Requires-Dist: theclassifier[serve]; extra == "dev"
+Requires-Dist: theclassifier[train]; extra == "dev"
+Requires-Dist: pytest>=8; extra == "dev"
+Requires-Dist: httpx; extra == "dev"
+Requires-Dist: build; extra == "dev"
+Requires-Dist: twine; extra == "dev"
+Dynamic: license-file
+
+# The Classifier
+
+Classify text into categories you choose, using the API or your own computer.
+You can also train a model from a table of examples, then save it for later.
+
+## Install
+
+Install the Python client:
+
+```sh
+pip install --upgrade theclassifier
+```
+
+For local use or training, install the training extra instead:
+
+```sh
+pip install --upgrade 'theclassifier[train]'
+```
+
+Python 3.10 or later is required. API use only needs Requests; training support
+adds the libraries needed to run models and work with pandas and NumPy.
+
+## Classify text
+
+Create an account at [theclassifier.ai](https://theclassifier.ai), then create an
+API key in the dashboard. Set the `CLASSIFIER_API_KEY` environment variable to your key.
+The service URL defaults to `https://api.theclassifier.ai`; set
+`CLASSIFIER_API_PUBLIC_URL` to override it, or pass `base_url=` to the constructor.
+No other application environment variables are required.
+
+```python
+import os
+from theclassifier import Classifier
+
+classifier = Classifier(api_key=os.environ["CLASSIFIER_API_KEY"])
+result = classifier.classify(
+    "Please close my account.",
+    choices=["cancellation", "billing", "none"],
+)
+print(result["results"][0]["selected"]["choice"])
+```
+
+`choices` contains the answers the model is allowed to choose. Add `none` when
+some text might not fit the other categories; it is not added automatically.
+The result includes the selected answer and scores for all choices. Scores are
+relative to the choices, not a guarantee that the answer is correct.
+
+For a more specific question:
+
+```python
+result = classifier.classify(
+    "Please close my account.",
+    question="What does the customer want?",
+    choices=[
+        {"choice": "cancellation", "criteria": "Requests to close an account."},
+        {"choice": "billing", "criteria": "Questions about charges or payments."},
+        {"choice": "none", "criteria": "Neither of the other categories fits."},
+    ],
+)
+```
+
+## Choose a model
+
+The defaults are `version="latest"` and `domain="general"`.
+`version` selects a model release; `domain` selects its area of use.
+Currently `latest`, `1.1` and `1.1.0` refer to model release 1.1.0.
+The package version (0.2.0) and model version (1.1.0) are separate.
+
+| Domain | Use it for |
+| --- | --- |
+| general | General text classification; start here if unsure |
+| intent | What a customer wants to do |
+| sentiment | Positive, neutral or negative language |
+| triage | Support ticket categories |
+| cause | The issue or reason reported in a complaint |
+| codify | Product and service categories |
+| complaints | Financial complaint products and issues |
+| stars | One-to-five review ratings |
+
+```python
+result = classifier.classify(
+    "Great service!",
+    choices=["positive", "neutral", "negative"],
+    domain="sentiment",
+    version="1.1",
+)
+```
+
+Versions and domains are discovered from [Hugging Face](https://huggingface.co/TrueState/theclassifier):
+
+```python
+from theclassifier import available_versions, available_domains
+
+print(available_versions())
+print(available_domains(version="latest"))
+```
+
+Local `latest` follows the release catalog on Hugging Face. New models can be
+added without updating the Python package. Each version points to a fixed model
+revision, and downloaded weights are reused from the local cache. An existing
+classifier stays on its resolved version; create a new one to pick up a newer release.
+
+The catalog is cached after a successful lookup. Use `offline=True` with either
+function to read only the cache. Network failures also fall back to the cached
+catalog. Saved model folders load without looking up the catalog.
+
+The hosted API resolves its own `latest`; `/v1/versions` lists models currently
+available on that service, which may differ from those published on Hugging Face.
+
+## Run on your computer
+
+Use the same call with `mode="local"`:
+
+```python
+result = classifier.classify(
+    "Great service!",
+    choices=["positive", "neutral", "negative"],
+    mode="local",
+)
+```
+
+The first local call downloads the model. Later calls reuse the local copy.
+Text stays on your computer. The constructor still requires an API key, but local
+calls do not transmit or validate it. Use `device="cpu"` or `device="cuda"` at
+construction to choose a device; the default automatically uses an available
+NVIDIA GPU, otherwise the CPU. Apple GPU acceleration is not currently supported.
+
+## Train from your own examples
+
+Your DataFrame needs two columns: `text` and its correct `label`.
+
+```python
+import pandas as pd
+
+df = pd.DataFrame({
+    "text": ["Please close my account.", "I was charged twice."],
+    "label": ["cancellation", "billing"],
+})
+
+fine_tuned = classifier.fine_tune(data=df)
+result = fine_tuned.classify("Please cancel my account.")
+print(result["results"][0]["selected"]["choice"])
+```
+
+The new classifier remembers the labels, runs locally, and leaves the original
+unchanged. It stays in memory until you save it. Training text is not sent to
+the API. The small example shows the format; use representative examples and
+check predictions on separate examples that were not used for training.
+
+A NumPy array also works: `classifier.fine_tune(data=df.to_numpy())`. It must
+have two columns in this order: text, label. Both must contain non-empty strings.
+Normally there must be at least two different labels. Optional `choices=` lets
+you provide the full set explicitly, including a fallback such as `none`.
+
+## Save and load
+
+```python
+fine_tuned.save("~/Downloads/my_classifier")
+
+loaded = Classifier(
+    api_key=os.environ["CLASSIFIER_API_KEY"],
+    model_path="~/Downloads/my_classifier",
+)
+result = loaded.classify("Please cancel my account.")
+```
+
+Saving writes a complete model and its labels. It leaves the in-memory model
+unchanged. The destination must be empty; existing models are never overwritten.
+Loading restores the labels and uses your computer automatically. Keep the entire
+saved folder together. After the required Python libraries are installed, a saved
+model can run without downloading the original model again.
+
+## Optional settings
+
+Most users can keep the defaults. Pass these as named arguments when needed:
+
+| Setting | Where | Meaning |
+| --- | --- | --- |
+| `mode="api"` or `"local"` | `classify` | Use the service or your computer |
+| `version`, `domain` | Constructor or `classify` | Select a model |
+| `epochs=1` | `fine_tune` | Passes through your training examples |
+| `max_steps=1, grad_accum=1` | `fine_tune` | A quick one-step training check |
+| `question="Which label fits?"` | `classify` or `fine_tune` | Describe the decision |
+| `timeout=60` | Constructor | API timeout in seconds |
+| `offline=True` | Constructor | Require local files and disable API calls |
+
+API failures raise Requests exceptions. A 401 usually means the key is invalid;
+a 429 means the request limit was reached. Respect `Retry-After` before retrying.
+The client does not automatically retry or switch between the API and local mode.
+Custom models run locally; they are not uploaded to the service by training or saving.
+
+## Serve your saved model
+
+Install the `serve` extra, then run:
+
+```sh
+theclassifier serve --model-path ~/Downloads/my_classifier
+```
+
+The local server listens at `http://127.0.0.1:8090`. It runs your model without
+API keys, accounts, billing, or rate limits. Send requests directly:
+
+```python
+import requests
+
+response = requests.post(
+    "http://127.0.0.1:8090/v1/classify",
+    json={
+        "state": "Please close my account.",
+        "questions": [{
+            "question": "What does the customer want?",
+            "choices": ["cancel account", "billing help", "technical support"],
+        }],
+    },
+    timeout=60,
+)
+response.raise_for_status()
+print(response.json())
+```
+
+Code and published model weights use Apache-2.0. See the technical paper for
+research details and evaluation. Maintainers can find release checks in RELEASE.md.

theclassifier-0.2.0/README.md

@@ -0,0 +1,222 @@
+# The Classifier
+
+Classify text into categories you choose, using the API or your own computer.
+You can also train a model from a table of examples, then save it for later.
+
+## Install
+
+Install the Python client:
+
+```sh
+pip install --upgrade theclassifier
+```
+
+For local use or training, install the training extra instead:
+
+```sh
+pip install --upgrade 'theclassifier[train]'
+```
+
+Python 3.10 or later is required. API use only needs Requests; training support
+adds the libraries needed to run models and work with pandas and NumPy.
+
+## Classify text
+
+Create an account at [theclassifier.ai](https://theclassifier.ai), then create an
+API key in the dashboard. Set the `CLASSIFIER_API_KEY` environment variable to your key.
+The service URL defaults to `https://api.theclassifier.ai`; set
+`CLASSIFIER_API_PUBLIC_URL` to override it, or pass `base_url=` to the constructor.
+No other application environment variables are required.
+
+```python
+import os
+from theclassifier import Classifier
+
+classifier = Classifier(api_key=os.environ["CLASSIFIER_API_KEY"])
+result = classifier.classify(
+    "Please close my account.",
+    choices=["cancellation", "billing", "none"],
+)
+print(result["results"][0]["selected"]["choice"])
+```
+
+`choices` contains the answers the model is allowed to choose. Add `none` when
+some text might not fit the other categories; it is not added automatically.
+The result includes the selected answer and scores for all choices. Scores are
+relative to the choices, not a guarantee that the answer is correct.
+
+For a more specific question:
+
+```python
+result = classifier.classify(
+    "Please close my account.",
+    question="What does the customer want?",
+    choices=[
+        {"choice": "cancellation", "criteria": "Requests to close an account."},
+        {"choice": "billing", "criteria": "Questions about charges or payments."},
+        {"choice": "none", "criteria": "Neither of the other categories fits."},
+    ],
+)
+```
+
+## Choose a model
+
+The defaults are `version="latest"` and `domain="general"`.
+`version` selects a model release; `domain` selects its area of use.
+Currently `latest`, `1.1` and `1.1.0` refer to model release 1.1.0.
+The package version (0.2.0) and model version (1.1.0) are separate.
+
+| Domain | Use it for |
+| --- | --- |
+| general | General text classification; start here if unsure |
+| intent | What a customer wants to do |
+| sentiment | Positive, neutral or negative language |
+| triage | Support ticket categories |
+| cause | The issue or reason reported in a complaint |
+| codify | Product and service categories |
+| complaints | Financial complaint products and issues |
+| stars | One-to-five review ratings |
+
+```python
+result = classifier.classify(
+    "Great service!",
+    choices=["positive", "neutral", "negative"],
+    domain="sentiment",
+    version="1.1",
+)
+```
+
+Versions and domains are discovered from [Hugging Face](https://huggingface.co/TrueState/theclassifier):
+
+```python
+from theclassifier import available_versions, available_domains
+
+print(available_versions())
+print(available_domains(version="latest"))
+```
+
+Local `latest` follows the release catalog on Hugging Face. New models can be
+added without updating the Python package. Each version points to a fixed model
+revision, and downloaded weights are reused from the local cache. An existing
+classifier stays on its resolved version; create a new one to pick up a newer release.
+
+The catalog is cached after a successful lookup. Use `offline=True` with either
+function to read only the cache. Network failures also fall back to the cached
+catalog. Saved model folders load without looking up the catalog.
+
+The hosted API resolves its own `latest`; `/v1/versions` lists models currently
+available on that service, which may differ from those published on Hugging Face.
+
+## Run on your computer
+
+Use the same call with `mode="local"`:
+
+```python
+result = classifier.classify(
+    "Great service!",
+    choices=["positive", "neutral", "negative"],
+    mode="local",
+)
+```
+
+The first local call downloads the model. Later calls reuse the local copy.
+Text stays on your computer. The constructor still requires an API key, but local
+calls do not transmit or validate it. Use `device="cpu"` or `device="cuda"` at
+construction to choose a device; the default automatically uses an available
+NVIDIA GPU, otherwise the CPU. Apple GPU acceleration is not currently supported.
+
+## Train from your own examples
+
+Your DataFrame needs two columns: `text` and its correct `label`.
+
+```python
+import pandas as pd
+
+df = pd.DataFrame({
+    "text": ["Please close my account.", "I was charged twice."],
+    "label": ["cancellation", "billing"],
+})
+
+fine_tuned = classifier.fine_tune(data=df)
+result = fine_tuned.classify("Please cancel my account.")
+print(result["results"][0]["selected"]["choice"])
+```
+
+The new classifier remembers the labels, runs locally, and leaves the original
+unchanged. It stays in memory until you save it. Training text is not sent to
+the API. The small example shows the format; use representative examples and
+check predictions on separate examples that were not used for training.
+
+A NumPy array also works: `classifier.fine_tune(data=df.to_numpy())`. It must
+have two columns in this order: text, label. Both must contain non-empty strings.
+Normally there must be at least two different labels. Optional `choices=` lets
+you provide the full set explicitly, including a fallback such as `none`.
+
+## Save and load
+
+```python
+fine_tuned.save("~/Downloads/my_classifier")
+
+loaded = Classifier(
+    api_key=os.environ["CLASSIFIER_API_KEY"],
+    model_path="~/Downloads/my_classifier",
+)
+result = loaded.classify("Please cancel my account.")
+```
+
+Saving writes a complete model and its labels. It leaves the in-memory model
+unchanged. The destination must be empty; existing models are never overwritten.
+Loading restores the labels and uses your computer automatically. Keep the entire
+saved folder together. After the required Python libraries are installed, a saved
+model can run without downloading the original model again.
+
+## Optional settings
+
+Most users can keep the defaults. Pass these as named arguments when needed:
+
+| Setting | Where | Meaning |
+| --- | --- | --- |
+| `mode="api"` or `"local"` | `classify` | Use the service or your computer |
+| `version`, `domain` | Constructor or `classify` | Select a model |
+| `epochs=1` | `fine_tune` | Passes through your training examples |
+| `max_steps=1, grad_accum=1` | `fine_tune` | A quick one-step training check |
+| `question="Which label fits?"` | `classify` or `fine_tune` | Describe the decision |
+| `timeout=60` | Constructor | API timeout in seconds |
+| `offline=True` | Constructor | Require local files and disable API calls |
+
+API failures raise Requests exceptions. A 401 usually means the key is invalid;
+a 429 means the request limit was reached. Respect `Retry-After` before retrying.
+The client does not automatically retry or switch between the API and local mode.
+Custom models run locally; they are not uploaded to the service by training or saving.
+
+## Serve your saved model
+
+Install the `serve` extra, then run:
+
+```sh
+theclassifier serve --model-path ~/Downloads/my_classifier
+```
+
+The local server listens at `http://127.0.0.1:8090`. It runs your model without
+API keys, accounts, billing, or rate limits. Send requests directly:
+
+```python
+import requests
+
+response = requests.post(
+    "http://127.0.0.1:8090/v1/classify",
+    json={
+        "state": "Please close my account.",
+        "questions": [{
+            "question": "What does the customer want?",
+            "choices": ["cancel account", "billing help", "technical support"],
+        }],
+    },
+    timeout=60,
+)
+response.raise_for_status()
+print(response.json())
+```
+
+Code and published model weights use Apache-2.0. See the technical paper for
+research details and evaluation. Maintainers can find release checks in RELEASE.md.

theclassifier-0.2.0/RELEASE.md

@@ -0,0 +1,143 @@
+# Release checklist
+
+## Package
+
+The initial package is `theclassifier==0.1.0`, under Apache-2.0. Build and inspect
+the package from the repository root:
+
+```sh
+python -m pytest
+python -m build
+python -m twine check dist/*
+```
+
+Inspect the wheel and sdist file lists. They should contain package source,
+documentation, licence and tests, with no credentials, training data or model
+weights. Confirm ownership of the PyPI name at upload time: an earlier 404 is not
+a reservation. Authenticate locally with a PyPI API token or configure a trusted
+publisher; do not put credentials in source files or chat.
+
+```sh
+python -m twine upload dist/*
+```
+
+Version 0.1.0 is published on PyPI; both uploaded distributions match the tested
+local build. TrueState/theclassifier is now public, with Apache-2.0 licensing
+for the adapters and scoring heads. Public release was verified without authentication.
+
+## Checkpoints
+
+The default repository is `TrueState/theclassifier` with one directory per version:
+
+```
+general/adapter/adapter_config.json
+general/adapter/adapter_model.safetensors
+general/tokenizer/...
+general/head.safetensors
+intent/adapter/...
+intent/tokenizer/...
+intent/head.safetensors
+# likewise sentiment, triage, cause, codify, complaints, stars
+```
+
+Existing `head.pt` checkpoints work; prefer safetensors for new public releases.
+Only upload the intended release adapters, heads and tokenizers. Do not upload
+logs, datasets, local cache folders or credentials. Verify that every adapter's
+`base_model_name_or_path` points to `Qwen/Qwen3-1.7B-Base` (or the actual public
+backbone used), not a private workstation path. Include model cards describing
+training, evaluation and limitations. The package, released adapters and scoring heads use Apache-2.0.
+Upstream backbone and dataset terms remain separate.
+
+After authentication via `hf auth login`, create the model repository and upload
+an explicitly staged release folder using `hf upload`. Add the model card, then
+verify all versions from a fresh cache and rerun the CUDA tests. Pin a tested Hub
+commit with `revision=` for reproducible deployments. Model releases now select immutable Hub commits. Local `latest` resolves to the
+latest entry in the Hugging Face release catalog; API `latest` is resolved by
+the server. An explicit `revision=` overrides the local Hub revision.
+
+## Validation status
+
+The automated tests use a tiny local random Qwen3 model to exercise real CPU
+inference, LoRA training, checkpoint reload and HTTP serving. They are functional
+tests, not evidence of production classification quality or latency. All six tests passed on the CUDA workstation. The actual general model also
+passed CPU parity against the original scorer, all seven specialists loaded
+and ran on CUDA, and one real-checkpoint LoRA update saved and reloaded on CUDA.
+All eight versions were downloaded from the private Hugging Face repository into
+a fresh cache, matched against the staged files using SHA-256, and resolved
+successfully offline. Verified Hub revision:
+`b5c3072a4b83d14d7dbaf6a358a2ece01b173596`.
+These are functional smoke tests, not a new quality or throughput benchmark.
+
+## Public release and local CPU validation (7 October 2026)
+
+Hugging Face revision `bb8068d36263f09f3be0a47a62637ee40a463af4` is public.
+Tokenizer metadata was made compatible with Transformers 4 and 5 without changing
+vocabulary, special tokens or tested token sequences. PyPI 0.1.0 was installed
+separately for validation; the general adapter and backbone downloaded without
+authentication into a fresh cache.
+
+On an Apple M2 with 24 GB RAM, four CPU threads and float32: a short three-choice
+request took 1.64 seconds initially and 0.66/0.64 seconds warm. Inference peak
+process RSS was 9.17 GiB, including model loading. A one-example, one-step LoRA
+fine-tune from general took 4.69 seconds including loading and saving, with
+10.05 GiB peak RSS. It updated 3,213,313 trainable parameters; both adapter and
+head changes were checked. The saved checkpoint reloaded and inferred offline.
+The single training example used max_length=512 and grad_accum=1.
+These are smoke-test measurements, not representative throughput benchmarks.
+The original model chose 'none' rather than 'cancellation' for the test input;
+functional validation does not establish classification quality.
+
+## API-first client (0.2.0, not yet published)
+
+`Classifier(api_key=...)` now uses Requests for API inference by default.
+`classify(..., mode="local")` selects the lazy local runtime. The API key is
+required when constructing the public client; it is never transmitted for local
+calls. Training and the local CLI/server continue to use the local engine.
+Core installation requires only Requests; local, train and serve extras install
+the ML runtime. This is a breaking change from the 0.1.0 local-only constructor.
+Build and upload only the 0.2.0 filenames; existing published files are immutable.
+
+Validation: 11 automated tests passed locally; CUDA-only test skipped on this Mac.
+A clean wheel install without PyTorch supports API use and reports the required
+local extra when local mode is requested. Real general-model CPU inference via
+the public client matches a Requests call to the authenticated local HTTP server;
+incorrect keys return 401. The hosted production service was not exercised.
+
+The 0.2.0 model selector is now `version="latest", domain="general"`.
+`latest`, `1.1` and `1.1.0` select model release 1.1.0, pinned locally to Hub commit
+`bb8068d36263f09f3be0a47a62637ee40a463af4`. The domain selects the adapter.
+Local latest follows the Hugging Face release catalog; the API resolves
+latest server-side. Responses report both the resolved version and domain.
+The hosted boundary accepts the new pair while translating old version-as-domain
+requests for backward compatibility. These server changes require deployment.
+
+Release/domain validation: 13 package tests passed (one CUDA test skipped on this
+Mac), 17 REST tests passed and two MCP tests passed. The service modules were
+run in separate processes because collecting them together loads conflicting
+admin/database test settings. Real general-model API/local inference parity also
+passed with the new selectors. Website source examples were updated; the local
+Next server on port 3010 was unavailable for a rendered-page check.
+
+Fine-tuning now uses `fine_tuned = original.fine_tune(data=df)` and keeps the
+adapter/head in memory. It shares frozen backbone parameters on the same device
+while copying trainable parameters. `fine_tuned.save(output_directory)` merges
+a separate snapshot and saves standalone weights plus tokenizer/head/labels.
+The live adapter and original classifier stay unchanged. A saved model reloads
+with `Classifier(api_key=..., model_path=...)`. Both in-memory and reloaded custom
+classifiers default to local inference. CLI training still accepts an output
+directory and explicitly saves its result. Package 0.2.0 remains unpublished.
+
+Public loading terminology: `model_path` loads a saved model; `adapter_path`
+loads a separate adapter. The CLI uses `--model-path` and retains `--checkpoint`
+as a compatibility alias. Internal checkpoint helpers remain implementation details.
+
+## Publishing model versions
+
+`classifier-releases.json` on `TrueState/theclassifier` is the source of truth
+for local model versions and domains. Schema version 1 has `latest` and a
+`releases` object keyed by full semantic versions. Each entry contains an immutable
+40-character Hub commit SHA in `revision` and a `domains` list containing `general`.
+Upload the weights first, verify each listed domain at that commit, then update
+the catalog. Preserve the revision of existing versions; publish a new version
+for changed weights. Package helpers fetch the catalog with requests and cache it
+for offline use. Hosted API availability is managed independently.

theclassifier-0.2.0/pyproject.toml

@@ -0,0 +1,35 @@
+[build-system]
+requires = ["setuptools>=77", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "theclassifier"
+version = "0.2.0"
+description = "Classify text through an API or locally, and train models from your own examples"
+readme = "README.md"
+requires-python = ">=3.10"
+license = "Apache-2.0"
+license-files = ["LICENSE"]
+authors = [{name = "TrueState"}]
+dependencies = ["requests>=2.32,<3"]
+
+[project.optional-dependencies]
+local = ["torch>=2.6,<3", "transformers>=4.56,<6", "peft>=0.17,<1", "accelerate>=1,<2", "huggingface-hub>=0.34,<2", "safetensors>=0.5"]
+train = ["theclassifier[local]", "pandas>=2,<4", "numpy>=1.26,<3"]
+serve = ["theclassifier[local]", "fastapi>=0.115,<1", "uvicorn>=0.30,<1"]
+dev = ["theclassifier[serve]", "theclassifier[train]", "pytest>=8", "httpx", "build", "twine"]
+
+[project.scripts]
+theclassifier = "theclassifier.cli:main"
+
+[project.urls]
+Homepage = "https://theclassifier.ai"
+Documentation = "https://theclassifier.ai/docs"
+Repository = "https://github.com/truestate-ai/theclassifier"
+Issues = "https://github.com/truestate-ai/theclassifier/issues"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]

theclassifier-0.2.0/src/theclassifier/__init__.py

@@ -0,0 +1,11 @@
+"""The Classifier: API and local inference with LoRA fine-tuning."""
+__version__ = "0.2.0"
+
+
+def __getattr__(name):
+    if name == "Classifier":
+        from .client import Classifier
+        return Classifier
+    raise AttributeError(name)
+
+from .releases import available_versions, available_domains