- improve project info

- add MIT license
- improve readme

Author: RootLUG

LICENSE.txt

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

README.md

@@ -1,7 +1,7 @@
-fassert: Fuzzy assert
+^fassert$: Fuzzy assert
 ---------------------
 
-Assert in your tests only a subset of data that matters
+Fuzzy assert in your tests only a subset of data that matters
 
 ```
 from fassert import fassert
@@ -18,20 +18,75 @@ fassert(
 ) # key2: value2 is ignored as it's not defined in the template
 
 fassert(
-    {"key": "value"},
+    {"key": "value", "abc": "value"},
     # You can nest and combine the fuzzy matching types in containers
     {re.compile(r"[a-z]{3}"): "value"}
 )
 
+fassert(
+    [1, {"very": {"nested": {"dictionary": "data"}}}, {"not": "this"}],
+    # Isn't this cool?
+    [{"very": {re.compile(".{6}"): {"dictionary": lambda x: len(x) == 4}}}]
+)
+
 # Template can contain callables as well
 fassert("value", lambda x: x == "value")
 
 try:
+    fassert("expected", "to not match")
     fassert({"a": "b"}, {"c": "d"})  # This will fail, {"c":"d"} is not in the target data
+    fassert([1, 2, 3], [4])
+    fassert("string", b"string")  # bytes != string in fassert
 except AssertionError:
     pass  # All the examples within the try block above will raise this exception
 ```
 
 In fassert, you can define a template to match your data against.
 When you use a type that is a container (e.g. list, tuple, dict, etc...), then only the data that you defined in the template will be asserted.
 All the addition data in the container will be ignored
+
+Did you know this project is also dedicated to have **0 dependencies** on other packages?
+
+Installation
+------------
+
+From PyPI:
+`pip install fassert`
+
+Locally:
+```
+pip install . 
+
+# Run tests with:
+python -m unittest discover -s tests/
+```
+
+
+
+Advanced usage
+--------------
+
+`fassert` function is equivalent in creating a default `FuzzyAssert()` object and calling match on it.
+You can configure some behaviour of the fuzzy matcher via the object attributes like so:
+
+```
+from fassert import FuzzyAssert
+
+fasserter = FuzzyAssert()
+# Eval functions is turned on by default
+fasserter.match("value", lambda x: x == "value")
+
+fasserter.eval_functions = False
+# This will now raise Assertion error
+fasserter.match("value", lambda x: x == "value")
+
+```
+
+Bellow is an overview of the configurable options and their default values
+
+| Name                          | Default value | Description                                                                            |
+|-------------------------------|---------------|----------------------------------------------------------------------------------------|
+| eval_functions                | True          | Enable template matching as callable functions                                         |
+| regex_allowed                 | True          | Enable matching regexes from template agains strings in the data                       |
+| fuzzy_sequence_types          | False         | Ignore types of similar sequence types when matching the template (e.g. tuple vs list) |
+| check_minimum_sequence_length | True          | Check that the data has a minimum length of greater or equal to the template           |

fassert/__init__.py

@@ -2,6 +2,8 @@
 from abc import ABC, abstractmethod
 from typing import Pattern, Sequence, Literal
 
+__version__ = "0.2"
+
 
 class FuzzyAssert:
     def __init__(self):
@@ -18,7 +20,9 @@ def match(self, data, template) -> Literal[True]:
 
         :param data: Data to match against, extra data, container types or other python types is ignored
         :param template: Template to match against, everything defined here must have a match
+        :raises AssertionError: Raised when data does not match the given template
         :return: True if `template` matches the `data`
+        :rtype: Literal[True]
         """
         if inspect.isfunction(template):
             if self.eval_functions and template(data):

setup.cfg

@@ -1,14 +1,18 @@
 [metadata]
 name = fassert
-version = 0.1
+version = attr: fassert.__version__
 author = Martin Carnogursky
 author_email = admin@sourcecode.ai
-
+long_description = file: README.md
+url = https://github.com/SourceCode-AI/fassert
 classifiers =
-    Programming Language :: Python :: 3
+    Intended Audience :: Developers
+    Programming Language :: Python :: 3 :: Only
+    License :: OSI Approved :: MIT License
     Operating System :: OS Independent
+keywords = fuzzy, assert, matching, nested
 
 
 [options]
-packages = find:
+packages = fassert
 python_requires = >=3.8

tests/test_misc.py

@@ -12,23 +12,32 @@ def test_readme_main_example(self):
 
         fassert("This is expected", "This is expected")
 
-        fassert("This matches as well", re.compile(r"[thismacewl ]+", re.I))
+        fassert("This matches as well", re.compile(r"[thismachewl ]+", re.I))
 
         fassert(
             {"key": "value", "key2": "value2"},
             {"key": "value"}
         )  # key2: value2 is ignored as it's not defined in the template
 
         fassert(
-            {"key": "value"},
+            {"key": "value", "abc": "value"},
             # You can nest and combine the fuzzy matching types in containers
             {re.compile(r"[a-z]{3}"): "value"}
         )
 
+        fassert(
+            [1, {"very": {"nested": {"dictionary": "data"}}}, {"not": "this"}],
+            # Isn't this cool?
+            [{"very": {re.compile(".{6}"): {"dictionary": lambda x: len(x) == 4}}}]
+        )
+
         # Template can contain callables as well
         fassert("value", lambda x: x == "value")
 
         try:
+            fassert("expected", "to not match")
             fassert({"a": "b"}, {"c": "d"})  # This will fail, {"c":"d"} is not in the target data
+            fassert([1, 2, 3], [4])
+            fassert("string", b"string")  # bytes != string in fassert
         except AssertionError:
             pass  # All the examples within the try block above will raise this exception