patent-ate 1.0.0__tar.gz

patent_ate-1.0.0/LICENSE

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

patent_ate-1.0.0/PKG-INFO

@@ -0,0 +1,237 @@
+Metadata-Version: 2.4
+Name: patent-ate
+Version: 1.0.0
+Summary: Extract ranked multiword terms from patent text into an immutable termhood table.
+Author: Qubut
+License: MIT
+Project-URL: Homepage, https://github.com/Qubut/patent-ate
+Project-URL: Issues, https://github.com/Qubut/patent-ate/issues
+Keywords: automatic-term-extraction,term-extraction,patents,nlp,c-value,termhood,spacy,duckdb,ibis,uspto
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering :: Information Analysis
+Classifier: Topic :: Text Processing :: Linguistic
+Requires-Python: <3.14,>=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pydantic>=2.10.0
+Requires-Dist: pyyaml>=6.0.0
+Requires-Dist: typer>=0.15.0
+Requires-Dist: structlog>=25.5.0
+Requires-Dist: polars>=1.31.0
+Requires-Dist: pyarrow>=18.0.0
+Requires-Dist: duckdb>=1.5.5
+Requires-Dist: ibis-framework[duckdb]>=12.0.0
+Requires-Dist: ray[data]>=2.50
+Requires-Dist: spacy>=3.8.0
+Requires-Dist: jate>=3.3.0
+Requires-Dist: ahocorasick_rs==1.0.3
+Requires-Dist: numpy>=2.0.0
+Requires-Dist: pydivsufsort>=0.0.20
+Requires-Dist: returns>=0.25.0
+Requires-Dist: en-core-web-lg
+Requires-Dist: sqlglot!=26.32.0,<30,>=23.4
+Dynamic: license-file
+
+# patent-ate
+
+[![CI](https://github.com/Qubut/patent-ate/actions/workflows/ci.yml/badge.svg)](https://github.com/Qubut/patent-ate/actions/workflows/ci.yml)
+[![Python 3.12](https://img.shields.io/badge/python-3.12-3776AB.svg)](https://www.python.org/downloads/)
+[![License: MIT](https://img.shields.io/badge/license-MIT-green.svg)](LICENSE)
+[![Hugging Face](https://img.shields.io/badge/dataset-Qubut%2Fpatent--ate--hupd-yellow.svg)](https://huggingface.co/datasets/Qubut/patent-ate-hupd)
+
+patent-ate finds the technical phrases that actually appear in patent text
+and scores each one by how much it behaves like a real term, not a generic
+word.
+
+Patents repeat short generic words such as "panel" and "method" inside
+longer phrases. "Vehicle interior panel" contains "interior panel" and
+"panel", so counting mentions ranks boilerplate highest. A lawyer or
+engineer looking for the invention then sees "panel" at the top of the list.
+
+C-value is a published score that down-weights those fragments by rewarding
+longer phrases and subtracting the times a short string showed up only
+inside a longer one (Frantzi, Ananiadou, and Mima, [*Automatic recognition
+of multi-word terms: the C-value/NC-value method*](https://link.springer.com/article/10.1007/s007999900023),
+2000). This tool computes that score on a collection of patents, following
+the formula in [JATE](https://github.com/ziqizhang/jate) 3.3, an open-source
+toolkit for ranking phrases, and writes a table of each phrase, its
+C-value, and how many documents contain it.
+
+C-value still keeps headings that stand on their own in many patents, such
+as "another aspect". The table therefore also stores document frequency:
+the number of patents that contain the phrase.
+
+## Install and run
+
+```text
+uv add patent-ate
+```
+
+Until the first PyPI release, depend on the git repository:
+
+```text
+uv add 'patent-ate @ git+https://github.com/Qubut/patent-ate'
+```
+
+patent-ate reads a directory of JSON files, one patent object per file,
+and looks for text in the `claims`, `abstract`, and `summary` fields.
+Missing fields are skipped. Multi-record Hugging Face files (JSONL or
+Parquet) are not read directly; write one JSON object per file first.
+
+Sample the directory, extract phrases, score them, and write the table in
+one job:
+
+```text
+patent-ate corpus \
+  --output ./termhood \
+  --input-dir ./patents \
+  --limit 1000 \
+  --extract-workers 0 \
+  --extract-block-rows 256
+```
+
+`--extract-workers 0` leaves one CPU free for Ray, the library that
+schedules the extraction workers. Pass a positive count to run more
+workers. `--config` is optional YAML for the spaCy English model (the
+parser that finds noun phrases), DuckDB memory, and phrase matching;
+package defaults apply when it is omitted.
+
+Extract phrases first, then score without re-parsing the JSON:
+
+```text
+patent-ate extract --output ./termhood --input-dir ./patents --limit 1000
+patent-ate score --extract ./termhood/extract --output ./termhood
+```
+
+`inspect` prints how many phrases a saved table contains. The output
+directory can keep more than one scored table from later runs;
+`list-generations` prints those files. The Python package runs the same
+steps: extract a collection, score Parquet files, and open the table the
+output directory currently selects.
+
+## Evidence from the Harvard USPTO Patent Dataset
+
+Suzgun, Melas-Kyriazi, Sarkar, Kominers, and Shieber (2022) released the
+**Harvard USPTO Patent Dataset (HUPD)**: English-language US utility
+applications whose JSON objects already carry `claims`, `abstract`, and
+`summary`
+([dataset](https://huggingface.co/datasets/HUPD/hupd),
+[paper](https://arxiv.org/abs/2207.04043),
+[site](https://patentdataset.org)). Scoring that collection with this
+package produced 88,607,764 phrases across 4,518,254 applications. The
+saved columns are the phrase (`key`), C-value (`c_value`), and document
+frequency (`df`).
+
+Most of that C-value sits in short strings. Two-word keys hold about half
+of the positive mass, three-word keys most of the rest; unigrams barely
+register and phrases of six words or more are a thin tail. Nested scoring
+matters because the fragments that inflate a raw count are exactly those
+two- and three-word shells.
+
+![Bar chart of nested C-value mass by number of whitespace tokens](docs/figures/c-mass-by-length.png)
+
+Hyphenation and plural endings stay as written. The table also stores a
+lowercase lookup spelling so either form can be found, which is why
+"lithium ion battery" and "lithium-ion battery" are separate rows.
+
+On that table, C-value and raw document frequency still agree on legal
+headings. "Least a portion" leads C-value as a high-frequency claim
+fragment that also stands alone; "detailed description" leads `df` as a
+section title. The last column below is a combined rank: a high number is
+a rare technical phrase; zero means the phrase is too common to keep as a
+single rank.
+
+| Phrase | C-value | Documents (`df`) | Combined rank |
+| --- | ---: | ---: | ---: |
+| `least a portion` | 2,345,468 | 333,608 | 0 |
+| `another aspect` | 2,080,434 | 694,564 | 0 |
+| `present disclosure` | 1,568,066 | 390,064 | 0 |
+| `computer program product` | 1,381,133 | 154,388 | 0 |
+| `detailed description` | 1,061,982 | 843,582 | 0 |
+| `lithium ion battery` | 22,744 | 3,018 | 0 |
+| `lithium-ion battery` | 9,028 | 1,756 | 71.5 |
+| `sina molecule` | 86,557 | 317 | 108.7 |
+
+Side by side, the two rankings share those headings: the left list still
+opens with claim fragments such as "least a portion", and the right list
+is section titles such as "detailed description".
+
+![Side-by-side bars of C-value leaders and document-frequency leaders](docs/figures/top-c-vs-top-df.png)
+
+To down-weight phrases that appear in most of the collection, the library
+can multiply log(1 + C-value) by inverse document frequency, a weight that
+shrinks as a phrase appears in more documents (Sparck Jones, 1972; Lucene
+BM25-style). The product is zero when `df * df` exceeds the document count,
+so a phrase that appears in more than about √N documents drops out of a
+single ranked list. Almost every key in the histogram sits at small `df`;
+the long tail past √N ≈ 2,126 is where those headings live, and about
+8.65 million phrases (9.8%) hit the cutoff.
+
+![Log-log histogram of document frequency with a line at the square root of the document count](docs/figures/df-tail.png)
+
+`lithium ion battery` (df 3,018) sits past that line and scores zero;
+the hyphenated sibling `lithium-ion battery` (df 1,756) keeps a combined
+rank of 71.5. The published parquet stores phrase, C-value, and document
+frequency; multiply them in this library when you need one rank.
+
+That product is what ranks rare technical compounds instead of those
+headings: the left ranking still lists "least a portion", while the right
+ranking lists phrases such as "rf network node" and
+"polymer-anticancer agent conjugate".
+
+![Side-by-side bars of C-value leaders and combined-rank leaders](docs/figures/c-vs-product-score.png)
+
+## Get the published table
+
+A 3,393-row preview on
+[Qubut/patent-ate-hupd](https://huggingface.co/datasets/Qubut/patent-ate-hupd)
+mixes C-value leaders, high-`df` headings, combined-rank leaders, phrases
+of different lengths, and a random draw. Load that slice before fetching
+the full parquet.
+
+```python
+from datasets import load_dataset
+
+preview = load_dataset('Qubut/patent-ate-hupd', 'slice', split='preview')
+```
+
+```python
+import polars as pl
+
+pl.scan_parquet(
+    'hf://datasets/Qubut/patent-ate-hupd/slice/preview.parquet'
+).head(20).collect()
+```
+
+```python
+import duckdb
+
+con = duckdb.connect('preview.duckdb')  # download slice/preview.duckdb
+con.sql("SELECT * FROM termhood_slice WHERE stratum = 'top_score' LIMIT 10")
+```
+
+`load_dataset('Qubut/patent-ate-hupd', split='termhood')` opens the full
+table. The derived phrase table follows HUPD's license (CC BY-NC-SA 4.0);
+this software is MIT.
+
+## Development
+
+In a local clone, Python 3.12 tools come from devenv:
+
+```text
+devenv shell -- uv sync --group dev --group test
+devenv shell -- ruff check src tests
+devenv shell -- ruff format --check src tests
+devenv shell -- mypy src
+devenv shell -- pytest
+```
+
+The CPU image `ghcr.io/qubut/patent-ate` has entrypoint `patent-ate`. Tags
+and conventional-commit changelogs follow `v*` releases.
+
+## License
+
+[MIT](./LICENSE)

patent_ate-1.0.0/README.md

@@ -0,0 +1,200 @@
+# patent-ate
+
+[![CI](https://github.com/Qubut/patent-ate/actions/workflows/ci.yml/badge.svg)](https://github.com/Qubut/patent-ate/actions/workflows/ci.yml)
+[![Python 3.12](https://img.shields.io/badge/python-3.12-3776AB.svg)](https://www.python.org/downloads/)
+[![License: MIT](https://img.shields.io/badge/license-MIT-green.svg)](LICENSE)
+[![Hugging Face](https://img.shields.io/badge/dataset-Qubut%2Fpatent--ate--hupd-yellow.svg)](https://huggingface.co/datasets/Qubut/patent-ate-hupd)
+
+patent-ate finds the technical phrases that actually appear in patent text
+and scores each one by how much it behaves like a real term, not a generic
+word.
+
+Patents repeat short generic words such as "panel" and "method" inside
+longer phrases. "Vehicle interior panel" contains "interior panel" and
+"panel", so counting mentions ranks boilerplate highest. A lawyer or
+engineer looking for the invention then sees "panel" at the top of the list.
+
+C-value is a published score that down-weights those fragments by rewarding
+longer phrases and subtracting the times a short string showed up only
+inside a longer one (Frantzi, Ananiadou, and Mima, [*Automatic recognition
+of multi-word terms: the C-value/NC-value method*](https://link.springer.com/article/10.1007/s007999900023),
+2000). This tool computes that score on a collection of patents, following
+the formula in [JATE](https://github.com/ziqizhang/jate) 3.3, an open-source
+toolkit for ranking phrases, and writes a table of each phrase, its
+C-value, and how many documents contain it.
+
+C-value still keeps headings that stand on their own in many patents, such
+as "another aspect". The table therefore also stores document frequency:
+the number of patents that contain the phrase.
+
+## Install and run
+
+```text
+uv add patent-ate
+```
+
+Until the first PyPI release, depend on the git repository:
+
+```text
+uv add 'patent-ate @ git+https://github.com/Qubut/patent-ate'
+```
+
+patent-ate reads a directory of JSON files, one patent object per file,
+and looks for text in the `claims`, `abstract`, and `summary` fields.
+Missing fields are skipped. Multi-record Hugging Face files (JSONL or
+Parquet) are not read directly; write one JSON object per file first.
+
+Sample the directory, extract phrases, score them, and write the table in
+one job:
+
+```text
+patent-ate corpus \
+  --output ./termhood \
+  --input-dir ./patents \
+  --limit 1000 \
+  --extract-workers 0 \
+  --extract-block-rows 256
+```
+
+`--extract-workers 0` leaves one CPU free for Ray, the library that
+schedules the extraction workers. Pass a positive count to run more
+workers. `--config` is optional YAML for the spaCy English model (the
+parser that finds noun phrases), DuckDB memory, and phrase matching;
+package defaults apply when it is omitted.
+
+Extract phrases first, then score without re-parsing the JSON:
+
+```text
+patent-ate extract --output ./termhood --input-dir ./patents --limit 1000
+patent-ate score --extract ./termhood/extract --output ./termhood
+```
+
+`inspect` prints how many phrases a saved table contains. The output
+directory can keep more than one scored table from later runs;
+`list-generations` prints those files. The Python package runs the same
+steps: extract a collection, score Parquet files, and open the table the
+output directory currently selects.
+
+## Evidence from the Harvard USPTO Patent Dataset
+
+Suzgun, Melas-Kyriazi, Sarkar, Kominers, and Shieber (2022) released the
+**Harvard USPTO Patent Dataset (HUPD)**: English-language US utility
+applications whose JSON objects already carry `claims`, `abstract`, and
+`summary`
+([dataset](https://huggingface.co/datasets/HUPD/hupd),
+[paper](https://arxiv.org/abs/2207.04043),
+[site](https://patentdataset.org)). Scoring that collection with this
+package produced 88,607,764 phrases across 4,518,254 applications. The
+saved columns are the phrase (`key`), C-value (`c_value`), and document
+frequency (`df`).
+
+Most of that C-value sits in short strings. Two-word keys hold about half
+of the positive mass, three-word keys most of the rest; unigrams barely
+register and phrases of six words or more are a thin tail. Nested scoring
+matters because the fragments that inflate a raw count are exactly those
+two- and three-word shells.
+
+![Bar chart of nested C-value mass by number of whitespace tokens](docs/figures/c-mass-by-length.png)
+
+Hyphenation and plural endings stay as written. The table also stores a
+lowercase lookup spelling so either form can be found, which is why
+"lithium ion battery" and "lithium-ion battery" are separate rows.
+
+On that table, C-value and raw document frequency still agree on legal
+headings. "Least a portion" leads C-value as a high-frequency claim
+fragment that also stands alone; "detailed description" leads `df` as a
+section title. The last column below is a combined rank: a high number is
+a rare technical phrase; zero means the phrase is too common to keep as a
+single rank.
+
+| Phrase | C-value | Documents (`df`) | Combined rank |
+| --- | ---: | ---: | ---: |
+| `least a portion` | 2,345,468 | 333,608 | 0 |
+| `another aspect` | 2,080,434 | 694,564 | 0 |
+| `present disclosure` | 1,568,066 | 390,064 | 0 |
+| `computer program product` | 1,381,133 | 154,388 | 0 |
+| `detailed description` | 1,061,982 | 843,582 | 0 |
+| `lithium ion battery` | 22,744 | 3,018 | 0 |
+| `lithium-ion battery` | 9,028 | 1,756 | 71.5 |
+| `sina molecule` | 86,557 | 317 | 108.7 |
+
+Side by side, the two rankings share those headings: the left list still
+opens with claim fragments such as "least a portion", and the right list
+is section titles such as "detailed description".
+
+![Side-by-side bars of C-value leaders and document-frequency leaders](docs/figures/top-c-vs-top-df.png)
+
+To down-weight phrases that appear in most of the collection, the library
+can multiply log(1 + C-value) by inverse document frequency, a weight that
+shrinks as a phrase appears in more documents (Sparck Jones, 1972; Lucene
+BM25-style). The product is zero when `df * df` exceeds the document count,
+so a phrase that appears in more than about √N documents drops out of a
+single ranked list. Almost every key in the histogram sits at small `df`;
+the long tail past √N ≈ 2,126 is where those headings live, and about
+8.65 million phrases (9.8%) hit the cutoff.
+
+![Log-log histogram of document frequency with a line at the square root of the document count](docs/figures/df-tail.png)
+
+`lithium ion battery` (df 3,018) sits past that line and scores zero;
+the hyphenated sibling `lithium-ion battery` (df 1,756) keeps a combined
+rank of 71.5. The published parquet stores phrase, C-value, and document
+frequency; multiply them in this library when you need one rank.
+
+That product is what ranks rare technical compounds instead of those
+headings: the left ranking still lists "least a portion", while the right
+ranking lists phrases such as "rf network node" and
+"polymer-anticancer agent conjugate".
+
+![Side-by-side bars of C-value leaders and combined-rank leaders](docs/figures/c-vs-product-score.png)
+
+## Get the published table
+
+A 3,393-row preview on
+[Qubut/patent-ate-hupd](https://huggingface.co/datasets/Qubut/patent-ate-hupd)
+mixes C-value leaders, high-`df` headings, combined-rank leaders, phrases
+of different lengths, and a random draw. Load that slice before fetching
+the full parquet.
+
+```python
+from datasets import load_dataset
+
+preview = load_dataset('Qubut/patent-ate-hupd', 'slice', split='preview')
+```
+
+```python
+import polars as pl
+
+pl.scan_parquet(
+    'hf://datasets/Qubut/patent-ate-hupd/slice/preview.parquet'
+).head(20).collect()
+```
+
+```python
+import duckdb
+
+con = duckdb.connect('preview.duckdb')  # download slice/preview.duckdb
+con.sql("SELECT * FROM termhood_slice WHERE stratum = 'top_score' LIMIT 10")
+```
+
+`load_dataset('Qubut/patent-ate-hupd', split='termhood')` opens the full
+table. The derived phrase table follows HUPD's license (CC BY-NC-SA 4.0);
+this software is MIT.
+
+## Development
+
+In a local clone, Python 3.12 tools come from devenv:
+
+```text
+devenv shell -- uv sync --group dev --group test
+devenv shell -- ruff check src tests
+devenv shell -- ruff format --check src tests
+devenv shell -- mypy src
+devenv shell -- pytest
+```
+
+The CPU image `ghcr.io/qubut/patent-ate` has entrypoint `patent-ate`. Tags
+and conventional-commit changelogs follow `v*` releases.
+
+## License
+
+[MIT](./LICENSE)

patent_ate-1.0.0/pyproject.toml

@@ -0,0 +1,148 @@
+[project]
+name = "patent-ate"
+version = "1.0.0"
+description = "Extract ranked multiword terms from patent text into an immutable termhood table."
+readme = "README.md"
+requires-python = ">=3.12,<3.14"
+authors = [{ name = "Qubut" }]
+license = { text = "MIT" }
+keywords = [
+  "automatic-term-extraction",
+  "term-extraction",
+  "patents",
+  "nlp",
+  "c-value",
+  "termhood",
+  "spacy",
+  "duckdb",
+  "ibis",
+  "uspto",
+]
+classifiers = [
+  "Development Status :: 3 - Alpha",
+  "Intended Audience :: Science/Research",
+  "License :: OSI Approved :: MIT License",
+  "Programming Language :: Python :: 3.12",
+  "Topic :: Scientific/Engineering :: Information Analysis",
+  "Topic :: Text Processing :: Linguistic",
+]
+dependencies = [
+  "pydantic>=2.10.0",
+  "pyyaml>=6.0.0",
+  "typer>=0.15.0",
+  "structlog>=25.5.0",
+  "polars>=1.31.0",
+  "pyarrow>=18.0.0",
+  "duckdb>=1.5.5",
+  "ibis-framework[duckdb]>=12.0.0",
+  "ray[data]>=2.50",
+  "spacy>=3.8.0",
+  "jate>=3.3.0",
+  "ahocorasick_rs==1.0.3",
+  "numpy>=2.0.0",
+  "pydivsufsort>=0.0.20",
+  "returns>=0.25.0",
+  "en-core-web-lg",
+  "sqlglot>=23.4,!=26.32.0,<30",
+]
+
+[dependency-groups]
+dev = [
+  "mypy>=1.13.0",
+  "ruff>=0.11.0",
+]
+test = [
+  "pytest>=8.3.0",
+  "hypothesis>=6.0",
+  "en-core-web-sm",
+]
+
+[build-system]
+requires = ["setuptools>=68.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+include = ["patent_ate*"]
+
+[tool.setuptools.package-data]
+patent_ate = ["ate_stop_surfaces.json"]
+
+[project.urls]
+Homepage = "https://github.com/Qubut/patent-ate"
+Issues = "https://github.com/Qubut/patent-ate/issues"
+
+[project.scripts]
+patent-ate = "patent_ate.__main__:main"
+
+[tool.uv]
+default-groups = ["dev", "test"]
+
+[tool.uv.sources]
+en-core-web-lg = { url = "https://github.com/explosion/spacy-models/releases/download/en_core_web_lg-3.8.0/en_core_web_lg-3.8.0-py3-none-any.whl" }
+en-core-web-sm = { url = "https://github.com/explosion/spacy-models/releases/download/en_core_web_sm-3.8.0/en_core_web_sm-3.8.0-py3-none-any.whl" }
+
+[tool.ruff]
+src = ["src", "tests"]
+preview = true
+fix = true
+target-version = "py312"
+line-length = 100
+
+[tool.ruff.format]
+quote-style = "single"
+docstring-code-format = true
+
+[tool.ruff.lint]
+select = [
+  "A","B","C4","C90","COM","D","DTZ","E","ERA","EXE","F","FBT","FLY","FURB",
+  "G","I","ICN","ISC","LOG","N","PERF","PIE","PL","PT","PTH","Q","RET","RSE",
+  "RUF","S","SIM","SLF","SLOT","T100","TRY","UP","W","YTT",
+]
+ignore = [
+  "A005","COM812","D100","D101","D104","D106","D107","D203","D212","D401","D404","D405",
+  "FBT003","ISC001","ISC003","N812","PLR09","PLR2004","PLR6301","TRY003",
+]
+
+[tool.ruff.lint.flake8-quotes]
+inline-quotes = "single"
+
+[tool.ruff.lint.pydocstyle]
+convention = "google"
+
+[tool.ruff.lint.mccabe]
+max-complexity = 7
+
+[tool.ruff.lint.per-file-ignores]
+"tests/**/*.py" = ["S101","S105","S106","S404","S603","S607","D","PT011","PLC2701","SLF001","RUF012"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+python_files = "test_*.py"
+xfail_strict = true
+addopts = ["--strict-config","--strict-markers","-ra"]
+markers = [
+  "benchmark: machine-local C-value timing gate",
+]
+filterwarnings = [
+  "error",
+  "ignore:.*corpus-level ranking algorithm.*:UserWarning",
+  "ignore::DeprecationWarning:ray.data.context",
+  "ignore:.*use_push_based_shuffle.*:DeprecationWarning",
+  "ignore:.*fetch_arrow_table.*is deprecated.*:DeprecationWarning",
+  "ignore:.*CUDA initialization.*:UserWarning",
+  "ignore:In Polars 2.0, the default behavior for `empty_as_null`:DeprecationWarning",
+]
+
+[tool.mypy]
+files = ["src"]
+python_version = "3.12"
+strict = true
+plugins = ["returns.contrib.mypy.returns_plugin"]
+ignore_missing_imports = true
+local_partial_types = true
+warn_unreachable = true
+enable_error_code = [
+  "truthy-bool","truthy-iterable","redundant-expr","unused-awaitable",
+  "possibly-undefined","redundant-self","unimported-reveal","deprecated",
+]

patent_ate-1.0.0/setup.cfg

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

patent_ate-1.0.0/src/patent_ate/__init__.py

@@ -0,0 +1,24 @@
+"""CPU automatic term extraction for patent claim, abstract, and summary text."""
+
+from __future__ import annotations
+
+from patent_ate.cvalue import score_term_parquet
+from patent_ate.extract import (
+    corpus_termhood,
+    extract_corpus,
+    extract_parquet_parts,
+    write_termhood,
+)
+from patent_ate.spec import AteSpec
+from patent_ate.termhood import TermhoodIndex, TermhoodStore
+
+__all__ = [
+    'AteSpec',
+    'TermhoodIndex',
+    'TermhoodStore',
+    'corpus_termhood',
+    'extract_corpus',
+    'extract_parquet_parts',
+    'score_term_parquet',
+    'write_termhood',
+]