humanus 0.35.0__tar.gz

humanus-0.35.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Anthus AI Solutions
+
+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.

humanus-0.35.0/PKG-INFO

@@ -0,0 +1,231 @@
+Metadata-Version: 2.4
+Name: humanus
+Version: 0.35.0
+Summary: Configurable editorial compliance checks: policy packs, deterministic rules, zero-shot decision models and rewrite suggestions.
+Author: Anthus AI Solutions
+License: MIT
+Project-URL: Homepage, https://github.com/AnthusAI/Humanus
+Project-URL: Repository, https://github.com/AnthusAI/Humanus
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: PyYAML<7.0.0,>=6.0.2
+Requires-Dist: jsonschema<5,>=4.18
+Requires-Dist: markdown-it-py<5,>=3.0
+Provides-Extra: jev
+Requires-Dist: typesafe-sdk<0.8,>=0.7.2; extra == "jev"
+Provides-Extra: dev
+Requires-Dist: behave>=1.2.6; extra == "dev"
+Requires-Dist: pytest>=8.0.0; extra == "dev"
+Dynamic: license-file
+
+# Humanus
+
+Humanus is a configurable editorial compliance engine. A publication sends its
+own editorial policies with each request; Humanus marks every place a draft
+breaks them, says how sure it is, and offers rewrites when an editor asks.
+
+## Press Release
+
+**Anthus AI Solutions introduces Humanus, an open-source engine that checks writing against a publication's own editorial policies — and only rewrites when an editor asks**
+
+Every publication has rules: words it avoids, claims it will not make without a
+source, a voice it keeps. Most are enforced by an editor's memory. Humanus makes
+them executable. A CMS sends a draft and a *policy pack* — the publication's
+policies, each written in plain words and backed by detectors — and Humanus
+returns the draft annotated with every finding, down to the exact words.
+
+Two kinds of detector do the finding. Rules catch what a pattern can: banned
+phrases, house style, the tells of AI-generated prose. A decision model, TypeSafe
+Jev, judges what a pattern cannot — "does this sentence make a claim without
+saying who or how much?" — sentence by sentence, with a probability attached.
+Rewrites come from a generative model only when an editor asks for them, for a
+flagged passage or any passage they select, and they never add facts.
+
+"We wanted editorial policy to be something you can read, test and change, not
+something one editor carries in their head," said the Humanus team at Anthus AI
+Solutions. Humanus runs inside Papyrus, Anthus's newsroom system, and is
+available as an MIT-licensed Python package.
+
+## FAQ
+
+**Is Humanus an AI-content detector?** No. It checks text against policies you
+define, whoever wrote it. The starter pack of AI-writing tells is a set of
+editable policies like any other.
+
+**Can it enforce a published standard?** Yes. Starter packs implement ASD-STE100
+Simplified Technical English (`asd-ste100`) and the Federal Plain Language
+Guidelines (`plain-language`); copy one and adjust its limits and word lists.
+
+**Does it rewrite my content?** Only when asked, and never by itself: `suggest`
+returns options for a finding or a selection, and a person chooses.
+
+**Where do policies live?** In the caller. Humanus is stateless; the CMS stores
+policies, settings and editors' decisions and sends a pack with every request.
+
+## Installation
+
+```bash
+pip install humanus          # rules lane, contracts, suggest
+pip install "humanus[jev]"   # adds the TypeSafe Jev classifier lane
+```
+
+Set `TYPESAFE_API_KEY` for the classifier lane and `OPENAI_API_KEY` for
+rewrite suggestions and drafted questions (`gpt-6-luna` by default).
+
+## Usage
+
+```bash
+humanus pack builtin ai-writing-tells > pack.json      # a starter pack to edit
+humanus pack import --profile style-profile.yml > pack.json   # or convert a legacy style profile
+humanus check --draft draft.md --pack pack.json --language en   # findings, segments, lanes (check-result-v1)
+humanus suggest --request suggest-request.json         # rewrite options for a finding or selection
+humanus draft-questions --request draft-request.json   # classifier detectors for a prose policy
+humanus calibrate --labels labels.json                 # calibration from editors' decisions
+humanus schema policy-pack-v1                          # print any contract schema
+```
+
+```python
+from humanus import check, suggest
+
+result = check({"schemaVersion": 1, "content": {"format": "markus", "language": "en", "text": text}, "pack": pack})
+for finding in result["findings"]:
+    print(finding["severity"], finding["policyId"], finding["excerpt"], finding.get("probability"))
+```
+
+## Contracts
+
+The payloads are JSON Schemas packaged with Humanus (`humanus schema <name>`);
+callers in any language validate against the same files.
+
+| Schema | Purpose |
+| --- | --- |
+| `policy-pack-v1` | Policies: prose guidance, severity (`info`/`warn`/`error`), examples, rewrite guidance and detectors — `rules` (`regex`, `phrase`, `builtin`) or `classifier` (a zero-shot question at sentence, paragraph or document scope, with threshold, review band and optional calibration) |
+| `check-request-v1` / `check-result-v1` | Content (`markus`, `markdown` or `text`, with its `language`) plus a pack in; the language pack used, segments, protected regions, findings, coverage and lane status out |
+| `finding-v1` | One located problem, with an id that is stable across rescans |
+| `suggest-request-v1` / `suggest-result-v1` | Rewrite options for a finding (rewritten as its sentence) or an editor's selection |
+| `draft-questions-request-v1` / `draft-questions-result-v1` | Classifier detectors drafted from a prose policy |
+| `feedback-labels-v1` / `calibration-v1` | Editors' decisions in, per-detector calibration out |
+
+**Offsets** count UTF-16 code units, as JavaScript string indexes do.
+**Segments** are the document, its prose paragraphs (paragraphs, headings, list
+items) and their sentences; each carries its plain text so a rendered preview
+can place findings. Front matter, code, Markus directives, block quotes and raw
+HTML are protected regions and never checked. Table cells are prose: each cell
+that has words in it is a paragraph segment with block `tableCell`, split into
+sentences like any other paragraph, so both lanes read it and findings point at
+the cell text; pipes and the alignment row stay out of detection, and cells that
+hold only numbers or code are skipped. Set `options.tables` to `false` to make
+tables a protected region again. Whole-document measures (average sentence
+length, reading grade, information density, paragraph length, uniform cadence,
+overused words) leave table cells out. Paragraph, sentence and
+finding ids derive from text, so they survive edits elsewhere.
+
+## Languages
+
+Every check request states the language of its content (`content.language`, a
+BCP 47 tag) and every policy pack states the language its policies are written
+for (`language`, or `"*"` for language-neutral policies). Humanus reads the text
+with that language's **language pack** (`src/humanus/languages/*.yml`): where
+sentences end (Chinese `。！？` with no space or capital after them; Spanish
+`¿…?` and `¡…!`), what a unit of length is (words, or characters in Chinese),
+how a phrase matches (on word boundaries, or anywhere in a script written
+without spaces), which quotation marks enclose someone else's words, which
+built-in checks the language can run, its word classes, its native baseline
+rates and its typography data. Shipped: `en`, `es`, `es-419` (an overlay on
+`es`: only what differs, such as quotation marks and number forms) and
+`zh-Hans` (also served for `zh-CN`, `zh-SG`, `zh-MY`).
+
+- A language with no pack is **refused** with an error that names it; text is
+  never checked as if it were English. Tags match exactly (or a documented
+  alias): `es-AR` is refused, not read as `es`.
+- A pack written for another language is refused: English policies never run
+  on Chinese text. A pack for a base language (`es`) applies to its variants
+  (`es-419`); a pack for one variant never applies to another.
+- A rules detector the language cannot run (an English built-in on Chinese, a
+  word class needing a tagger the pack lacks) is listed in
+  `lanes.rules.notRun` with the reason.
+
+Generic built-ins take everything from the language pack: `frame` (ordered
+parts with a bounded gap in one sentence, such as `不是 … 而是`), `density` (a
+word class per paragraph against the pack's native rate, reported when the
+count would be improbable at that rate) and `typography` (a named mechanical
+rule: `punctuation-width`, `quotation-marks`, `ellipsis`,
+`space-beside-full-width`, `latin-spacing`, `number-words`, `number-format`).
+Length checks count in the language's unit.
+
+## Lanes
+
+- **Rules** (deterministic): phrase and regex detectors run on prose only;
+  built-in checks cover empty lead-ins, unsupported certainty, missing
+  attribution, passive voice, redundancy, uniform cadence, information density,
+  overused words, uncontracted forms, contrast caps and emoji. Checks for writing
+  standards cover sentence length (by procedure or description), average
+  sentence length, paragraph length, Flesch-Kincaid grade, double negatives,
+  undefined acronyms, one instruction per step, imperative steps, -ing forms,
+  missing articles and one meaning per word. Phrase detectors take `exceptions`,
+  such as technical names, inside which a match is not a finding.
+  Direct quotations are someone else's words: a rules finding that lies
+  entirely inside a double-quoted passage (straight or curly) or a block quote
+  is not reported. A detector or its policy sets `quotations: "check"` to opt
+  back in (the detector wins); the starter pack does so for placeholder leaks,
+  chatbot artifacts, chat citation markup and AI-tool tracking parameters.
+  `passive_voice` also ignores a passive clause inside a quotation when the
+  rest of the sentence is not passive. The classifier lane still reads quotations.
+- **Starter packs** (`humanus pack builtin <name>`):
+  - `ai-writing-tells`: 24 policies adapted from
+    [avoid-ai-writing](https://github.com/conorbronsdon/avoid-ai-writing) (MIT).
+  - `asd-ste100`: ASD-STE100 Simplified Technical English. The official
+    dictionary is licensed by ASD, so the pack ships a small seed of
+    unapproved words, nouns and one-meaning words; extend them with yours.
+  - `plain-language`: the Federal Plain Language Guidelines (public domain),
+    with simple-word and excess-word replacements, "must" for "shall", hidden
+    verbs, length and readability limits, and Jev questions for addressing the
+    reader as "you", putting the main point first and avoiding jargon.
+  - `typography-zh-hans`, `typography-es`: mechanical punctuation, quotation
+    mark and number-form rules, each finding with its deterministic replacement.
+  - `ai-writing-tells-zh-hans`, `translationese-zh-hans`, `ai-writing-tells-es`:
+    small advisory starter sets (all `info`), each policy marked with its
+    `evidence` grade (`measured`, `normative` or `folk`).
+  - `word-choice-es-419`: Latin American word choice (computadora, falla).
+
+  See `humanus/packs/NOTICE.md` for sources and licenses.
+- **Classifier** (TypeSafe Jev, zero-shot): one request per segment carries
+  every question that applies to it; sentences are judged with their paragraph
+  as context. Answers are cached by content, so a rescan only asks about changed
+  text. `options.classifier` sets the model, concurrency, an input-token budget,
+  a deadline (to stay inside an API timeout) and few-shot examples from past
+  decisions. Without a decision model the lane reports `unavailable` and rules
+  findings are still returned.
+
+Editors' decisions improve the classifier: `calibrate` fits Platt scaling (from
+10 labels) or isotonic regression (from 50) per detector; store it on the
+detector as `calibration` and thresholds apply to the calibrated probability.
+
+## HTML usability
+
+A separate, read-only scan for rendered HTML pages (contrast, tap targets, focus
+visibility, alt text, generic AI-page patterns):
+
+```bash
+humanus usability scan --page page.html --profile usability-profile.yml
+```
+
+## For agents
+
+`humanus skill` prints an Agent Skill describing the check → suggest → choose
+workflow.
+
+## Testing
+
+Specifications are Gherkin, run with [Behave](https://behave.readthedocs.io/);
+unit tests use pytest. Neither needs network access or API keys.
+
+```bash
+behave
+python -m pytest tests -q
+```
+
+## License
+
+MIT — see [LICENSE](LICENSE).

humanus-0.35.0/README.md

@@ -0,0 +1,210 @@
+# Humanus
+
+Humanus is a configurable editorial compliance engine. A publication sends its
+own editorial policies with each request; Humanus marks every place a draft
+breaks them, says how sure it is, and offers rewrites when an editor asks.
+
+## Press Release
+
+**Anthus AI Solutions introduces Humanus, an open-source engine that checks writing against a publication's own editorial policies — and only rewrites when an editor asks**
+
+Every publication has rules: words it avoids, claims it will not make without a
+source, a voice it keeps. Most are enforced by an editor's memory. Humanus makes
+them executable. A CMS sends a draft and a *policy pack* — the publication's
+policies, each written in plain words and backed by detectors — and Humanus
+returns the draft annotated with every finding, down to the exact words.
+
+Two kinds of detector do the finding. Rules catch what a pattern can: banned
+phrases, house style, the tells of AI-generated prose. A decision model, TypeSafe
+Jev, judges what a pattern cannot — "does this sentence make a claim without
+saying who or how much?" — sentence by sentence, with a probability attached.
+Rewrites come from a generative model only when an editor asks for them, for a
+flagged passage or any passage they select, and they never add facts.
+
+"We wanted editorial policy to be something you can read, test and change, not
+something one editor carries in their head," said the Humanus team at Anthus AI
+Solutions. Humanus runs inside Papyrus, Anthus's newsroom system, and is
+available as an MIT-licensed Python package.
+
+## FAQ
+
+**Is Humanus an AI-content detector?** No. It checks text against policies you
+define, whoever wrote it. The starter pack of AI-writing tells is a set of
+editable policies like any other.
+
+**Can it enforce a published standard?** Yes. Starter packs implement ASD-STE100
+Simplified Technical English (`asd-ste100`) and the Federal Plain Language
+Guidelines (`plain-language`); copy one and adjust its limits and word lists.
+
+**Does it rewrite my content?** Only when asked, and never by itself: `suggest`
+returns options for a finding or a selection, and a person chooses.
+
+**Where do policies live?** In the caller. Humanus is stateless; the CMS stores
+policies, settings and editors' decisions and sends a pack with every request.
+
+## Installation
+
+```bash
+pip install humanus          # rules lane, contracts, suggest
+pip install "humanus[jev]"   # adds the TypeSafe Jev classifier lane
+```
+
+Set `TYPESAFE_API_KEY` for the classifier lane and `OPENAI_API_KEY` for
+rewrite suggestions and drafted questions (`gpt-6-luna` by default).
+
+## Usage
+
+```bash
+humanus pack builtin ai-writing-tells > pack.json      # a starter pack to edit
+humanus pack import --profile style-profile.yml > pack.json   # or convert a legacy style profile
+humanus check --draft draft.md --pack pack.json --language en   # findings, segments, lanes (check-result-v1)
+humanus suggest --request suggest-request.json         # rewrite options for a finding or selection
+humanus draft-questions --request draft-request.json   # classifier detectors for a prose policy
+humanus calibrate --labels labels.json                 # calibration from editors' decisions
+humanus schema policy-pack-v1                          # print any contract schema
+```
+
+```python
+from humanus import check, suggest
+
+result = check({"schemaVersion": 1, "content": {"format": "markus", "language": "en", "text": text}, "pack": pack})
+for finding in result["findings"]:
+    print(finding["severity"], finding["policyId"], finding["excerpt"], finding.get("probability"))
+```
+
+## Contracts
+
+The payloads are JSON Schemas packaged with Humanus (`humanus schema <name>`);
+callers in any language validate against the same files.
+
+| Schema | Purpose |
+| --- | --- |
+| `policy-pack-v1` | Policies: prose guidance, severity (`info`/`warn`/`error`), examples, rewrite guidance and detectors — `rules` (`regex`, `phrase`, `builtin`) or `classifier` (a zero-shot question at sentence, paragraph or document scope, with threshold, review band and optional calibration) |
+| `check-request-v1` / `check-result-v1` | Content (`markus`, `markdown` or `text`, with its `language`) plus a pack in; the language pack used, segments, protected regions, findings, coverage and lane status out |
+| `finding-v1` | One located problem, with an id that is stable across rescans |
+| `suggest-request-v1` / `suggest-result-v1` | Rewrite options for a finding (rewritten as its sentence) or an editor's selection |
+| `draft-questions-request-v1` / `draft-questions-result-v1` | Classifier detectors drafted from a prose policy |
+| `feedback-labels-v1` / `calibration-v1` | Editors' decisions in, per-detector calibration out |
+
+**Offsets** count UTF-16 code units, as JavaScript string indexes do.
+**Segments** are the document, its prose paragraphs (paragraphs, headings, list
+items) and their sentences; each carries its plain text so a rendered preview
+can place findings. Front matter, code, Markus directives, block quotes and raw
+HTML are protected regions and never checked. Table cells are prose: each cell
+that has words in it is a paragraph segment with block `tableCell`, split into
+sentences like any other paragraph, so both lanes read it and findings point at
+the cell text; pipes and the alignment row stay out of detection, and cells that
+hold only numbers or code are skipped. Set `options.tables` to `false` to make
+tables a protected region again. Whole-document measures (average sentence
+length, reading grade, information density, paragraph length, uniform cadence,
+overused words) leave table cells out. Paragraph, sentence and
+finding ids derive from text, so they survive edits elsewhere.
+
+## Languages
+
+Every check request states the language of its content (`content.language`, a
+BCP 47 tag) and every policy pack states the language its policies are written
+for (`language`, or `"*"` for language-neutral policies). Humanus reads the text
+with that language's **language pack** (`src/humanus/languages/*.yml`): where
+sentences end (Chinese `。！？` with no space or capital after them; Spanish
+`¿…?` and `¡…!`), what a unit of length is (words, or characters in Chinese),
+how a phrase matches (on word boundaries, or anywhere in a script written
+without spaces), which quotation marks enclose someone else's words, which
+built-in checks the language can run, its word classes, its native baseline
+rates and its typography data. Shipped: `en`, `es`, `es-419` (an overlay on
+`es`: only what differs, such as quotation marks and number forms) and
+`zh-Hans` (also served for `zh-CN`, `zh-SG`, `zh-MY`).
+
+- A language with no pack is **refused** with an error that names it; text is
+  never checked as if it were English. Tags match exactly (or a documented
+  alias): `es-AR` is refused, not read as `es`.
+- A pack written for another language is refused: English policies never run
+  on Chinese text. A pack for a base language (`es`) applies to its variants
+  (`es-419`); a pack for one variant never applies to another.
+- A rules detector the language cannot run (an English built-in on Chinese, a
+  word class needing a tagger the pack lacks) is listed in
+  `lanes.rules.notRun` with the reason.
+
+Generic built-ins take everything from the language pack: `frame` (ordered
+parts with a bounded gap in one sentence, such as `不是 … 而是`), `density` (a
+word class per paragraph against the pack's native rate, reported when the
+count would be improbable at that rate) and `typography` (a named mechanical
+rule: `punctuation-width`, `quotation-marks`, `ellipsis`,
+`space-beside-full-width`, `latin-spacing`, `number-words`, `number-format`).
+Length checks count in the language's unit.
+
+## Lanes
+
+- **Rules** (deterministic): phrase and regex detectors run on prose only;
+  built-in checks cover empty lead-ins, unsupported certainty, missing
+  attribution, passive voice, redundancy, uniform cadence, information density,
+  overused words, uncontracted forms, contrast caps and emoji. Checks for writing
+  standards cover sentence length (by procedure or description), average
+  sentence length, paragraph length, Flesch-Kincaid grade, double negatives,
+  undefined acronyms, one instruction per step, imperative steps, -ing forms,
+  missing articles and one meaning per word. Phrase detectors take `exceptions`,
+  such as technical names, inside which a match is not a finding.
+  Direct quotations are someone else's words: a rules finding that lies
+  entirely inside a double-quoted passage (straight or curly) or a block quote
+  is not reported. A detector or its policy sets `quotations: "check"` to opt
+  back in (the detector wins); the starter pack does so for placeholder leaks,
+  chatbot artifacts, chat citation markup and AI-tool tracking parameters.
+  `passive_voice` also ignores a passive clause inside a quotation when the
+  rest of the sentence is not passive. The classifier lane still reads quotations.
+- **Starter packs** (`humanus pack builtin <name>`):
+  - `ai-writing-tells`: 24 policies adapted from
+    [avoid-ai-writing](https://github.com/conorbronsdon/avoid-ai-writing) (MIT).
+  - `asd-ste100`: ASD-STE100 Simplified Technical English. The official
+    dictionary is licensed by ASD, so the pack ships a small seed of
+    unapproved words, nouns and one-meaning words; extend them with yours.
+  - `plain-language`: the Federal Plain Language Guidelines (public domain),
+    with simple-word and excess-word replacements, "must" for "shall", hidden
+    verbs, length and readability limits, and Jev questions for addressing the
+    reader as "you", putting the main point first and avoiding jargon.
+  - `typography-zh-hans`, `typography-es`: mechanical punctuation, quotation
+    mark and number-form rules, each finding with its deterministic replacement.
+  - `ai-writing-tells-zh-hans`, `translationese-zh-hans`, `ai-writing-tells-es`:
+    small advisory starter sets (all `info`), each policy marked with its
+    `evidence` grade (`measured`, `normative` or `folk`).
+  - `word-choice-es-419`: Latin American word choice (computadora, falla).
+
+  See `humanus/packs/NOTICE.md` for sources and licenses.
+- **Classifier** (TypeSafe Jev, zero-shot): one request per segment carries
+  every question that applies to it; sentences are judged with their paragraph
+  as context. Answers are cached by content, so a rescan only asks about changed
+  text. `options.classifier` sets the model, concurrency, an input-token budget,
+  a deadline (to stay inside an API timeout) and few-shot examples from past
+  decisions. Without a decision model the lane reports `unavailable` and rules
+  findings are still returned.
+
+Editors' decisions improve the classifier: `calibrate` fits Platt scaling (from
+10 labels) or isotonic regression (from 50) per detector; store it on the
+detector as `calibration` and thresholds apply to the calibrated probability.
+
+## HTML usability
+
+A separate, read-only scan for rendered HTML pages (contrast, tap targets, focus
+visibility, alt text, generic AI-page patterns):
+
+```bash
+humanus usability scan --page page.html --profile usability-profile.yml
+```
+
+## For agents
+
+`humanus skill` prints an Agent Skill describing the check → suggest → choose
+workflow.
+
+## Testing
+
+Specifications are Gherkin, run with [Behave](https://behave.readthedocs.io/);
+unit tests use pytest. Neither needs network access or API keys.
+
+```bash
+behave
+python -m pytest tests -q
+```
+
+## License
+
+MIT — see [LICENSE](LICENSE).

humanus-0.35.0/pyproject.toml

@@ -0,0 +1,57 @@
+[project]
+name = "humanus"
+version = "0.35.0"
+description = "Configurable editorial compliance checks: policy packs, deterministic rules, zero-shot decision models and rewrite suggestions."
+readme = "README.md"
+license = { text = "MIT" }
+requires-python = ">=3.10"
+authors = [
+  { name = "Anthus AI Solutions" }
+]
+dependencies = [
+    "PyYAML>=6.0.2,<7.0.0",
+    "jsonschema>=4.18,<5",
+    "markdown-it-py>=3.0,<5",
+]
+
+[project.optional-dependencies]
+jev = [
+    "typesafe-sdk>=0.7.2,<0.8",
+]
+dev = [
+    "behave>=1.2.6",
+    "pytest>=8.0.0",
+]
+
+[project.urls]
+Homepage = "https://github.com/AnthusAI/Humanus"
+Repository = "https://github.com/AnthusAI/Humanus"
+
+[project.scripts]
+humanus = "humanus.cli:main"
+
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools.package-data]
+humanus = ["data/SKILL.md", "schemas/*.json", "packs/*.yml", "packs/*.md", "languages/*.yml"]
+
+[tool.semantic_release]
+version_toml = ["pyproject.toml:project.version"]
+version_variables = ["src/humanus/__init__.py:__version__"]
+build_command = "python -m pip install build && python -m build"
+commit_parser = "conventional"
+major_on_zero = false
+
+[tool.semantic_release.branches.main]
+match = "main"
+
+[tool.semantic_release.changelog]
+exclude_commit_patterns = []
+
+[tool.semantic_release.remote]
+type = "github"

humanus-0.35.0/setup.cfg

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

humanus-0.35.0/src/humanus/__init__.py

@@ -0,0 +1,51 @@
+"""Humanus: a configurable editorial compliance engine.
+
+A caller sends content and a policy pack; ``check`` returns where the content
+breaks the pack's policies, ``suggest`` offers rewrites for a finding or any
+selection, ``draft_questions`` helps write classifier detectors, and
+``calibrate`` learns from editors' decisions. Every request states its
+content's language, which a shipped language pack must serve. The JSON Schemas under
+``humanus/schemas`` are the contract (``load_schema``).
+"""
+
+__version__ = "0.35.0"
+
+from .calibration import apply_calibration, calibrate
+from .check import CheckRequestValidationError, check
+from .contracts import ContractValidationError, load_schema, validate_payload
+from .finding_ids import finding_id
+from .languages import Language, UnsupportedLanguageError, list_languages, resolve_language
+from .packs import builtin_pack, list_builtin_packs
+from .policy_pack import PolicyPack, PolicyPackValidationError, load_policy_pack
+from .segmentation import SegmentedDocument, segment_document
+from .style_profile_import import StyleProfileImportError, policy_pack_from_style_profile
+from .suggest import SuggestRequestValidationError, SuggestUnavailableError, draft_questions, suggest
+
+__all__ = [
+    "CheckRequestValidationError",
+    "ContractValidationError",
+    "Language",
+    "PolicyPack",
+    "PolicyPackValidationError",
+    "SegmentedDocument",
+    "StyleProfileImportError",
+    "SuggestRequestValidationError",
+    "SuggestUnavailableError",
+    "UnsupportedLanguageError",
+    "__version__",
+    "apply_calibration",
+    "builtin_pack",
+    "calibrate",
+    "check",
+    "draft_questions",
+    "finding_id",
+    "list_builtin_packs",
+    "list_languages",
+    "load_policy_pack",
+    "load_schema",
+    "policy_pack_from_style_profile",
+    "resolve_language",
+    "segment_document",
+    "suggest",
+    "validate_payload",
+]

humanus-0.35.0/src/humanus/__main__.py

@@ -0,0 +1,8 @@
+"""Run ``python -m humanus`` the same way as the ``humanus`` console script."""
+
+from __future__ import annotations
+
+from .cli import main
+
+if __name__ == "__main__":
+    raise SystemExit(main())

humanus-0.35.0/src/humanus/_util.py

@@ -0,0 +1,18 @@
+from __future__ import annotations
+
+import hashlib
+import json
+from typing import Any
+
+
+def hash_stable(value: Any) -> str:
+    if isinstance(value, str):
+        payload = value
+    else:
+        payload = json.dumps(value, sort_keys=True, separators=(",", ":"), default=str)
+    return hashlib.sha256(payload.encode("utf-8")).hexdigest()
+
+
+def hash_short(value: Any) -> str:
+    return hash_stable(value)[:16]
+