approval-utilities 16.0.0__tar.gz

approval_utilities-16.0.0/LICENSE

@@ -0,0 +1,191 @@
+Apache License
+Version 2.0, January 2004
+http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+"License" shall mean the terms and conditions for use, reproduction, and
+distribution as defined by Sections 1 through 9 of this document.
+
+"Licensor" shall mean the copyright owner or entity authorized by the copyright
+owner that is granting the License.
+
+"Legal Entity" shall mean the union of the acting entity and all other entities
+that control, are controlled by, or are under common control with that entity.
+For the purposes of this definition, "control" means (i) the power, direct or
+indirect, to cause the direction or management of such entity, whether by
+contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the
+outstanding shares, or (iii) beneficial ownership of such entity.
+
+"You" (or "Your") shall mean an individual or Legal Entity exercising
+permissions granted by this License.
+
+"Source" form shall mean the preferred form for making modifications, including
+but not limited to software source code, documentation source, and configuration
+files.
+
+"Object" form shall mean any form resulting from mechanical transformation or
+translation of a Source form, including but not limited to compiled object code,
+generated documentation, and conversions to other media types.
+
+"Work" shall mean the work of authorship, whether in Source or Object form, made
+available under the License, as indicated by a copyright notice that is included
+in or attached to the work (an example is provided in the Appendix below).
+
+"Derivative Works" shall mean any work, whether in Source or Object form, that
+is based on (or derived from) the Work and for which the editorial revisions,
+annotations, elaborations, or other modifications represent, as a whole, an
+original work of authorship. For the purposes of this License, Derivative Works
+shall not include works that remain separable from, or merely link (or bind by
+name) to the interfaces of, the Work and Derivative Works thereof.
+
+"Contribution" shall mean any work of authorship, including the original version
+of the Work and any modifications or additions to that Work or Derivative Works
+thereof, that is intentionally submitted to Licensor for inclusion in the Work
+by the copyright owner or by an individual or Legal Entity authorized to submit
+on behalf of the copyright owner. For the purposes of this definition,
+"submitted" means any form of electronic, verbal, or written communication sent
+to the Licensor or its representatives, including but not limited to
+communication on electronic mailing lists, source code control systems, and
+issue tracking systems that are managed by, or on behalf of, the Licensor for
+the purpose of discussing and improving the Work, but excluding communication
+that is conspicuously marked or otherwise designated in writing by the copyright
+owner as "Not a Contribution."
+
+"Contributor" shall mean Licensor and any individual or Legal Entity on behalf
+of whom a Contribution has been received by Licensor and subsequently
+incorporated within the Work.
+
+2. Grant of Copyright License.
+
+Subject to the terms and conditions of this License, each Contributor hereby
+grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free,
+irrevocable copyright license to reproduce, prepare Derivative Works of,
+publicly display, publicly perform, sublicense, and distribute the Work and such
+Derivative Works in Source or Object form.
+
+3. Grant of Patent License.
+
+Subject to the terms and conditions of this License, each Contributor hereby
+grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free,
+irrevocable (except as stated in this section) patent license to make, have
+made, use, offer to sell, sell, import, and otherwise transfer the Work, where
+such license applies only to those patent claims licensable by such Contributor
+that are necessarily infringed by their Contribution(s) alone or by combination
+of their Contribution(s) with the Work to which such Contribution(s) was
+submitted. If You institute patent litigation against any entity (including a
+cross-claim or counterclaim in a lawsuit) alleging that the Work or a
+Contribution incorporated within the Work constitutes direct or contributory
+patent infringement, then any patent licenses granted to You under this License
+for that Work shall terminate as of the date such litigation is filed.
+
+4. Redistribution.
+
+You may reproduce and distribute copies of the Work or Derivative Works thereof
+in any medium, with or without modifications, and in Source or Object form,
+provided that You meet the following conditions:
+
+You must give any other recipients of the Work or Derivative Works a copy of
+this License; and
+You must cause any modified files to carry prominent notices stating that You
+changed the files; and
+You must retain, in the Source form of any Derivative Works that You distribute,
+all copyright, patent, trademark, and attribution notices from the Source form
+of the Work, excluding those notices that do not pertain to any part of the
+Derivative Works; and
+If the Work includes a "NOTICE" text file as part of its distribution, then any
+Derivative Works that You distribute must include a readable copy of the
+attribution notices contained within such NOTICE file, excluding those notices
+that do not pertain to any part of the Derivative Works, in at least one of the
+following places: within a NOTICE text file distributed as part of the
+Derivative Works; within the Source form or documentation, if provided along
+with the Derivative Works; or, within a display generated by the Derivative
+Works, if and wherever such third-party notices normally appear. The contents of
+the NOTICE file are for informational purposes only and do not modify the
+License. You may add Your own attribution notices within Derivative Works that
+You distribute, alongside or as an addendum to the NOTICE text from the Work,
+provided that such additional attribution notices cannot be construed as
+modifying the License.
+You may add Your own copyright statement to Your modifications and may provide
+additional or different license terms and conditions for use, reproduction, or
+distribution of Your modifications, or for any such Derivative Works as a whole,
+provided Your use, reproduction, and distribution of the Work otherwise complies
+with the conditions stated in this License.
+
+5. Submission of Contributions.
+
+Unless You explicitly state otherwise, any Contribution intentionally submitted
+for inclusion in the Work by You to the Licensor shall be under the terms and
+conditions of this License, without any additional terms or conditions.
+Notwithstanding the above, nothing herein shall supersede or modify the terms of
+any separate license agreement you may have executed with Licensor regarding
+such Contributions.
+
+6. Trademarks.
+
+This License does not grant permission to use the trade names, trademarks,
+service marks, or product names of the Licensor, except as required for
+reasonable and customary use in describing the origin of the Work and
+reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty.
+
+Unless required by applicable law or agreed to in writing, Licensor provides the
+Work (and each Contributor provides its Contributions) on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied,
+including, without limitation, any warranties or conditions of TITLE,
+NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are
+solely responsible for determining the appropriateness of using or
+redistributing the Work and assume any risks associated with Your exercise of
+permissions under this License.
+
+8. Limitation of Liability.
+
+In no event and under no legal theory, whether in tort (including negligence),
+contract, or otherwise, unless required by applicable law (such as deliberate
+and grossly negligent acts) or agreed to in writing, shall any Contributor be
+liable to You for damages, including any direct, indirect, special, incidental,
+or consequential damages of any character arising as a result of this License or
+out of the use or inability to use the Work (including but not limited to
+damages for loss of goodwill, work stoppage, computer failure or malfunction, or
+any and all other commercial damages or losses), even if such Contributor has
+been advised of the possibility of such damages.
+
+9. Accepting Warranty or Additional Liability.
+
+While redistributing the Work or Derivative Works thereof, You may choose to
+offer, and charge a fee for, acceptance of support, warranty, indemnity, or
+other liability obligations and/or rights consistent with this License. However,
+in accepting such obligations, You may act only on Your own behalf and on Your
+sole responsibility, not on behalf of any other Contributor, and only if You
+agree to indemnify, defend, and hold each Contributor harmless for any liability
+incurred by, or claims asserted against, such Contributor by reason of your
+accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS
+
+APPENDIX: How to apply the Apache License to your work
+
+To apply the Apache License to your work, attach the following boilerplate
+notice, with the fields enclosed by brackets "[]" replaced with your own
+identifying information. (Don't include the brackets!) The text should be
+enclosed in the appropriate comment syntax for the file format. We also
+recommend that a file or class name and description of purpose be included on
+the same "printed page" as the copyright notice for easier identification within
+third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+     http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

approval_utilities-16.0.0/MANIFEST.in

@@ -0,0 +1,2 @@
+include requirements.prod.txt requirements.prod.extras.txt requirements.prod.required.txt setup/setup_utils.py version.py
+

approval_utilities-16.0.0/PKG-INFO

@@ -0,0 +1,30 @@
+Metadata-Version: 2.4
+Name: approval_utilities
+Version: 16.0.0
+Summary: Utilities for your production code that work well with approvaltests
+Home-page: https://github.com/approvals/ApprovalTests.Python
+Author: ApprovalTests Contributors
+Author-email: llewellyn.falco@gmail.com
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Operating System :: POSIX
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: MacOS :: MacOS X
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Topic :: Utilities
+Requires-Python: >=3.8
+License-File: LICENSE
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: requires-python
+Dynamic: summary

approval_utilities-16.0.0/README.md

@@ -0,0 +1,325 @@
+# ApprovalTests.Python
+
+<!-- toc -->
+## Contents
+
+  * [What can I use ApprovalTests for?](#what-can-i-use-approvaltests-for)
+  * [Getting Started](#getting-started)
+    * [What Are Approvals](#what-are-approvals)
+    * [New Projects](#new-projects)
+      * [Minimal Example Tutorial](#minimal-example-tutorial)
+    * [Adding to Existing Projects](#adding-to-existing-projects)
+  * [Overview](#overview)
+    * [Example using pytest](#example-using-pytest)
+    * [Example using unittest](#example-using-unittest)
+    * [Example using CLI](#example-using-cli)
+      * [Usage](#usage)
+      * [Argument Definitions](#argument-definitions)
+  * [Reporters](#reporters)
+    * [Selecting a Reporter](#selecting-a-reporter)
+    * [JSON file for collection of reporters](#json-file-for-collection-of-reporters)
+  * [Support and Documentation](#support-and-documentation)
+    * [Missing Documentation?](#missing-documentation)
+    * [Dependencies](#dependencies)
+      * [Required dependencies](#required-dependencies)
+      * [Extra dependencies](#extra-dependencies)
+  * [For developers](#for-developers)
+    * [Weekly Ensemble](#weekly-ensemble)
+    * [Pull Requests](#pull-requests)<!-- endToc -->
+
+Capturing Human Intelligence - ApprovalTests is an open source assertion/verification library to aid testing.  
+`approvaltests` is the ApprovalTests port for Python.
+
+For more information see: [www.approvaltests.com](http://approvaltests.com/).
+
+[![PyPI version](https://img.shields.io/pypi/v/approvaltests.svg)](https://pypi.org/project/approvaltests)
+[![Python versions](https://img.shields.io/pypi/pyversions/approvaltests.svg)](https://pypi.org/project/approvaltests)
+[![Build Status](https://github.com/approvals/ApprovalTests.Python/workflows/Test/badge.svg?branch=master)](https://github.com/approvals/ApprovalTests.Python/actions)
+[![Build Status](https://github.com/approvals/ApprovalTests.Python/workflows/on-push-do-doco/badge.svg)](https://github.com/approvals/ApprovalTests.Python/actions?query=workflow%3Aon-push-do-doco)
+[![Build Status](https://github.com/approvals/ApprovalTests.Python/workflows/Upload%20Python%20Package/badge.svg)](https://github.com/approvals/ApprovalTests.Python/actions?query=workflow%3A%22Upload+Python+Package%22)
+[![Discord](https://img.shields.io/discord/1349240939406819409?logo=discord)](https://discord.gg/XDrgy6x6Se)
+
+## What can I use ApprovalTests for?
+
+You can use ApprovalTests to verify objects that require more than a simple assert including long strings, large arrays,
+and complex hash structures and objects. ApprovalTests really shines when you need a more granular look at the test
+failure. Sometimes, trying to find a small difference in a long string printed to STDOUT is just too hard!  
+ApprovalTests solves this problem by providing reporters which let you view the test results in one of many popular diff
+utilities.
+
+## Getting Started
+
+### What Are Approvals
+
+If you need to gain a better understanding or are new to this concept, start [here](https://github.com/approvals/ApprovalTests.Documentation/blob/main/explanations/what_are_approvals.md).
+
+### New Projects
+
+If you are starting a new project, we suggest you use the [Starter Project](https://github.com/approvals/ApprovalTests.Python.StarterProject).
+You can just clone this and go. It's great for exercises, katas, and green field projects.
+
+#### Minimal Example Tutorial
+
+If this is first time approvaltesting in python, consider starting here: [Minimal Example Tutorial](docs/tutorial/minimal-example.md)
+
+### Adding to Existing Projects
+
+From [pypi](https://pypi.org/project/approvaltests/):
+
+    pip install approvaltests
+
+## Overview
+
+Approvals work by comparing the test results to a golden master. If no golden master exists you can create a snapshot
+of the current test results and use that as the golden master. The reporter helps you manage the golden master.  
+Whenever your current results differ from the golden master, Approvals will launch an external application for you to
+examine the differences. Either you will update the master because you expected the changes and they are good,
+or you will go back to your code and update or roll back your changes to get your results back in line with the
+golden master.
+
+### Example using pytest
+
+<!-- snippet: getting_started_with_pytest.py -->
+<a id='snippet-getting_started_with_pytest.py'></a>
+```py
+from approvaltests.approvals import verify
+
+
+def test_simple() -> None:
+    result = "Hello ApprovalTests"
+    verify(result)
+```
+<sup><a href='/tests/examples/getting_started_with_pytest.py#L1-L6' title='Snippet source file'>snippet source</a> | <a href='#snippet-getting_started_with_pytest.py' title='Start of snippet'>anchor</a></sup>
+<!-- endSnippet -->
+
+Install the plugin pytest-approvaltests and use it to select a reporter:
+
+    pip install pytest-approvaltests
+    pytest --approvaltests-use-reporter='PythonNative'
+
+The reporter is used both to alert you to changes in your test output, and to provide a tool to update the golden
+master. In this snippet, we chose the 'PythonNative' reporter when we ran the tests. For more information about selecting
+reporters see [the documentation](https://github.com/approvals/ApprovalTests.Python.PytestPlugin)
+
+### Example using unittest
+
+<!-- snippet: getting_started_with_unittest.py -->
+<a id='snippet-getting_started_with_unittest.py'></a>
+```py
+import unittest
+
+from approvaltests.approvals import verify
+
+
+class GettingStartedTest(unittest.TestCase):
+    def test_simple(self) -> None:
+        verify("Hello ApprovalTests")
+
+
+if __name__ == "__main__":
+    unittest.main()
+```
+<sup><a href='/tests/examples/getting_started_with_unittest.py#L1-L12' title='Snippet source file'>snippet source</a> | <a href='#snippet-getting_started_with_unittest.py' title='Start of snippet'>anchor</a></sup>
+<!-- endSnippet -->
+
+This example has the same behaviour as the pytest version, but uses the built-in test framework `unittest` instead.
+
+### Example using CLI
+
+You can invoke a verify() call from the command line. This allows invoking python approvals from any other stack via subprocesses.
+
+#### Usage
+
+```
+python -m approvaltests --test-id hello --received "hello world!"
+```
+
+or
+
+```
+python -m approvaltests -t hello -r "hello world!"
+```
+
+or
+
+```
+echo "hello world!" | python -m approvaltests -t hello
+```
+
+#### Argument Definitions
+
+-   **`--test-id`** or **`-t`**: Test identifier used to name the `approved.txt` and `received.txt` files for the test.
+
+-   **`--received`** or **`-r`**: The output of the program under test (a string) that is passed to the verify method.
+
+    -   **`stdin`**: Instead of providing a `received` argument, you may use `stdin`.
+
+## Reporters
+
+### Selecting a Reporter
+
+All verify functions take an optional `options` parameter that can configure reporters (as well as many other aspects).
+
+ApprovalTests.Python comes with a few reporters configured, supporting Linux, Mac OSX, and Windows.
+
+In the example shown below, we pass in an options with a reporter we're selecting directly:
+
+<!-- snippet: select_reporter_from_class -->
+<a id='snippet-select_reporter_from_class'></a>
+```py
+class TestSelectReporterFromClass(unittest.TestCase):
+    def test_simple(self):
+        verify("Hello", options=Options().with_reporter(report_with_beyond_compare()))
+```
+<sup><a href='/tests/samples/test_getting_started.py#L28-L34' title='Snippet source file'>snippet source</a> | <a href='#snippet-select_reporter_from_class' title='Start of snippet'>anchor</a></sup>
+<!-- endSnippet -->
+
+You can also use the `GenericDiffReporterFactory` to find and select the first diff utility that exists on our system.
+
+An advantage of this method is you can modify the reporters.json file directly to handle your unique system.
+
+<!-- snippet: select_reporter_from_factory -->
+<a id='snippet-select_reporter_from_factory'></a>
+```py
+class TestSelectReporter(unittest.TestCase):
+    @override
+    def setUp(self):
+        self.factory = GenericDiffReporterFactory()
+
+    def test_simple(self):
+        verify(
+            "Hello", options=Options().with_reporter(self.factory.get("BeyondCompare"))
+        )
+```
+<sup><a href='/tests/samples/test_getting_started.py#L13-L25' title='Snippet source file'>snippet source</a> | <a href='#snippet-select_reporter_from_factory' title='Start of snippet'>anchor</a></sup>
+<!-- endSnippet -->
+
+Or you can build your own GenericDiffReporter on the fly
+
+<!-- snippet: custom_generic_diff_reporter -->
+<a id='snippet-custom_generic_diff_reporter'></a>
+```py
+class GettingStartedTest(unittest.TestCase):
+    def test_simple(self):
+        verify(
+            "Hello",
+            options=Options().with_reporter(
+                GenericDiffReporter.create(r"C:\my\favorite\diff\utility.exe")
+            ),
+        )
+```
+<sup><a href='/tests/samples/test_getting_started.py#L37-L48' title='Snippet source file'>snippet source</a> | <a href='#snippet-custom_generic_diff_reporter' title='Start of snippet'>anchor</a></sup>
+<!-- endSnippet -->
+
+As long as `C:/my/favorite/diff/utility.exe` can be invoked from the command line using the format `utility.exe file1 file2`
+then it will be compatible with GenericDiffReporter. Otherwise you will have to derive your own reporter, which
+we won't cover here.
+
+### JSON file for collection of reporters
+
+To wrap things up, I should note that you can completely replace the collection of reporters known to the reporter
+factory by writing your own JSON file and loading it.
+
+For example if you had `C:/myreporters.json`
+
+```json
+[
+    ["BeyondCompare4", "C:/Program Files (x86)/Beyond Compare 4/BCompare.exe"],
+    ["WinMerge", "C:/Program Files (x86)/WinMerge/WinMergeU.exe"],
+    ["Tortoise", "C:/Program Files (x86)/TortoiseSVN/bin/tortoisemerge.exe"]
+]
+```
+
+You could then use that file by loading it into the factory:
+
+```python
+
+import unittest
+
+from approvaltests.approvals import verify
+from approvaltests.reporters.generic_diff_reporter_factory import GenericDiffReporterFactory
+
+
+class GettingStartedTest(unittest.TestCase):
+    def setUp(self):
+        factory = GenericDiffReporterFactory()
+        factory.load('C:/myreporters.json')
+        self.reporter = factory.get_first_working()
+
+    def test_simple(self):
+        verify('Hello', self.reporter)
+
+if __name__ == "__main__":
+    unittest.main()
+```
+
+Of course, if you have some interesting new reporters in `myreporters.json` then please consider updating the
+`reporters.json` file that ships with Approvals and submitting a pull request.
+
+## Support and Documentation
+
+-   [Documentation](/docs/README.md)
+
+-   GitHub: [https://github.com/approvals/ApprovalTests.Python](https://github.com/approvals/ApprovalTests.Python)
+
+-   ApprovalTests Homepage: [http://www.approvaltests.com](http://www.approvaltests.com)
+
+### Missing Documentation?
+
+If there is documentation you wish existed, please add a `page request` to [this issue](https://github.com/approvals/ApprovalTests.Python/issues/135).
+
+### Dependencies
+
+ApprovalTests is tested on the following Python versions: 3.8, 3.9, 3.10, 3.11, 3.12, 3.13, 3.14.<!-- singleLineInclude: tests/approved_files/test_workflow_matrix.test_workflow_matrix_python_versions.approved.txt -->
+
+ApprovalTests requires the following dependencies:
+
+#### Required dependencies
+
+These dependencies are always required for approvaltests
+
+<!-- snippet: requirements.prod.required.txt -->
+<a id='snippet-requirements.prod.required.txt'></a>
+```txt
+pytest>=4.0.0
+empty-files>=0.0.3
+typing_extensions>=3.6.2
+```
+<sup><a href='/requirements.prod.required.txt#L1-L5' title='Snippet source file'>snippet source</a> | <a href='#snippet-requirements.prod.required.txt' title='Start of snippet'>anchor</a></sup>
+<!-- endSnippet -->
+
+#### Extra dependencies
+
+These dependencies are required if you are going to use the related functionality.  
+If you want the bare minimum you can use the pypi project
+[approvaltests-minimal](https://pypi.org/project/approvaltests-minimal/).
+
+<!-- snippet: requirements.prod.extras.txt -->
+<a id='snippet-requirements.prod.extras.txt'></a>
+```txt
+pyperclip>=1.5.29     # For Clipboard Reporter
+beautifulsoup4>=4.4.0 # For verify_html
+allpairspy>=2.1.0     # For PairwiseCombinations
+testfixtures >= 7.1.0 # For verify_logging
+mock >= 5.1.0         # For verify_logging
+```
+<sup><a href='/requirements.prod.extras.txt#L1-L5' title='Snippet source file'>snippet source</a> | <a href='#snippet-requirements.prod.extras.txt' title='Start of snippet'>anchor</a></sup>
+<!-- endSnippet -->
+
+## For developers
+
+### Weekly Ensemble
+
+The best way to contribute is to [join our weekly mob/ensemble](./docs/Contribute.md).
+
+### Pull Requests
+
+Pull requests are welcomed, particularly those accompanied by automated tests.
+
+To run the self-tests:
+`./build_and_test.sh`
+
+This will run the self-tests on several python versions. We support python 3.8 and above.
+
+All pull requests will be pre-checked using GitHub actions to execute all these tests. You can see the [results of test
+runs here](https://github.com/approvals/ApprovalTests.Python/actions).

approval_utilities-16.0.0/approval_utilities/approvaltests/core/executable_command.py

@@ -0,0 +1,17 @@
+from abc import ABC, abstractmethod
+
+
+class CommandGetter(ABC):
+    @abstractmethod
+    def get_command(self) -> str:
+        raise NotImplementedError("Interface member not implemented")
+
+
+class CommandExecutor(ABC):
+    @abstractmethod
+    def execute_command(self, command: str) -> str:
+        raise NotImplementedError("Interface member not implemented")
+
+
+class ExecutableCommand(CommandGetter, CommandExecutor):
+    pass

approval_utilities-16.0.0/approval_utilities/approvaltests/core/verifiable.py

@@ -0,0 +1,10 @@
+from abc import ABC, abstractmethod
+
+from approval_utilities.approvaltests.core.verify_parameters import VerifyParameters
+from approvaltests.core.options import Options
+
+
+class Verifiable(ABC):
+    @abstractmethod
+    def get_verify_parameters(self, options: "Options") -> VerifyParameters:
+        pass

approval_utilities-16.0.0/approval_utilities/approvaltests/core/verify_parameters.py

@@ -0,0 +1,9 @@
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from approvaltests.core.options import Options
+
+
+class VerifyParameters:
+    def __init__(self, options: "Options"):
+        self.options = options

approval_utilities-16.0.0/approval_utilities/list_utils.py

@@ -0,0 +1,20 @@
+from typing import Any, Callable, List, Optional
+
+
+def format_list(alist: List[Any], formatter: Optional[Callable], header: str) -> str:
+    if formatter is None:
+        formatter = FormatLineItem().print_item
+    text = (header + "\n\n") if header else ""
+    for i in alist:
+        text += formatter(i) + "\n"
+    return text
+
+
+class FormatLineItem:
+    def __init__(self) -> None:
+        self.index = 0
+
+    def print_item(self, item: Any) -> str:
+        text = str(self.index) + ") " + str(item)
+        self.index += 1
+        return text

approval_utilities-16.0.0/approval_utilities/utilities/clipboard_utilities.py

@@ -0,0 +1,7 @@
+def copy_to_clipboard(text: str) -> None:
+    """
+    This acts as a wrapper to defer the importing of pyperclip util actual usage
+    """
+    import pyperclip  # type ignore
+
+    pyperclip.copy(text)

approval_utilities-16.0.0/approval_utilities/utilities/deprecated.py

@@ -0,0 +1,25 @@
+import functools
+import warnings
+from typing import Callable
+
+
+def deprecated(reason: str) -> Callable:
+    def decorator(func: Callable) -> Callable:
+        """This is a decorator which can be used to mark functions
+        as deprecated. It will result in a warning being emitted
+        when the function is used."""
+
+        @functools.wraps(func)
+        def new_func(*args, **kwargs):
+            warnings.simplefilter("always", DeprecationWarning)  # turn off filter
+            warnings.warn(
+                f"Call to deprecated function {func.__name__}. {reason}",
+                category=DeprecationWarning,
+                stacklevel=2,
+            )
+            warnings.simplefilter("default", DeprecationWarning)  # reset filter
+            return func(*args, **kwargs)
+
+        return new_func
+
+    return decorator