cpf-dv 1.0.0__py3-none-any.whl

cpf_dv/__init__.py

@@ -0,0 +1,19 @@
+from .cpf_check_digits import CpfCheckDigits
+from .exceptions import (
+    CpfCheckDigitsCalculationError,
+    CpfCheckDigitsError,
+    CpfCheckDigitsInputLengthError,
+    CpfCheckDigitsInputNotValidError,
+    CpfCheckDigitsInputTypeError,
+)
+
+__all__ = [
+    "CpfCheckDigits",
+    "CpfCheckDigitsCalculationError",
+    "CpfCheckDigitsError",
+    "CpfCheckDigitsInputLengthError",
+    "CpfCheckDigitsInputNotValidError",
+    "CpfCheckDigitsInputTypeError",
+]
+
+__version__ = "1.0.0"

cpf_dv/cpf_check_digits.py

@@ -0,0 +1,154 @@
+import re
+
+from .exceptions import (
+    CpfCheckDigitsCalculationError,
+    CpfCheckDigitsInputLengthError,
+    CpfCheckDigitsInputNotValidError,
+    CpfCheckDigitsInputTypeError,
+)
+
+CPF_MIN_LENGTH = 9
+CPF_MAX_LENGTH = 11
+
+
+class CpfCheckDigits:
+    """Class to calculate CPF check digits."""
+
+    __slots__ = ("_cpf_digits", "_first_digit", "_second_digit")
+
+    def __init__(self, cpf_input: str | list[str] | list[int]) -> None:
+        original_input = cpf_input
+
+        if not isinstance(cpf_input, (str, list)):
+            raise CpfCheckDigitsInputTypeError(original_input)
+
+        if isinstance(cpf_input, str):
+            cpf_input = self._handle_string_input(cpf_input)
+        else:
+            cpf_input = self._handle_list_input(cpf_input, original_input)
+
+        self._validate_length(cpf_input, original_input)
+        self._validate_non_repeated_digits(cpf_input, original_input)
+
+        self._cpf_digits = cpf_input[:CPF_MIN_LENGTH]
+        self._first_digit: int | None = None
+        self._second_digit: int | None = None
+
+    @property
+    def first_digit(self) -> int:
+        """Calculates and returns the first check digit.As it's immutable, it caches the calculation result."""
+        if self._first_digit is None:
+            base_digits_sequence = self._cpf_digits.copy()
+            self._first_digit = self._calculate(base_digits_sequence)
+
+        return self._first_digit
+
+    @property
+    def second_digit(self) -> int:
+        """Calculates and returns the second check digit.As it's immutable, it caches the calculation result. And, as it depends on the first check digit, it's also calculated."""
+        if self._second_digit is None:
+            base_digits_sequence = [*self._cpf_digits, self.first_digit]
+            self._second_digit = self._calculate(base_digits_sequence)
+
+        return self._second_digit
+
+    def to_list(self) -> list[int]:
+        """Returns the complete CPF as a list of 11 integers (9 base digits + 2 check digits)."""
+        return [*self._cpf_digits, self.first_digit, self.second_digit]
+
+    def to_string(self) -> str:
+        """Returns the complete CPF as a string of 11 digits (9 base digits + 2 check digits)."""
+        return "".join(str(digit) for digit in self.to_list())
+
+    def _handle_string_input(self, cpf_string: str) -> list[int]:
+        """When CPF is provided as a string, it is sanitized, validated and converted to a list of integers."""
+        digits_only_string = re.sub(r"[^0-9]", "", cpf_string)
+
+        return [int(digit_string) for digit_string in digits_only_string]
+
+    def _handle_list_input(
+        self,
+        cpf_list: list[str] | list[int],
+        original_input: list,
+    ) -> list[int]:
+        """When CPF is provided as a list of strings or integers, it is sanitized, validated and converted to a list of integers for further processing."""
+        if all(isinstance(digit, str) for digit in cpf_list):
+            return self._handle_string_list_input(cpf_list)
+
+        if all(isinstance(digit, int) for digit in cpf_list):
+            return self._flatten_digits(cpf_list)
+
+        raise CpfCheckDigitsInputTypeError(original_input)
+
+    def _handle_string_list_input(self, cpf_string_list: list[str]) -> list[int]:
+        """When CPF is provided as a list of strings, it is sanitized, validated and converted to a list of integers for further processing."""
+        final_cpf_int_list = []
+
+        for list_item in cpf_string_list:
+            cpf_int_list = self._handle_string_input(list_item)
+            final_cpf_int_list.extend(cpf_int_list)
+
+        return final_cpf_int_list
+
+    def _flatten_digits(self, int_list: list[int]) -> list[int]:
+        """Breaks down multiple digits within the array into individual ones. Negative numbers are converted to their absolute value."""
+        final_cpf_int_list = []
+
+        for number in int_list:
+            abs_number = abs(number)
+            final_cpf_int_list.extend(
+                [int(digit_string) for digit_string in str(abs_number)]
+            )
+
+        return final_cpf_int_list
+
+    def _validate_length(
+        self,
+        cpf_int_list: list[int],
+        original_input: str | list[str] | list[int],
+    ) -> None:
+        """Validates the length of the CPF digits."""
+        digits_count = len(cpf_int_list)
+
+        if digits_count < CPF_MIN_LENGTH or digits_count > CPF_MAX_LENGTH:
+            raise CpfCheckDigitsInputLengthError(
+                original_input,
+                "".join(str(digit) for digit in cpf_int_list),
+                CPF_MIN_LENGTH,
+                CPF_MAX_LENGTH,
+            )
+
+    def _validate_non_repeated_digits(
+        self,
+        cpf_int_list: list[int],
+        original_input: str | list[str] | list[int],
+    ) -> None:
+        """Validates that the CPF digits are not all the same."""
+        eligible_cpf_int_list = cpf_int_list[:CPF_MIN_LENGTH]
+        digits_set = set(eligible_cpf_int_list)
+
+        if len(digits_set) == 1:
+            raise CpfCheckDigitsInputNotValidError(
+                original_input,
+                "Repeated digits are not considered valid.",
+            )
+
+    def _calculate(self, cpf_sequence: list[int]) -> int:
+        """Calculates the CPF check digits using the official Brazilian algorithm. For the first check digit, it uses the digits 1 through 9 of the CPF base. For the second one, it uses the digits 1 through 10 (with the first check digit)."""
+        min_length = CPF_MIN_LENGTH
+        max_length = CPF_MAX_LENGTH - 1
+        sequence_length = len(cpf_sequence)
+
+        if sequence_length < min_length or sequence_length > max_length:
+            raise CpfCheckDigitsCalculationError(cpf_sequence)
+
+        factor = sequence_length + 1
+        sum_result = 0
+
+        for num in cpf_sequence:
+            sum_result += num * factor
+            factor -= 1
+
+        remainder = 11 - (sum_result % 11)
+
+        return 0 if remainder > 9 else remainder

cpf_dv/exceptions.py

@@ -0,0 +1,71 @@
+class CpfCheckDigitsError(Exception):
+    """Base exception for all cpf-dv related errors."""
+
+
+class CpfCheckDigitsInputTypeError(CpfCheckDigitsError):
+    """Raised when the class input does not match the expected type."""
+
+    def __init__(self, actual_input) -> None:
+        self.actual_input = actual_input
+
+        super().__init__(
+            f"CPF input must be of type str, list[str] or list[int]. Got {type(actual_input).__name__}."
+        )
+
+
+class CpfCheckDigitsInputLengthError(CpfCheckDigitsError):
+    """Raised when the class input does not contain the expected number of digits."""
+
+    def __init__(
+        self,
+        actual_input: str | list[str] | list[int],
+        evaluated_input: str,
+        min_expected_length: int,
+        max_expected_length: int,
+    ) -> None:
+        self.actual_input = actual_input
+        self.evaluated_input = evaluated_input
+        self.min_expected_length = min_expected_length
+        self.max_expected_length = max_expected_length
+
+        if isinstance(actual_input, str):
+            fmt_actual_input = f'"{actual_input}"'
+        else:
+            fmt_actual_input = f"{actual_input}"
+
+        if actual_input == evaluated_input:
+            fmt_evaluated_input = f"{len(evaluated_input)}"
+        else:
+            fmt_evaluated_input = f'{len(evaluated_input)} in "{evaluated_input}"'
+
+        super().__init__(
+            f"CPF input {fmt_actual_input} does not contain "
+            f"{min_expected_length} to {max_expected_length} digits. "
+            f"Got {fmt_evaluated_input}."
+        )
+
+
+class CpfCheckDigitsInputNotValidError(CpfCheckDigitsError):
+    """Raised when the class input is not valid (e.g., repeated digits)."""
+
+    def __init__(self, actual_input: str | list[str] | list[int], reason: str) -> None:
+        self.actual_input = actual_input
+        self.reason = reason
+
+        if isinstance(actual_input, str):
+            fmt_actual_input = f'"{actual_input}"'
+        else:
+            fmt_actual_input = f"{actual_input}"
+
+        super().__init__(f"CPF input {fmt_actual_input} is invalid. {reason}")
+
+
+class CpfCheckDigitsCalculationError(CpfCheckDigitsError):
+    """Raised when the calculation of the CPF check digits fails."""
+
+    def __init__(self, actual_input: list[int]) -> None:
+        self.actual_input = actual_input
+
+        super().__init__(
+            f"Failed to calculate CPF check digits for the sequence: {actual_input}."
+        )

cpf_dv-1.0.0.dist-info/METADATA

@@ -0,0 +1,327 @@
+Metadata-Version: 2.4
+Name: cpf-dv
+Version: 1.0.0
+Summary: Utility resources to calculate check digits on CPF (Brazilian personal ID)
+Author: Julio L. Muller
+License-Expression: MIT
+Project-URL: Homepage, https://cnpj-utils.vercel.app/
+Project-URL: Source, https://github.com/LacusSolutions/br-utils-py
+Project-URL: Tracker, https://github.com/LacusSolutions/br-utils-py/issues
+Keywords: cpf,verificar,verificador,verify,verification,check,check-digit,check-digits,pt-br,br
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: Natural Language :: English
+Classifier: Natural Language :: Portuguese (Brazilian)
+Classifier: Operating System :: MacOS :: MacOS X
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: POSIX
+Classifier: Operating System :: Unix
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Topic :: Utilities
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+![cpf-dv for Python](https://br-utils.vercel.app/img/cover_cpf-dv.jpg)
+
+[![PyPI Version](https://img.shields.io/pypi/v/cpf-dv)](https://pypi.org/project/cpf-dv)
+[![PyPI Downloads](https://img.shields.io/pypi/dm/cpf-dv)](https://pypi.org/project/cpf-dv)
+[![Python Version](https://img.shields.io/pypi/pyversions/cpf-dv)](https://www.python.org/)
+[![Test Status](https://img.shields.io/github/actions/workflow/status/LacusSolutions/br-utils-py/ci.yml?label=ci/cd)](https://github.com/LacusSolutions/br-utils-py/actions)
+[![Last Update Date](https://img.shields.io/github/last-commit/LacusSolutions/br-utils-py)](https://github.com/LacusSolutions/br-utils-py)
+[![Project License](https://img.shields.io/github/license/LacusSolutions/br-utils-py)](https://github.com/LacusSolutions/br-utils-py/blob/main/LICENSE)
+
+Utility class to calculate check digits on CPF (Brazilian individual taxpayer ID).
+
+## Python Support
+
+| ![Python 3.10](https://img.shields.io/badge/Python-3.10-3776AB?logo=python&logoColor=white) | ![Python 3.11](https://img.shields.io/badge/Python-3.11-3776AB?logo=python&logoColor=white) | ![Python 3.12](https://img.shields.io/badge/Python-3.12-3776AB?logo=python&logoColor=white) | ![Python 3.13](https://img.shields.io/badge/Python-3.13-3776AB?logo=python&logoColor=white) | ![Python 3.14](https://img.shields.io/badge/Python-3.14-3776AB?logo=python&logoColor=white) |
+|--- | --- | --- | --- | --- |
+| Passing ✔ | Passing ✔ | Passing ✔ | Passing ✔ | Passing ✔ |
+
+## Installation
+
+```bash
+$ pip install cpf-dv
+```
+
+## Import
+
+```python
+from cpf_dv import CpfCheckDigits
+```
+
+## Usage
+
+### Basic Usage
+
+```python
+# Calculate check digits from a 9-digit CPF base
+check_digits = CpfCheckDigits("054496519")
+
+print(check_digits.first_digit)    # returns 1
+print(check_digits.second_digit)   # returns 0
+print(check_digits.to_string())    # returns '05449651910'
+print(check_digits.to_list())      # returns [0, 5, 4, 4, 9, 6, 5, 1, 9, 1, 0]
+```
+
+### Input Formats
+
+The `CpfCheckDigits` class accepts multiple input formats:
+
+#### String Input
+
+```python
+# Plain string (non-numeric characters are automatically stripped)
+check_digits = CpfCheckDigits("054496519")
+check_digits = CpfCheckDigits("054.496.519-10")  # formatting is ignored
+check_digits = CpfCheckDigits("054496519")        # 9 digits
+check_digits = CpfCheckDigits("05449651910")     # 11 digits (only first 9 are used)
+```
+
+#### List of Strings
+
+```python
+# List of single-character strings
+check_digits = CpfCheckDigits(["0", "5", "4", "4", "9", "6", "5", "1", "9"])
+
+# List with multi-digit strings (automatically flattened)
+check_digits = CpfCheckDigits(["054496519"])      # flattens to individual digits
+check_digits = CpfCheckDigits(["054", "496", "519"])  # also flattens
+```
+
+#### List of Integers
+
+```python
+# List of single-digit integers
+check_digits = CpfCheckDigits([1, 2, 3, 4, 5, 6, 7, 8, 9])
+
+# List with multi-digit integers (automatically flattened)
+check_digits = CpfCheckDigits([123456789])         # flattens to individual digits
+check_digits = CpfCheckDigits([123, 456, 789])     # also flattens
+
+### Properties
+
+#### `first_digit: int`
+
+Returns the first check digit (10th digit of the CPF).
+
+```python
+check_digits = CpfCheckDigits("054496519")
+print(check_digits.first_digit)  # returns 1
+```
+
+#### `second_digit: int`
+
+Returns the second check digit (11th digit of the CPF).
+
+```python
+check_digits = CpfCheckDigits("054496519")
+print(check_digits.second_digit)  # returns 0
+```
+
+### Methods
+
+#### `to_list() -> list[int]`
+
+Returns the complete CPF as a list of integers (9 base digits + 2 check digits).
+
+```python
+check_digits = CpfCheckDigits("054496519")
+print(check_digits.to_list())  # returns [0, 5, 4, 4, 9, 6, 5, 1, 9, 1, 0]
+```
+
+#### `to_string() -> str`
+
+Returns the complete CPF as a string (9 base digits + 2 check digits).
+
+```python
+check_digits = CpfCheckDigits("054496519")
+print(check_digits.to_string())  # returns '05449651910'
+```
+
+### Examples
+
+```python
+from cpf_dv import CpfCheckDigits
+
+# Calculate check digits for a CPF base
+base = "054496519"
+check_digits = CpfCheckDigits(base)
+
+# Get individual check digits
+first = check_digits.first_digit    # 1
+second = check_digits.second_digit   # 0
+
+# Get complete CPF
+complete = check_digits.to_string()  # '05449651910'
+
+# Work with formatted input
+formatted = CpfCheckDigits("054.496.519-10")
+print(formatted.to_string())  # '05449651910'
+
+# Work with list input
+list_input = CpfCheckDigits([0, 5, 4, 4, 9, 6, 5, 1, 9])
+print(list_input.to_string())  # '05449651910'
+```
+
+## Error Handling
+
+The package raises specific exceptions for different error scenarios:
+
+### `CpfCheckDigitsInputTypeError`
+
+Raised when the input type is not supported (must be `str`, `list[str]`, or `list[int]`).
+
+```python
+from cpf_dv import CpfCheckDigits, CpfCheckDigitsInputTypeError
+
+try:
+    CpfCheckDigits(12345678901)  # int not allowed
+except CpfCheckDigitsInputTypeError as e:
+    print(e)  # CPF input must be of type str, list[str] or list[int]. Got int.
+```
+
+### `CpfCheckDigitsInputLengthError`
+
+Raised when the input does not contain 9 to 11 digits.
+
+```python
+from cpf_dv import CpfCheckDigits, CpfCheckDigitsInputLengthError
+
+try:
+    CpfCheckDigits("12345678")  # only 8 digits
+except CpfCheckDigitsInputLengthError as e:
+    print(e)  # CPF input "12345678" does not contain 9 to 11 digits. Got 8 in "12345678".
+```
+
+### `CpfCheckDigitsInputNotValidError`
+
+Raised when the input is forbidden for some restriction, like repeated digits like `111.111.111`, `222.222.222`, `333.333.333` and so on.
+
+```python
+from cpf_dv import CpfCheckDigits, CpfCheckDigitsInputNotValidError
+
+try:
+    CpfCheckDigits(["999", "999", "999"])
+except CpfCheckDigitsInputNotValidError as e:
+    print(e)  # CPF input ['999', '999', '999'] is invalid. Repeated digits are not considered valid.
+```
+
+### Catch any error from the package
+
+All errors extend from a common error instance `CpfCheckDigitsError`, so you can use this type to handle any error thrown by the module.
+
+```python
+from cpf_dv import CpfCheckDigitsError
+
+try:
+  # some risky code run
+except CpfCheckDigitsError as e:
+  # do something
+```
+
+## Features
+
+- ✅ **Multiple Input Formats**: Accepts strings, lists of strings, or lists of integers
+- ✅ **Format Agnostic**: Automatically strips non-numeric characters from string input
+- ✅ **Auto-Expansion**: Automatically expands multi-digit numbers in lists to individual digits
+- ✅ **Lazy Evaluation**: Check digits are calculated only when accessed (via properties)
+- ✅ **Type Safety**: Built with Python 3.10+ type hints
+- ✅ **Zero Dependencies**: No external dependencies required
+- ✅ **Comprehensive Error Handling**: Specific exceptions for different error scenarios
+
+## API Reference
+
+### CpfCheckDigits Class
+
+#### Constructor
+
+```python
+CpfCheckDigits(cpf_digits: str | list[str] | list[int]) -> CpfCheckDigits
+```
+
+Creates a new `CpfCheckDigits` instance from the provided CPF base digits.
+
+**Parameters:**
+- `cpf_digits` (str | list[str] | list[int]): The CPF base digits (9-11 digits). Can be:
+  - A string with 9-11 digits (formatting characters are ignored)
+  - A list of strings (each string can be a single digit or multi-digit number)
+  - A list of integers (each integer can be a single digit or multi-digit number)
+
+**Raises:**
+- `CpfCheckDigitsInputTypeError`: If the input type is not supported
+- `CpfCheckDigitsInputLengthError`: If the input does not contain 9-11 digits
+
+**Returns:**
+- `CpfCheckDigits`: A new instance ready to calculate check digits
+
+#### Properties
+
+##### `first_digit: int`
+
+The first check digit (10th digit of the CPF). Calculated lazily on first access.
+
+##### `second_digit: int`
+
+The second check digit (11th digit of the CPF). Calculated lazily on first access.
+
+#### Methods
+
+##### `to_list() -> list[int]`
+
+Returns the complete CPF as a list of 11 integers (9 base digits + 2 check digits).
+
+##### `to_string() -> str`
+
+Returns the complete CPF as a string of 11 digits (9 base digits + 2 check digits).
+
+## Calculation Algorithm
+
+The package calculates CPF check digits using the official Brazilian algorithm:
+
+1. **First Check Digit (10th position)**:
+   - Uses digits 1-9 of the CPF base
+   - Applies weights: 10, 9, 8, 7, 6, 5, 4, 3, 2 (from left to right)
+   - Calculates: `sum(digit × weight) % 11`
+   - Result: `0` if remainder > 9, otherwise `11 - remainder`
+
+2. **Second Check Digit (11th position)**:
+   - Uses digits 1-9 + first check digit
+   - Applies weights: 11, 10, 9, 8, 7, 6, 5, 4, 3, 2 (from left to right)
+   - Calculates: `sum(digit × weight) % 11`
+   - Result: `0` if remainder > 9, otherwise `11 - remainder`
+
+## Dependencies
+
+- **Python**: >= 3.10
+
+No external dependencies required.
+
+## Contribution & Support
+
+We welcome contributions! Please see our [Contributing Guidelines](https://github.com/LacusSolutions/br-utils-py/blob/main/CONTRIBUTING.md) for details. But if you find this project helpful, please consider:
+
+- ⭐ Starring the repository
+- 🤝 Contributing to the codebase
+- 💡 [Suggesting new features](https://github.com/LacusSolutions/br-utils-py/issues)
+- 🐛 [Reporting bugs](https://github.com/LacusSolutions/br-utils-py/issues)
+
+## License
+
+This project is licensed under the MIT License - see the [LICENSE](https://github.com/LacusSolutions/br-utils-py/blob/main/LICENSE) file for details.
+
+## Changelog
+
+See [CHANGELOG](https://github.com/LacusSolutions/br-utils-py/blob/main/packages/cpf-dv/CHANGELOG.md) for a list of changes and version history.
+
+---
+
+Made with ❤️ by [Lacus Solutions](https://github.com/LacusSolutions)

cpf_dv-1.0.0.dist-info/RECORD

@@ -0,0 +1,8 @@
+cpf_dv/__init__.py,sha256=q9yjXOcCXevAco_TgAXX6dhBWiZ4ofjVZTS7ksgiHZE,481
+cpf_dv/cpf_check_digits.py,sha256=80x7n-Q_W_hZyxFBBKIN_lBOr1DeBAvWZ7WtTcAiiJM,5949
+cpf_dv/exceptions.py,sha256=blguXSbznmVFgtB_g5HXI-4SbHQOEBRQ7H0XnHFPCBE,2455
+cpf_dv-1.0.0.dist-info/licenses/LICENSE,sha256=6Q_pGT36dadTRTG16NLBYQGLRaiWtZ2DA3kwzd_32nk,1072
+cpf_dv-1.0.0.dist-info/METADATA,sha256=bnkDonYEu8pLaOVhNC45Fw17alqywyJ9O3M7CQImgbo,10966
+cpf_dv-1.0.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+cpf_dv-1.0.0.dist-info/top_level.txt,sha256=vgQZHkvUD0YCyUyQ-YhOYdH2flcdyCjRsK1w_TXiXmo,7
+cpf_dv-1.0.0.dist-info/RECORD,,

cpf_dv-1.0.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

cpf_dv-1.0.0.dist-info/licenses/LICENSE

@@ -0,0 +1,9 @@
+MIT License
+
+Copyright (c) 2025 Julio L. Muller
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

cpf_dv-1.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+cpf_dv