sapling-py 4.1.0__tar.gz → 4.3.0__tar.gz

{sapling_py-4.1.0/sapling_py.egg-info → sapling_py-4.3.0}/PKG-INFO

@@ -1,11 +1,12 @@
 Metadata-Version: 2.4
 Name: sapling-py
-Version: 4.1.0
+Version: 4.3.0
 Summary: Sapling Python Client
-Home-page: https://sapling.ai
-Author: Sapling Intelligence
-Author-email: info@sapling.ai
+Author-email: Sapling Intelligence <info@sapling.ai>
 License: Apache License 2.0
+Project-URL: Homepage, https://sapling.ai
+Project-URL: Documentation, https://sapling.readthedocs.io/
+Project-URL: Repository, https://github.com/saplingai/sapling-py
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Programming Language :: Python :: 3
@@ -17,18 +18,7 @@ Requires-Dist: requests
 Provides-Extra: test
 Requires-Dist: pytest; extra == "test"
 Requires-Dist: responses; extra == "test"
-Dynamic: author
-Dynamic: author-email
-Dynamic: classifier
-Dynamic: description
-Dynamic: description-content-type
-Dynamic: home-page
-Dynamic: license
 Dynamic: license-file
-Dynamic: provides-extra
-Dynamic: requires-dist
-Dynamic: requires-python
-Dynamic: summary
 
 # Sapling Python Client
 
@@ -40,7 +30,9 @@ Compare against leading grammar checking tools and APIs like Grammarly (Grammerl
 ## Overview
 
 Sapling is a toolkit for helping developers build language model-powered applications.
-The API provides spelling and grammar checking, autocomplete, tone detection, rephrasing, AI detection, and more.
+The API provides spelling and grammar checking, autocomplete, tone detection, rephrasing, AI detection,
+zero-shot text classification, structured data extraction, PII detection and redaction, content safety
+scoring, SEO analysis, and more.
 
 Key Features:
 - **60% More Corrections**: Outperforms [competing solutions](https://sapling.ai/comparison/api#sapling) at similar accuracy levels using state-of-the-art generative AI models.
@@ -52,12 +44,19 @@ Key Features:
 
 ## Installation
 
-Install the `sapling-py` package with [pip](https://pip.pypa.io/en/stable/installation/)
+Install the `sapling-py` package from PyPI with
+[pip](https://pip.pypa.io/en/stable/installation/):
 
-```
+```sh
 python -m pip install sapling-py
 ```
 
+Or add it to a [uv](https://docs.astral.sh/uv/) project:
+
+```sh
+uv add sapling-py
+```
+
 ## Documentation
 Documentation for the client is available at [Read the Docs](https://sapling.readthedocs.io/) and
 documentation for the HTTP API is available at [Sapling.ai](https://sapling.ai/docs).

{sapling_py-4.1.0 → sapling_py-4.3.0}/README.md

@@ -8,7 +8,9 @@ Compare against leading grammar checking tools and APIs like Grammarly (Grammerl
 ## Overview
 
 Sapling is a toolkit for helping developers build language model-powered applications.
-The API provides spelling and grammar checking, autocomplete, tone detection, rephrasing, AI detection, and more.
+The API provides spelling and grammar checking, autocomplete, tone detection, rephrasing, AI detection,
+zero-shot text classification, structured data extraction, PII detection and redaction, content safety
+scoring, SEO analysis, and more.
 
 Key Features:
 - **60% More Corrections**: Outperforms [competing solutions](https://sapling.ai/comparison/api#sapling) at similar accuracy levels using state-of-the-art generative AI models.
@@ -20,12 +22,19 @@ Key Features:
 
 ## Installation
 
-Install the `sapling-py` package with [pip](https://pip.pypa.io/en/stable/installation/)
+Install the `sapling-py` package from PyPI with
+[pip](https://pip.pypa.io/en/stable/installation/):
 
-```
+```sh
 python -m pip install sapling-py
 ```
 
+Or add it to a [uv](https://docs.astral.sh/uv/) project:
+
+```sh
+uv add sapling-py
+```
+
 ## Documentation
 Documentation for the client is available at [Read the Docs](https://sapling.readthedocs.io/) and
 documentation for the HTTP API is available at [Sapling.ai](https://sapling.ai/docs).

sapling_py-4.3.0/pyproject.toml

@@ -0,0 +1,42 @@
+[build-system]
+requires = ["setuptools>=61"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "sapling-py"
+dynamic = ["version"]
+description = "Sapling Python Client"
+readme = "README.md"
+requires-python = ">=3.7"
+license = { text = "Apache License 2.0" }
+authors = [
+    { name = "Sapling Intelligence", email = "info@sapling.ai" },
+]
+classifiers = [
+    "Development Status :: 5 - Production/Stable",
+    "License :: OSI Approved :: Apache Software License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3 :: Only",
+]
+dependencies = [
+    "requests",
+]
+
+[project.optional-dependencies]
+test = [
+    "pytest",
+    "responses",
+]
+
+[project.urls]
+Homepage = "https://sapling.ai"
+Documentation = "https://sapling.readthedocs.io/"
+Repository = "https://github.com/saplingai/sapling-py"
+
+[tool.setuptools.dynamic]
+version = { attr = "sapling.version.__version__" }
+
+[tool.setuptools.packages.find]
+include = ["sapling", "sapling.*"]
+exclude = ["test", "test.*"]
+namespaces = false

{sapling_py-4.1.0 → sapling_py-4.3.0}/sapling/client.py

@@ -1,5 +1,6 @@
 import requests
 import uuid
+from collections.abc import Iterable
 
 
 class SaplingError(Exception):
@@ -631,6 +632,92 @@ class SaplingClient:
         }
         return self._request(url, data)
 
+    def extract(
+        self,
+        text,
+        fields,
+        context=None,
+    ):
+        '''
+        Extracts structured data from unstructured text: you name the fields you
+        want, the API returns their values pulled from the document. Every value is
+        grounded in a verbatim span of the input, so this is extraction rather than
+        summarization or inference; a field the text does not state is reported
+        missing rather than guessed.
+
+        Example::
+
+            client.extract(
+                'Invoice INV-1042 for Acme Corp, total $1,299.00, due March 5, 2026.',
+                fields=[
+                    'invoice_number',
+                    {'name': 'total', 'type': 'number', 'description': 'Amount due',
+                     'required': True},
+                    {'name': 'due_date', 'type': 'date'},
+                    'purchase_order',
+                ],
+                context='A vendor invoice',
+            )
+            # {'data': {'invoice_number': 'INV-1042', 'total': 1299.0,
+            #           'due_date': '2026-03-05', 'purchase_order': None},
+            #  'fields': [{'name': 'invoice_number', 'type': 'string',
+            #              'value': 'INV-1042', 'evidence': 'Invoice INV-1042',
+            #              'found': True},
+            #             {'name': 'total', 'type': 'number', 'value': 1299.0,
+            #              'evidence': 'total $1,299.00', 'found': True},
+            #             {'name': 'due_date', 'type': 'date', 'value': '2026-03-05',
+            #              'evidence': 'due March 5, 2026', 'found': True},
+            #             {'name': 'purchase_order', 'type': 'string', 'value': None,
+            #              'evidence': '', 'found': False}],
+            #  'missing': ['purchase_order']}
+
+        :param text: Document to extract from, plain text or HTML (tags are
+            stripped), up to 10,000 characters.
+        :type text: str
+        :param fields: 1-20 fields to extract. Each entry is either a field name
+            (str) or a dict ``{'name': str, 'type': str, 'description': str,
+            'required': bool}`` where everything but ``name`` is optional. Names are
+            up to 50 characters and must be unique (case-insensitive). ``type`` is
+            one of ``'string'`` (the default), ``'number'``, ``'integer'``,
+            ``'boolean'``, ``'date'`` or ``'list'``. ``description`` is up to 200
+            characters and sharpens ambiguous fields. ``required`` is a hint to the
+            model; a required field the text does not state is still reported
+            missing, never guessed.
+        :type fields: list[str | dict]
+        :raises TypeError: If ``fields`` is None, a single string or a dict rather
+            than a list/tuple of fields.
+        :param context: Up to 500 characters describing what the document is or how
+            to read ambiguous fields (e.g. ``'A vendor invoice'``).
+        :type context: str
+        :rtype: dict
+        :return:
+            - data: ``{field name: value}`` map. Every requested field is present,
+              with ``None`` where the text did not state it. ``date`` values are
+              ``YYYY-MM-DD`` strings and ``list`` values are lists of strings.
+            - fields: One dict per requested field, in the order requested, with
+              ``name``, ``type``, ``value``, the verbatim ``evidence`` span the value
+              came from (``''`` when not found) and ``found``.
+            - missing: Names of the fields the text did not yield, in request order.
+              Finding nothing is a normal, successful response.
+        '''
+        # A bare string would silently be split into one-character field names,
+        # a dict would be reduced to its keys, and a non-iterable (None, an int)
+        # would raise an opaque "'int' object is not iterable" from list().
+        # Fail loudly with a message that names the right shape instead.
+        if (not isinstance(fields, Iterable)
+                or isinstance(fields, (str, bytes, dict))):
+            raise TypeError('fields must be a list of field names or '
+                            '{name, type, description, required} dicts')
+        url = self.url_endpoint + 'extract'
+        data = {
+            'key': self.api_key,
+            'text': text,
+            'fields': list(fields),
+        }
+        if context is not None:
+            data['context'] = context
+        return self._request(url, data)
+
     def tone(
         self,
         text,
@@ -682,43 +769,79 @@ class SaplingClient:
     def quality(
         self,
         text,
+        sentence_scores=None,
+        rubric=None,
     ):
         '''
         Computes a quality score for the provided text based on how "surprising"
         the text is to the model. Lower surprisal corresponds to higher scores.
+        Optionally also returns a per-sentence breakdown and an LLM-judged rubric.
 
-        :param text: Text to compute a quality score for.
+        :param text: Text to compute a quality score for. The base score is computed
+            on the leading ~4,000 characters; the rubric evaluates the whole text
+            (up to 20,000 characters).
         :type text: str
+        :param sentence_scores: If true, also return a 1-5 score for each sentence
+            under `sentences`.
+        :type sentence_scores: bool
+        :param rubric: If true, also return an LLM-judged rubric under `rubric`
+            (billed at the Tone rate).
+        :type rubric: bool
         :rtype: dict
         :return:
             - score: A score from 1 (low quality) to 5 (high quality).
+            - sentences: If sentence_scores is set, list of {start, end, text, score} in
+              document order; start/end are character offsets into the text.
+            - rubric: If rubric is set, {overall, dimensions: {clarity, coherence,
+              correctness, concision}, summary, issues: [{quote, dimension, note,
+              suggestion, start, end}]}; scores are integers 1-5.
         '''
         url = self.url_endpoint + 'quality'
         data = {
             'key': self.api_key,
             'text': text,
         }
+        if sentence_scores is not None:
+            data['sentence_scores'] = sentence_scores
+        if rubric is not None:
+            data['rubric'] = rubric
         return self._request(url, data)
 
     def langdetect(
         self,
         text,
+        top_k=None,
+        segments=None,
     ):
         '''
-        Identifies the language of the provided text.
+        Identifies the language of the provided text, with optional runner-up
+        candidates and a per-segment breakdown for mixed-language text.
 
-        :param text: Text to identify the language for.
+        :param text: Text to identify the language for (up to 20,000 characters).
         :type text: str
+        :param top_k: Number of language candidates to return, 1-10. Defaults to 3 server-side.
+        :type top_k: int
+        :param segments: If true, also detect the language of each line/sentence
+            of the text and return them under `segments`.
+        :type segments: bool
         :rtype: dict
         :return:
-            - lang: The detected language code.
+            - lang: The detected language code (mostly ISO 639-1).
+            - name: English name of the detected language.
             - conf: Confidence score for the detection result.
+            - candidates: List of {lang, name, conf} for the top languages, most likely first.
+            - segments: If segments is set, list of {start, end, text, lang, name, conf, candidates}
+              in document order; start/end are character offsets into the text.
         '''
         url = self.url_endpoint + 'langdetect'
         data = {
             'key': self.api_key,
             'text': text,
         }
+        if top_k is not None:
+            data['top_k'] = top_k
+        if segments is not None:
+            data['segments'] = segments
         return self._request(url, data)
 
     def profanity(
@@ -741,3 +864,239 @@ class SaplingClient:
             'text': text,
         }
         return self._request(url, data)
+
+    def safety(
+        self,
+        text,
+        threshold=None,
+        spans=None,
+    ):
+        '''
+        Scores the provided text on seven content-safety categories: toxicity,
+        profanity, harassment, hate_speech, self_harm, sexual, and violence.
+
+        :param text: Text to score, up to 20,000 characters.
+        :type text: str
+        :param threshold: Score at or above which a category is flagged.
+            Between 0 and 1 inclusive; the API defaults to 0.5.
+        :type threshold: float
+        :param spans: When True, the response also includes the offending
+            passages as spans, each with its text, start/end character offsets
+            into the submitted text, per-passage category scores, and
+            flagged_categories. The API defaults to False.
+        :type spans: bool
+        :rtype: dict
+        :return:
+            - scores: A probability from 0 to 1 for each category.
+            - flagged: True if any category scored at or above the threshold.
+            - flagged_categories: Categories that scored at or above the threshold.
+            - threshold: The threshold that was applied.
+            - spans: Only with spans=True — the offending passages, most
+              severe first, as {text, start, end, scores, flagged_categories}.
+        '''
+        url = self.url_endpoint + 'safety'
+        data = {
+            'key': self.api_key,
+            'text': text,
+        }
+        if threshold is not None:
+            data['threshold'] = threshold
+        if spans is not None:
+            data['spans'] = spans
+        return self._request(url, data)
+
+    def pii(
+        self,
+        text,
+        types=None,
+        redact=None,
+    ):
+        '''
+        Detects personally identifiable information (PII) in the provided text and
+        optionally returns a redacted copy.
+
+        Detection is deterministic (pattern matching plus checksum validation, no ML)
+        and every entity comes with exact character offsets into ``text``, so pass
+        raw text (not HTML) and apply the spans to your own copy of the document.
+        Person names and street addresses are not detected.
+
+        :param text: Text to scan for PII.
+        :type text: str
+        :param types: Optional list of PII types to detect. Defaults to all types:
+            ``email``, ``phone``, ``ssn``, ``credit_card``, ``ip_address``, ``iban``,
+            ``us_bank_routing``.
+        :type types: list[str]
+        :param redact: If True, the response also includes ``redacted_text`` with every
+            detected entity replaced by a placeholder such as ``[EMAIL]``.
+        :type redact: bool
+        :rtype: dict
+        :return:
+            - entities: List of ``{type, text, start, end, replacement}`` dicts, sorted
+              by ``start``; spans never overlap.
+            - flagged: True if any PII was detected.
+            - types: Sorted list of the PII types found.
+            - redacted_text: Only present when ``redact`` is True.
+        '''
+        url = self.url_endpoint + 'pii'
+        data = {
+            'key': self.api_key,
+            'text': text,
+        }
+        if types is not None:
+            if (not isinstance(types, Iterable)
+                    or isinstance(types, (str, bytes, dict))):
+                raise TypeError('types must be a list of entity type names')
+            data['types'] = list(types)
+        if redact is not None:
+            data['redact'] = redact
+        return self._request(url, data)
+
+    def seo(
+        self,
+        text,
+        keywords=None,
+        suggestions=None,
+        lang=None,
+    ):
+        '''
+        Analyzes the provided page or article text for SEO: deterministic content
+        statistics and readability, target-keyword usage, the most frequent terms, and
+        (optionally) LLM-generated titles, meta descriptions, a URL slug, and focus
+        keywords.
+
+        :param text: Page or article body, plain text or HTML (block tags become line
+            breaks, inline tags are removed), up to 20,000 characters.
+        :type text: str
+        :param keywords: Optional list of up to 10 target keyword phrases, most
+            important first (the first is the primary keyword). Each 1-100 characters.
+            Measured in the text and steered into the suggestions.
+        :type keywords: list[str]
+        :param suggestions: If False, only the deterministic ``stats``, ``keywords`` and
+            ``top_terms`` are returned (free); no ``suggestions`` are generated. The API
+            defaults to True (billed at the Tone rate).
+        :type suggestions: bool
+        :param lang: ISO 639-1 language code of the text (a region subtag such as
+            ``pt-BR`` is allowed, or ``auto``). The API defaults to ``en``. Only selects
+            the readability formulas: ``flesch_reading_ease`` and
+            ``flesch_kincaid_grade`` are computed for ``en``, ``de``, ``es``, ``fr``,
+            ``it``, ``nl``, ``pl`` and ``ru`` and are None for any other language.
+        :type lang: str
+        :rtype: dict
+        :return:
+            - stats: ``{chars, words, sentences, paragraphs, reading_time_min,
+              flesch_reading_ease, flesch_kincaid_grade}``; the two readability fields
+              are None for languages without readability support.
+            - keywords: One ``{keyword, count, density, in_first_100_words}`` dict per
+              submitted target keyword, in the same order; empty when none were sent.
+            - top_terms: Up to 10 most frequent content unigrams/bigrams as
+              ``{term, count}`` dicts (lower-cased, English stopwords removed).
+            - suggestions: Only present when ``suggestions`` is not False:
+              ``{titles, meta_descriptions, slug, keywords}`` where ``titles`` and
+              ``meta_descriptions`` are lists of strings, ``slug`` is a kebab-case
+              string (or None when no ASCII slug could be derived, e.g. purely CJK
+              content) and ``keywords`` is a list of focus-keyword phrases.
+        '''
+        url = self.url_endpoint + 'seo'
+        data = {
+            'key': self.api_key,
+            'text': text,
+        }
+        if keywords is not None:
+            if (not isinstance(keywords, Iterable)
+                    or isinstance(keywords, (str, bytes, dict))):
+                raise TypeError('keywords must be a list of keyword strings')
+            data['keywords'] = list(keywords)
+        if suggestions is not None:
+            data['suggestions'] = suggestions
+        if lang is not None:
+            data['lang'] = lang
+        return self._request(url, data)
+
+    def classify(
+        self,
+        text,
+        labels,
+        multi_label=None,
+        threshold=None,
+        context=None,
+    ):
+        '''
+        Classifies the provided text into one (or several) of the labels you supply.
+        Zero-shot: no training data or setup is needed, just the label names and,
+        optionally, a short description per label.
+
+        Example::
+
+            client.classify(
+                'I was charged twice for my last invoice.',
+                labels=[
+                    'billing',
+                    {'name': 'technical issue', 'description': 'Bugs, crashes, errors'},
+                    'shipping',
+                    'other',
+                ],
+                context='Support tickets for a SaaS billing product',
+            )
+            # {'label': 'billing',
+            #  'labels': ['billing'],
+            #  'scores': [{'label': 'billing', 'score': 0.86},
+            #             {'label': 'technical issue', 'score': 0.07},
+            #             {'label': 'shipping', 'score': 0.04},
+            #             {'label': 'other', 'score': 0.03}],
+            #  'rationale': 'The customer reports being charged twice on one invoice.',
+            #  'multi_label': False}
+
+        :param text: Text to classify, plain text or HTML (tags are stripped), up to
+            10,000 characters.
+        :type text: str
+        :param labels: 2-20 candidate labels. Each entry is either a label name (str) or
+            a dict ``{'name': str, 'description': str}`` where ``description`` is
+            optional. Names are up to 50 characters and must be unique
+            (case-insensitive); descriptions are up to 200 characters and help the
+            model with borderline decisions.
+        :type labels: list[str | dict]
+        :raises TypeError: If ``labels`` is None, a single string or a dict rather
+            than a list/tuple of labels.
+        :param multi_label: If False (the API default), exactly one label applies and
+            the scores form a probability distribution over the labels. If True, zero,
+            one or several labels may apply and each score is an independent 0-1
+            probability.
+        :type multi_label: bool
+        :param threshold: Multi-label cut-off, 0-1: ``labels`` in the response contains
+            every label with ``score >= threshold``. The API defaults to 0.5. Ignored in
+            single-label mode.
+        :type threshold: float
+        :param context: Up to 500 characters describing what the texts are or how to
+            decide (e.g. ``'Support tickets for a SaaS billing product'``). Guidance
+            only; the model can still only answer with the labels you provide.
+        :type context: str
+        :rtype: dict
+        :return:
+            - label: Best-matching label name (always one of the input labels).
+            - labels: Single-label mode: ``[label]``. Multi-label mode: every label
+              with ``score >= threshold``, descending by score; may be empty when none
+              of the labels apply.
+            - scores: One ``{label, score}`` dict per input label, sorted descending
+              by score (0-1, rounded to 4 decimals).
+            - rationale: One sentence naming the evidence in the text (may be empty).
+            - multi_label: The mode that was used.
+        '''
+        # A bare string would silently be split into one-character labels and
+        # None would raise an opaque TypeError from list(); fail loudly instead.
+        if (not isinstance(labels, Iterable)
+                or isinstance(labels, (str, bytes, dict))):
+            raise TypeError('labels must be a list of label names or '
+                            '{name, description} dicts')
+        url = self.url_endpoint + 'classify'
+        data = {
+            'key': self.api_key,
+            'text': text,
+            'labels': list(labels),
+        }
+        if multi_label is not None:
+            data['multi_label'] = multi_label
+        if threshold is not None:
+            data['threshold'] = threshold
+        if context is not None:
+            data['context'] = context
+        return self._request(url, data)

sapling_py-4.3.0/sapling/version.py

@@ -0,0 +1 @@
+__version__ = '4.3.0'

{sapling_py-4.1.0 → sapling_py-4.3.0/sapling_py.egg-info}/PKG-INFO

@@ -1,11 +1,12 @@
 Metadata-Version: 2.4
 Name: sapling-py
-Version: 4.1.0
+Version: 4.3.0
 Summary: Sapling Python Client
-Home-page: https://sapling.ai
-Author: Sapling Intelligence
-Author-email: info@sapling.ai
+Author-email: Sapling Intelligence <info@sapling.ai>
 License: Apache License 2.0
+Project-URL: Homepage, https://sapling.ai
+Project-URL: Documentation, https://sapling.readthedocs.io/
+Project-URL: Repository, https://github.com/saplingai/sapling-py
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Programming Language :: Python :: 3
@@ -17,18 +18,7 @@ Requires-Dist: requests
 Provides-Extra: test
 Requires-Dist: pytest; extra == "test"
 Requires-Dist: responses; extra == "test"
-Dynamic: author
-Dynamic: author-email
-Dynamic: classifier
-Dynamic: description
-Dynamic: description-content-type
-Dynamic: home-page
-Dynamic: license
 Dynamic: license-file
-Dynamic: provides-extra
-Dynamic: requires-dist
-Dynamic: requires-python
-Dynamic: summary
 
 # Sapling Python Client
 
@@ -40,7 +30,9 @@ Compare against leading grammar checking tools and APIs like Grammarly (Grammerl
 ## Overview
 
 Sapling is a toolkit for helping developers build language model-powered applications.
-The API provides spelling and grammar checking, autocomplete, tone detection, rephrasing, AI detection, and more.
+The API provides spelling and grammar checking, autocomplete, tone detection, rephrasing, AI detection,
+zero-shot text classification, structured data extraction, PII detection and redaction, content safety
+scoring, SEO analysis, and more.
 
 Key Features:
 - **60% More Corrections**: Outperforms [competing solutions](https://sapling.ai/comparison/api#sapling) at similar accuracy levels using state-of-the-art generative AI models.
@@ -52,12 +44,19 @@ Key Features:
 
 ## Installation
 
-Install the `sapling-py` package with [pip](https://pip.pypa.io/en/stable/installation/)
+Install the `sapling-py` package from PyPI with
+[pip](https://pip.pypa.io/en/stable/installation/):
 
-```
+```sh
 python -m pip install sapling-py
 ```
 
+Or add it to a [uv](https://docs.astral.sh/uv/) project:
+
+```sh
+uv add sapling-py
+```
+
 ## Documentation
 Documentation for the client is available at [Read the Docs](https://sapling.readthedocs.io/) and
 documentation for the HTTP API is available at [Sapling.ai](https://sapling.ai/docs).

{sapling_py-4.1.0 → sapling_py-4.3.0}/sapling_py.egg-info/SOURCES.txt

@@ -1,5 +1,6 @@
 LICENSE
 README.md
+pyproject.toml
 setup.py
 sapling/__init__.py
 sapling/client.py
@@ -9,5 +10,9 @@ sapling_py.egg-info/SOURCES.txt
 sapling_py.egg-info/dependency_links.txt
 sapling_py.egg-info/requires.txt
 sapling_py.egg-info/top_level.txt
-test/__init__.py
-test/test_client.py
+test/test_classify.py
+test/test_client.py
+test/test_extract.py
+test/test_pii.py
+test/test_safety.py
+test/test_seo.py