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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sapling-py
-Version: 4.3.0
+Version: 4.11.0
 Summary: Sapling Python Client
 Author-email: Sapling Intelligence <info@sapling.ai>
 License: Apache License 2.0
@@ -31,8 +31,9 @@ Compare against leading grammar checking tools and APIs like Grammarly (Grammerl
 
 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,
-zero-shot text classification, structured data extraction, PII detection and redaction, content safety
-scoring, SEO analysis, and more.
+zero-shot text classification, structured data extraction, translation, PII detection
+and redaction, content safety scoring, plain-language
+simplification, 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.
@@ -94,6 +95,20 @@ Get a production key by following [this documentation](https://sapling.ai/docs/a
 
 Here's some more information on [request options and response structure](https://sapling.ai/docs/api/edits-overview).
 
+## Batch requests
+
+The analysis endpoints — `classify`, `extract`, `safety`, `langdetect`,
+`translate`, `summarize`, `quality` and `aidetect` — also accept a list of
+1-10 texts in
+place of a single string. The batch is sent as one request (the same options
+apply to every item) and returns `{'results': [...]}` with one
+single-response-shaped dict per input, in order:
+
+```python
+scores = client.quality(['First draft.', 'Second draft.'], sentence_scores=True)
+langs = client.langdetect(['Bonjour le monde', 'Hello world'])
+```
+
 ## License
 
 Copyright 2024--present Sapling Intelligence, Inc.

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

@@ -9,8 +9,9 @@ Compare against leading grammar checking tools and APIs like Grammarly (Grammerl
 
 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,
-zero-shot text classification, structured data extraction, PII detection and redaction, content safety
-scoring, SEO analysis, and more.
+zero-shot text classification, structured data extraction, translation, PII detection
+and redaction, content safety scoring, plain-language
+simplification, 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.
@@ -72,6 +73,20 @@ Get a production key by following [this documentation](https://sapling.ai/docs/a
 
 Here's some more information on [request options and response structure](https://sapling.ai/docs/api/edits-overview).
 
+## Batch requests
+
+The analysis endpoints — `classify`, `extract`, `safety`, `langdetect`,
+`translate`, `summarize`, `quality` and `aidetect` — also accept a list of
+1-10 texts in
+place of a single string. The batch is sent as one request (the same options
+apply to every item) and returns `{'results': [...]}` with one
+single-response-shaped dict per input, in order:
+
+```python
+scores = client.quality(['First draft.', 'Second draft.'], sentence_scores=True)
+langs = client.langdetect(['Bonjour le monde', 'Hello world'])
+```
+
 ## License
 
 Copyright 2024--present Sapling Intelligence, Inc.

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

@@ -430,8 +430,13 @@ class SaplingClient:
         '''
         Score a piece of text on how likely it was generated by AI.
 
-        :param text: Text to score for AI-generated content.
-        :type text: str
+        :param text: Text to score for AI-generated content (up to 200,000
+            characters). Pass a list or tuple of 1-10 strings to score a batch
+            in one request (sent as the API's ``texts`` parameter; the same
+            options apply to every item, and the combined length is capped at
+            200,000 characters). A batch response is ``{'results': [...]}``
+            with one single-response-shaped dict per input, in order.
+        :type text: str | list[str]
         :param sent_scores: If true, each sentence will also be scored individually.
         :type sent_scores: bool
 
@@ -445,12 +450,94 @@ class SaplingClient:
         url = f'{self.url_endpoint}aidetect'
         data = {
             'key': self.api_key,
-            'text': text,
         }
+        # A list/tuple of texts is the batch form: one request, one result per
+        # item ({'results': [...]}), same options applied to every item.
+        if isinstance(text, (list, tuple)):
+            data['texts'] = list(text)
+        else:
+            data['text'] = text
         if sent_scores is not None:
             data['sent_scores'] = sent_scores
         return self._request(url, data)
 
+    def simplify(
+        self,
+        text,
+        reading_level=None,
+        preserve_terms=None,
+        lang=None,
+    ):
+        '''
+        Rewrites a text in plain language at a target reading level, keeping
+        all of its content, structure and language — nothing is summarized or
+        dropped. The response includes a deterministic before/after
+        readability block (Flesch-Kincaid grade and reading ease) when the
+        text's language supports it, so the improvement is verifiable.
+
+        Example::
+
+            client.simplify(
+                'The party of the first part shall remit payment within '
+                'thirty (30) days of receipt of the invoice.',
+                reading_level='plain',
+                preserve_terms=['invoice'],
+            )
+            # {'simplified': 'You must pay within 30 days of getting '
+            #                'the invoice.',
+            #  'reading_level': 'plain', 'lang': 'en',
+            #  'readability': {'before': {'grade': 12.3, 'ease': 42.1},
+            #                  'after': {'grade': 5.8, 'ease': 78.4}}}
+
+        :param text: Text to simplify, up to 5,000 characters. Sent to the
+            model as submitted — markup and line structure are preserved, not
+            stripped.
+        :type text: str
+        :param reading_level: Target audience: ``'plain'`` (plain-language
+            style for a general audience, the API default), ``'elementary'``
+            (~US grade 3-5), ``'middle_school'`` (~grade 6-8) or
+            ``'high_school'`` (~grade 9-10).
+        :type reading_level: str
+        :param preserve_terms: Up to 20 terms (each up to 100 characters) the
+            rewrite must keep exactly as written — product names, defined
+            legal terms. A rewrite that drops one is refused server-side
+            rather than returned.
+        :type preserve_terms: list[str]
+        :param lang: ISO 639-1 code used to pick the readability formula for
+            the before/after scores. Omit for auto-detection (falls back to
+            ``'en'``). The rewrite itself always stays in the text's own
+            language.
+        :type lang: str
+        :raises TypeError: If ``preserve_terms`` is a single string rather
+            than a list/tuple of terms.
+        :rtype: dict
+        :return:
+            - simplified: The rewritten text, structure preserved.
+            - reading_level: The reading level that was applied.
+            - lang: The language the readability scores were computed for
+              (detected when not supplied).
+            - readability: ``{'before': {'grade', 'ease'}, 'after': {'grade',
+              'ease'}}`` Flesch-Kincaid scores, present when the language
+              supports readability scoring.
+        '''
+        # A bare string would silently be split into one-character terms;
+        # fail loudly instead (same guard as extract/classify).
+        if preserve_terms is not None and (
+                not isinstance(preserve_terms, Iterable)
+                or isinstance(preserve_terms, (str, bytes, dict))):
+            raise TypeError('preserve_terms must be a list of strings')
+        url = f'{self.url_endpoint}simplify'
+        data = {
+            'key': self.api_key,
+            'text': text,
+        }
+        if reading_level is not None:
+            data['reading_level'] = reading_level
+        if preserve_terms is not None:
+            data['preserve_terms'] = list(preserve_terms)
+        if lang is not None:
+            data['lang'] = lang
+        return self._request(url, data)
     def chunk_text(
         self,
         text,
@@ -615,21 +702,55 @@ class SaplingClient:
     def summarize(
         self,
         text,
+        length=None,
     ):
         '''
-        Summarizes a longer document into a shorter, more digestible one.
+        Summarizes a longer document, webpage or email thread into a prose
+        summary plus key points.
 
-        :param text: Input document to summarize.
-        :type text: str
+        Example::
+
+            client.summarize(
+                'Hi, I was charged twice for my order this month. ...',
+                length='short',
+            )
+            # {'result': 'The customer was double-charged and wants a refund.',
+            #  'summary': 'The customer was double-charged and wants a refund.',
+            #  'key_points': ['Charged twice for one order.',
+            #                 'Requests a refund of the duplicate.'],
+            #  'length': 'short'}
+
+        :param text: Input document to summarize, plain text or HTML (tags
+            are stripped), up to 20,000 characters. Pass a list or tuple of
+            1-10 strings to summarize a batch in one request (sent as the
+            API's ``texts`` parameter; combined length up to 20,000
+            characters, same ``length`` option applied to every item). A
+            batch response is ``{'results': [...]}`` with one
+            single-response-shaped dict per input, in order.
+        :type text: str | list[str]
+        :param length: Optional summary length: ``'short'``, ``'medium'``
+            (the default) or ``'long'``.
+        :type length: str
         :rtype: dict
         :return:
-            - result: The summarized text.
+            - summary: The prose summary.
+            - result: Mirrors ``summary`` (the endpoint's original response
+              key, kept for backward compatibility).
+            - key_points: List of key-point strings.
+            - length: The length option the summary was generated with.
         '''
         url = self.url_endpoint + 'summarize'
         data = {
             'key': self.api_key,
-            'text': text,
         }
+        # A list/tuple of texts is the batch form: one request, one result per
+        # item ({'results': [...]}), same options applied to every item.
+        if isinstance(text, (list, tuple)):
+            data['texts'] = list(text)
+        else:
+            data['text'] = text
+        if length is not None:
+            data['length'] = length
         return self._request(url, data)
 
     def extract(
@@ -672,8 +793,12 @@ class SaplingClient:
             #  'missing': ['purchase_order']}
 
         :param text: Document to extract from, plain text or HTML (tags are
-            stripped), up to 10,000 characters.
-        :type text: str
+            stripped), up to 10,000 characters. Pass a list or tuple of 1-10
+            strings to extract from a batch in one request (sent as the API's
+            ``texts`` parameter; combined length up to 10,000 characters). A batch
+            response is ``{'results': [...]}`` with one single-response-shaped
+            dict per input, in order.
+        :type text: str | list[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
@@ -711,13 +836,85 @@ class SaplingClient:
         url = self.url_endpoint + 'extract'
         data = {
             'key': self.api_key,
-            'text': text,
             'fields': list(fields),
         }
+        # A list/tuple of texts is the batch form: one request, one result per
+        # item ({'results': [...]}), same fields applied to every item.
+        if isinstance(text, (list, tuple)):
+            data['texts'] = list(text)
+        else:
+            data['text'] = text
         if context is not None:
             data['context'] = context
         return self._request(url, data)
 
+    def translate(
+        self,
+        text,
+        target_lang,
+        source_lang=None,
+        formality=None,
+    ):
+        '''
+        Translates text into a target language with an LLM, preserving line
+        breaks, markup and placeholders in place. The response reports the
+        language the text was actually written in (detected, not assumed from
+        the hint).
+
+        Example::
+
+            client.translate(
+                'Hello world.\\nSee you at 5pm.',
+                target_lang='fr',
+            )
+            # {'translation': 'Bonjour le monde.\\nÀ 17h.',
+            #  'source_lang': 'en', 'source_lang_name': 'English',
+            #  'target_lang': 'fr', 'target_lang_name': 'French'}
+
+        :param text: Text to translate, up to 5,000 characters. Markup and
+            whitespace are preserved, not stripped. Pass a list or tuple of
+            1-10 strings to translate a batch in one request (sent as the
+            API's ``texts`` parameter; combined length up to 5,000
+            characters, same target/source/formality applied to every item).
+            A batch response is ``{'results': [...]}`` with one
+            single-response-shaped dict per input, in order.
+        :type text: str | list[str]
+        :param target_lang: Language to translate into: an ISO 639 code
+            (``'fr'``, ``'zh-TW'``) or an English language name
+            (``'French'``). Region variants ``zh-CN``/``zh-TW``/``zh-HK``,
+            ``pt-BR``/``pt-PT``, ``en-GB``/``en-US``, ``fr-CA`` and ``es-419``
+            are supported as targets.
+        :type target_lang: str
+        :param source_lang: Optional hint for the source language, same forms
+            as ``target_lang``. The text itself wins if they disagree.
+        :type source_lang: str
+        :param formality: Optional register: ``'formal'`` (vous/Sie/usted) or
+            ``'informal'`` (tu/du/tú). Omit for the model default.
+        :type formality: str
+        :rtype: dict
+        :return:
+            - translation: The translated text, structure preserved.
+            - source_lang / source_lang_name: The detected source language
+              (``'und'`` and ``None`` when undetermined).
+            - target_lang / target_lang_name: The normalized target.
+        '''
+        url = self.url_endpoint + 'translate'
+        data = {
+            'key': self.api_key,
+            'target_lang': target_lang,
+        }
+        # A list/tuple of texts is the batch form: one request, one result per
+        # item ({'results': [...]}), same options applied to every item.
+        if isinstance(text, (list, tuple)):
+            data['texts'] = list(text)
+        else:
+            data['text'] = text
+        if source_lang is not None:
+            data['source_lang'] = source_lang
+        if formality is not None:
+            data['formality'] = formality
+        return self._request(url, data)
+
     def tone(
         self,
         text,
@@ -779,8 +976,13 @@ class SaplingClient:
 
         :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
+            (up to 20,000 characters). Pass a list or tuple of 1-10 strings to
+            score a batch in one request (sent as the API's ``texts`` parameter;
+            the same options apply to every item, and with ``rubric`` the
+            combined length is capped at 20,000 characters). A batch response is
+            ``{'results': [...]}`` with one single-response-shaped dict per
+            input, in order.
+        :type text: str | list[str]
         :param sentence_scores: If true, also return a 1-5 score for each sentence
             under `sentences`.
         :type sentence_scores: bool
@@ -799,8 +1001,13 @@ class SaplingClient:
         url = self.url_endpoint + 'quality'
         data = {
             'key': self.api_key,
-            'text': text,
         }
+        # A list/tuple of texts is the batch form: one request, one result per
+        # item ({'results': [...]}), same options applied to every item.
+        if isinstance(text, (list, tuple)):
+            data['texts'] = list(text)
+        else:
+            data['text'] = text
         if sentence_scores is not None:
             data['sentence_scores'] = sentence_scores
         if rubric is not None:
@@ -818,7 +1025,11 @@ class SaplingClient:
         candidates and a per-segment breakdown for mixed-language text.
 
         :param text: Text to identify the language for (up to 20,000 characters).
-        :type text: str
+            Pass a list or tuple of 1-10 strings to detect a batch in one
+            request (sent as the API's ``texts`` parameter; combined length up
+            to 20,000 characters). A batch response is ``{'results': [...]}``
+            with one single-response-shaped dict per input, in order.
+        :type text: str | list[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
@@ -836,8 +1047,13 @@ class SaplingClient:
         url = self.url_endpoint + 'langdetect'
         data = {
             'key': self.api_key,
-            'text': text,
         }
+        # A list/tuple of texts is the batch form: one request, one result per
+        # item ({'results': [...]}), same options applied to every item.
+        if isinstance(text, (list, tuple)):
+            data['texts'] = list(text)
+        else:
+            data['text'] = text
         if top_k is not None:
             data['top_k'] = top_k
         if segments is not None:
@@ -875,8 +1091,12 @@ class SaplingClient:
         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 text: Text to score, up to 20,000 characters. Pass a list or
+            tuple of 1-10 strings to score a batch in one request (sent as the
+            API's ``texts`` parameter; combined length up to 20,000
+            characters). A batch response is ``{'results': [...]}`` with one
+            single-response-shaped dict per input, in order.
+        :type text: str | list[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
@@ -897,8 +1117,13 @@ class SaplingClient:
         url = self.url_endpoint + 'safety'
         data = {
             'key': self.api_key,
-            'text': text,
         }
+        # A list/tuple of texts is the batch form: one request, one result per
+        # item ({'results': [...]}), same options applied to every item.
+        if isinstance(text, (list, tuple)):
+            data['texts'] = list(text)
+        else:
+            data['text'] = text
         if threshold is not None:
             data['threshold'] = threshold
         if spans is not None:
@@ -1047,8 +1272,12 @@ class SaplingClient:
             #  'multi_label': False}
 
         :param text: Text to classify, plain text or HTML (tags are stripped), up to
-            10,000 characters.
-        :type text: str
+            10,000 characters. Pass a list or tuple of 1-10 strings to classify a
+            batch in one request (sent as the API's ``texts`` parameter; combined
+            length up to 10,000 characters). A batch response is
+            ``{'results': [...]}`` with one single-response-shaped dict per input,
+            in order.
+        :type text: str | list[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
@@ -1090,9 +1319,14 @@ class SaplingClient:
         url = self.url_endpoint + 'classify'
         data = {
             'key': self.api_key,
-            'text': text,
             'labels': list(labels),
         }
+        # A list/tuple of texts is the batch form: one request, one result per
+        # item ({'results': [...]}), same labels applied to every item.
+        if isinstance(text, (list, tuple)):
+            data['texts'] = list(text)
+        else:
+            data['text'] = text
         if multi_label is not None:
             data['multi_label'] = multi_label
         if threshold is not None:

sapling_py-4.11.0/sapling/version.py

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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sapling-py
-Version: 4.3.0
+Version: 4.11.0
 Summary: Sapling Python Client
 Author-email: Sapling Intelligence <info@sapling.ai>
 License: Apache License 2.0
@@ -31,8 +31,9 @@ Compare against leading grammar checking tools and APIs like Grammarly (Grammerl
 
 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,
-zero-shot text classification, structured data extraction, PII detection and redaction, content safety
-scoring, SEO analysis, and more.
+zero-shot text classification, structured data extraction, translation, PII detection
+and redaction, content safety scoring, plain-language
+simplification, 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.
@@ -94,6 +95,20 @@ Get a production key by following [this documentation](https://sapling.ai/docs/a
 
 Here's some more information on [request options and response structure](https://sapling.ai/docs/api/edits-overview).
 
+## Batch requests
+
+The analysis endpoints — `classify`, `extract`, `safety`, `langdetect`,
+`translate`, `summarize`, `quality` and `aidetect` — also accept a list of
+1-10 texts in
+place of a single string. The batch is sent as one request (the same options
+apply to every item) and returns `{'results': [...]}` with one
+single-response-shaped dict per input, in order:
+
+```python
+scores = client.quality(['First draft.', 'Second draft.'], sentence_scores=True)
+langs = client.langdetect(['Bonjour le monde', 'Hello world'])
+```
+
 ## License
 
 Copyright 2024--present Sapling Intelligence, Inc.

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

@@ -15,4 +15,6 @@ test/test_client.py
 test/test_extract.py
 test/test_pii.py
 test/test_safety.py
-test/test_seo.py
+test/test_seo.py
+test/test_simplify.py
+test/test_translate.py

{sapling_py-4.3.0 → sapling_py-4.11.0}/test/test_classify.py

@@ -198,3 +198,26 @@ def test_classify_custom_hostname_and_pathname():
 def test_classify_rejects_non_list_labels(client, bad_labels):
     with pytest.raises(TypeError):
         client.classify('I was charged twice.', bad_labels)
+
+
+@responses.activate
+def test_classify_batch_list_sent_as_texts(client):
+    # A list of texts is the batch form (SAP-395): sent as `texts`, no `text`
+    # key, and the {'results': [...]} body comes back untouched.
+    batch_response = {'results': [CLASSIFY_RESPONSE, MULTI_LABEL_RESPONSE]}
+    responses.add(responses.POST, BASE + 'classify', json=batch_response, status=200)
+    result = client.classify(['first ticket', 'second ticket'], LABELS)
+    assert result == batch_response
+    body = _last_request_body()
+    assert body == {'key': API_KEY, 'texts': ['first ticket', 'second ticket'],
+                    'labels': LABELS}
+
+
+@responses.activate
+def test_classify_batch_tuple_sent_as_list(client):
+    responses.add(responses.POST, BASE + 'classify',
+                  json={'results': [CLASSIFY_RESPONSE]}, status=200)
+    client.classify(('only ticket',), LABELS)
+    body = _last_request_body()
+    assert body['texts'] == ['only ticket']
+    assert 'text' not in body

{sapling_py-4.3.0 → sapling_py-4.11.0}/test/test_client.py

@@ -168,6 +168,31 @@ def test_langdetect_options(client):
     assert _last_request_body() == {'key': API_KEY, 'text': 'Hello', 'top_k': 1, 'segments': True}
 
 
+@responses.activate
+def test_langdetect_batch_list_sent_as_texts(client):
+    # A list of texts is the batch form (SAP-397): sent as `texts`, no `text`
+    # key, and the {'results': [...]} body comes back untouched.
+    batch_response = {'results': [
+        {'lang': 'en', 'name': 'English', 'conf': 0.99, 'candidates': []},
+        {'lang': 'es', 'name': 'Spanish', 'conf': 0.97, 'candidates': []},
+    ]}
+    responses.add(responses.POST, BASE + 'langdetect', json=batch_response, status=200)
+    result = client.langdetect(['Hello there.', 'Hola.'], top_k=1)
+    assert result == batch_response
+    assert _last_request_body() == {'key': API_KEY, 'texts': ['Hello there.', 'Hola.'],
+                                    'top_k': 1}
+
+
+@responses.activate
+def test_langdetect_batch_tuple_sent_as_list(client):
+    responses.add(responses.POST, BASE + 'langdetect',
+                  json={'results': [{'lang': 'en'}]}, status=200)
+    client.langdetect(('Hello there.',))
+    body = _last_request_body()
+    assert body['texts'] == ['Hello there.']
+    assert 'text' not in body
+
+
 @responses.activate
 def test_hostname_and_pathname_override():
     client = SaplingClient(api_key=API_KEY, hostname='http://localhost:5000', pathname='/api/v1/')
@@ -193,3 +218,100 @@ def test_quality_options(client):
     assert result == payload
     assert _last_request_body() == {'key': API_KEY, 'text': 'Hello',
                                     'sentence_scores': True, 'rubric': True}
+
+
+@responses.activate
+def test_quality_batch_list_sent_as_texts(client):
+    # A list of texts is the batch form (SAP-400): sent as `texts`, no `text`
+    # key, the same options applied to every item, and the {'results': [...]}
+    # body comes back untouched.
+    batch_response = {'results': [
+        {'score': 4.1},
+        {'score': 2.3},
+    ]}
+    responses.add(responses.POST, BASE + 'quality', json=batch_response, status=200)
+    result = client.quality(['First document.', 'Second document.'],
+                            sentence_scores=True)
+    assert result == batch_response
+    assert _last_request_body() == {'key': API_KEY,
+                                    'texts': ['First document.', 'Second document.'],
+                                    'sentence_scores': True}
+
+
+@responses.activate
+def test_quality_batch_tuple_sent_as_list(client):
+    responses.add(responses.POST, BASE + 'quality',
+                  json={'results': [{'score': 3.0}]}, status=200)
+    client.quality(('First document.',))
+    body = _last_request_body()
+    assert body['texts'] == ['First document.']
+    assert 'text' not in body
+
+
+@responses.activate
+def test_summarize_length_sent_only_when_given(client):
+    payload = {'result': 'Short.', 'summary': 'Short.', 'key_points': ['One.'],
+               'length': 'short'}
+    responses.add(responses.POST, BASE + 'summarize', json=payload, status=200)
+    result = client.summarize('A long document.', length='short')
+    assert result == payload
+    assert _last_request_body() == {'key': API_KEY, 'text': 'A long document.',
+                                    'length': 'short'}
+
+    responses.add(responses.POST, BASE + 'summarize', json=payload, status=200)
+    client.summarize('A long document.')
+    assert 'length' not in _last_request_body()
+
+
+@responses.activate
+def test_summarize_batch_list_sent_as_texts(client):
+    # A list of texts is the batch form (SAP-399): sent as `texts`, no `text`
+    # key, and the {'results': [...]} body comes back untouched.
+    batch_response = {'results': [
+        {'result': 'One.', 'summary': 'One.', 'key_points': ['A.'], 'length': 'medium'},
+        {'result': 'Two.', 'summary': 'Two.', 'key_points': ['B.'], 'length': 'medium'},
+    ]}
+    responses.add(responses.POST, BASE + 'summarize', json=batch_response, status=200)
+    result = client.summarize(['First document.', 'Second document.'])
+    assert result == batch_response
+    assert _last_request_body() == {'key': API_KEY,
+                                    'texts': ['First document.', 'Second document.']}
+
+
+@responses.activate
+def test_summarize_batch_tuple_sent_as_list(client):
+    responses.add(responses.POST, BASE + 'summarize',
+                  json={'results': [{'result': 'One.'}]}, status=200)
+    client.summarize(('First document.',), length='long')
+    body = _last_request_body()
+    assert body['texts'] == ['First document.']
+    assert body['length'] == 'long'
+    assert 'text' not in body
+
+
+@responses.activate
+def test_aidetect_batch_list_sent_as_texts(client):
+    # A list of texts is the batch form (SAP-403): sent as `texts`, no `text`
+    # key, and the {'results': [...]} body comes back untouched.
+    batch_response = {'results': [
+        {'score': 0.91, 'text': 'Almost certainly generated.'},
+        {'score': 0.08, 'text': 'Plainly human prose.'},
+    ]}
+    responses.add(responses.POST, BASE + 'aidetect', json=batch_response, status=200)
+    result = client.aidetect(['Almost certainly generated.', 'Plainly human prose.'],
+                             sent_scores=False)
+    assert result == batch_response
+    assert _last_request_body() == {'key': API_KEY,
+                                    'texts': ['Almost certainly generated.',
+                                              'Plainly human prose.'],
+                                    'sent_scores': False}
+
+
+@responses.activate
+def test_aidetect_batch_tuple_sent_as_list(client):
+    responses.add(responses.POST, BASE + 'aidetect',
+                  json={'results': [{'score': 0.5}]}, status=200)
+    client.aidetect(('One draft.',))
+    body = _last_request_body()
+    assert body['texts'] == ['One draft.']
+    assert 'text' not in body

{sapling_py-4.3.0 → sapling_py-4.11.0}/test/test_extract.py

@@ -211,3 +211,27 @@ def test_extract_accepts_any_iterable_of_fields(client):
     responses.add(responses.POST, BASE + 'extract', json=EXTRACT_RESPONSE, status=200)
     client.extract(TEXT, (name for name in ['invoice_number', 'total']))
     assert _last_request_body()['fields'] == ['invoice_number', 'total']
+
+
+@responses.activate
+def test_extract_batch_list_sent_as_texts(client):
+    # A list of texts is the batch form (SAP-395): sent as `texts`, no `text`
+    # key, and the {'results': [...]} body comes back untouched.
+    batch_response = {'results': [EXTRACT_RESPONSE, EXTRACT_RESPONSE]}
+    responses.add(responses.POST, BASE + 'extract', json=batch_response, status=200)
+    result = client.extract([TEXT, 'Invoice INV-2077 for Globex.'], FIELDS)
+    assert result == batch_response
+    body = _last_request_body()
+    assert body['texts'] == [TEXT, 'Invoice INV-2077 for Globex.']
+    assert 'text' not in body
+    assert body['fields'] == FIELDS
+
+
+@responses.activate
+def test_extract_batch_tuple_sent_as_list(client):
+    responses.add(responses.POST, BASE + 'extract',
+                  json={'results': [EXTRACT_RESPONSE]}, status=200)
+    client.extract((TEXT,), FIELDS)
+    body = _last_request_body()
+    assert body['texts'] == [TEXT]
+    assert 'text' not in body

{sapling_py-4.3.0 → sapling_py-4.11.0}/test/test_safety.py

@@ -54,3 +54,26 @@ def test_safety_spans_omitted_by_default(client):
     client.safety('some text')
     body = json.loads(responses.calls[-1].request.body)
     assert 'spans' not in body
+
+
+@responses.activate
+def test_safety_batch_list_sent_as_texts(client):
+    # A list of texts is the batch form (SAP-397): sent as `texts`, no `text`
+    # key, and the {'results': [...]} body comes back untouched.
+    batch_response = {'results': [{'flagged': True}, {'flagged': False}]}
+    responses.add(responses.POST, BASE + 'safety', json=batch_response, status=200)
+    result = client.safety(['first message', 'second message'], threshold=0.7)
+    assert result == batch_response
+    body = json.loads(responses.calls[-1].request.body)
+    assert body == {'key': API_KEY, 'texts': ['first message', 'second message'],
+                    'threshold': 0.7}
+
+
+@responses.activate
+def test_safety_batch_tuple_sent_as_list(client):
+    responses.add(responses.POST, BASE + 'safety',
+                  json={'results': [{'flagged': False}]}, status=200)
+    client.safety(('only message',))
+    body = json.loads(responses.calls[-1].request.body)
+    assert body['texts'] == ['only message']
+    assert 'text' not in body

sapling_py-4.11.0/test/test_simplify.py

@@ -0,0 +1,95 @@
+import json
+
+import pytest
+import responses
+
+from sapling import SaplingClient
+
+API_KEY = 'a' * 32
+BASE = 'https://api.sapling.ai/api/v1/'
+
+TEXT = ('The party of the first part shall remit payment within thirty (30) '
+        'days of receipt of the invoice.')
+
+SIMPLIFY_RESPONSE = {
+    'simplified': 'You must pay within 30 days of getting the invoice.',
+    'reading_level': 'plain',
+    'lang': 'en',
+    'readability': {
+        'before': {'grade': 12.3, 'ease': 42.1},
+        'after': {'grade': 5.8, 'ease': 78.4},
+    },
+}
+
+
+@pytest.fixture
+def client():
+    return SaplingClient(api_key=API_KEY)
+
+
+def _last_request_body():
+    return json.loads(responses.calls[-1].request.body)
+
+
+@responses.activate
+def test_simplify_returns_json_and_sends_key_and_text(client):
+    responses.add(responses.POST, BASE + 'simplify',
+                  json=SIMPLIFY_RESPONSE, status=200)
+    result = client.simplify(TEXT)
+    assert result == SIMPLIFY_RESPONSE
+    body = _last_request_body()
+    assert body == {'key': API_KEY, 'text': TEXT}
+
+
+@responses.activate
+def test_simplify_posts_to_simplify_endpoint(client):
+    responses.add(responses.POST, BASE + 'simplify',
+                  json=SIMPLIFY_RESPONSE, status=200)
+    client.simplify(TEXT)
+    assert responses.calls[-1].request.url == BASE + 'simplify'
+
+
+@responses.activate
+def test_simplify_omits_optional_arguments_when_not_given(client):
+    responses.add(responses.POST, BASE + 'simplify',
+                  json=SIMPLIFY_RESPONSE, status=200)
+    client.simplify(TEXT)
+    body = _last_request_body()
+    assert 'reading_level' not in body
+    assert 'preserve_terms' not in body
+    assert 'lang' not in body
+
+
+@responses.activate
+def test_simplify_sends_optional_arguments(client):
+    responses.add(responses.POST, BASE + 'simplify',
+                  json=SIMPLIFY_RESPONSE, status=200)
+    client.simplify(TEXT, reading_level='middle_school',
+                    preserve_terms=['invoice', 'Sapling'], lang='en')
+    body = _last_request_body()
+    assert body['reading_level'] == 'middle_school'
+    assert body['preserve_terms'] == ['invoice', 'Sapling']
+    assert body['lang'] == 'en'
+
+
+@responses.activate
+def test_simplify_accepts_a_tuple_of_preserve_terms(client):
+    responses.add(responses.POST, BASE + 'simplify',
+                  json=SIMPLIFY_RESPONSE, status=200)
+    client.simplify(TEXT, preserve_terms=('invoice',))
+    assert _last_request_body()['preserve_terms'] == ['invoice']
+
+
+def test_simplify_rejects_non_list_preserve_terms(client):
+    for bad in ('invoice', b'invoice', {'term': 'invoice'}, 5):
+        with pytest.raises(TypeError):
+            client.simplify(TEXT, preserve_terms=bad)
+
+
+@responses.activate
+def test_simplify_http_error_raises(client):
+    responses.add(responses.POST, BASE + 'simplify',
+                  json={'msg': 'Unexpected error simplifying text.'},
+                  status=502)
+    with pytest.raises(Exception):
+        client.simplify(TEXT)

sapling_py-4.11.0/test/test_translate.py

@@ -0,0 +1,109 @@
+import json
+
+import pytest
+import responses
+
+from sapling import SaplingClient, SaplingError
+
+API_KEY = 'a' * 32
+BASE = 'https://api.sapling.ai/api/v1/'
+
+TEXT = 'Hello world.\nSee you at 5pm.'
+
+TRANSLATE_RESPONSE = {
+    'translation': 'Bonjour le monde.\nÀ 17h.',
+    'source_lang': 'en',
+    'source_lang_name': 'English',
+    'target_lang': 'fr',
+    'target_lang_name': 'French',
+}
+
+
+@pytest.fixture
+def client():
+    return SaplingClient(api_key=API_KEY)
+
+
+def _last_request_body():
+    return json.loads(responses.calls[-1].request.body)
+
+
+@responses.activate
+def test_translate_returns_json_and_sends_key(client):
+    responses.add(responses.POST, BASE + 'translate',
+                  json=TRANSLATE_RESPONSE, status=200)
+    result = client.translate(TEXT, target_lang='fr')
+    assert result == TRANSLATE_RESPONSE
+    body = _last_request_body()
+    assert body == {'key': API_KEY, 'text': TEXT, 'target_lang': 'fr'}
+
+
+@responses.activate
+def test_translate_posts_to_translate_endpoint(client):
+    responses.add(responses.POST, BASE + 'translate',
+                  json=TRANSLATE_RESPONSE, status=200)
+    client.translate(TEXT, target_lang='fr')
+    assert responses.calls[-1].request.url == BASE + 'translate'
+
+
+@responses.activate
+def test_translate_optional_params_sent_only_when_given(client):
+    responses.add(responses.POST, BASE + 'translate',
+                  json=TRANSLATE_RESPONSE, status=200)
+    client.translate(TEXT, target_lang='fr')
+    body = _last_request_body()
+    assert 'source_lang' not in body
+    assert 'formality' not in body
+
+    client.translate(TEXT, target_lang='fr',
+                     source_lang='en', formality='formal')
+    body = _last_request_body()
+    assert body['source_lang'] == 'en'
+    assert body['formality'] == 'formal'
+
+
+@responses.activate
+def test_translate_accepts_names_and_region_variants(client):
+    responses.add(responses.POST, BASE + 'translate',
+                  json=dict(TRANSLATE_RESPONSE, target_lang='zh-TW',
+                            target_lang_name='Traditional Chinese'),
+                  status=200)
+    result = client.translate(TEXT, target_lang='Traditional Chinese')
+    assert result['target_lang'] == 'zh-TW'
+    assert _last_request_body()['target_lang'] == 'Traditional Chinese'
+
+
+@responses.activate
+def test_translate_http_error_raises_sapling_error(client):
+    responses.add(responses.POST, BASE + 'translate',
+                  json={'msg': 'Unknown language: "Klingon".'}, status=400)
+    with pytest.raises(SaplingError):
+        client.translate(TEXT, target_lang='Klingon')
+
+
+@responses.activate
+def test_translate_batch_list_sent_as_texts(client):
+    # A list of texts is the batch form (SAP-398): sent as `texts`, no `text`
+    # key, and the {'results': [...]} body comes back untouched.
+    batch_response = {'results': [TRANSLATE_RESPONSE,
+                                  dict(TRANSLATE_RESPONSE,
+                                       translation='À demain.')]}
+    responses.add(responses.POST, BASE + 'translate',
+                  json=batch_response, status=200)
+    result = client.translate(['Hello world.', 'See you tomorrow.'],
+                              target_lang='fr', formality='formal')
+    assert result == batch_response
+    body = _last_request_body()
+    assert body == {'key': API_KEY,
+                    'texts': ['Hello world.', 'See you tomorrow.'],
+                    'target_lang': 'fr', 'formality': 'formal'}
+
+
+@responses.activate
+def test_translate_batch_tuple_sent_as_list(client):
+    responses.add(responses.POST, BASE + 'translate',
+                  json={'results': [TRANSLATE_RESPONSE]}, status=200)
+    client.translate(('Hello world.',), target_lang='fr')
+    body = _last_request_body()
+    assert body['texts'] == ['Hello world.']
+    assert 'text' not in body

sapling_py-4.3.0/sapling/version.py

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