Tests and style

Author: sobolevn

.github/FUNDING.yml

@@ -0,0 +1,4 @@
+
+# These are supported funding model platforms
+
+patreon: sobolevn

.travis.yml

@@ -14,7 +14,7 @@ install: poetry install
 
 script:
   - poetry run flake8 .
-  - poetry run mypy safe_assert
+  - poetry run mypy classes tests/**/*.py
   - poetry run pytest
   - poetry check
   - poetry run pip check

CONTRIBUTING.md

@@ -0,0 +1,100 @@
+# How to contribute
+
+## Tutorials
+
+If you want to start working on this project,
+you will need to get familiar with these concepts:
+
+- <http://learnyouahaskell.com/types-and-typeclasses>
+- <https://en.wikipedia.org/wiki/Type_class>
+
+Similar projects:
+
+- <https://github.com/thejohnfreeman/python-typeclasses>
+- <https://docs.python.org/3/library/functools.html#functools.singledispatch>
+
+## Dependencies
+
+We use [`poetry`](https://github.com/sdispater/poetry) to manage the dependencies.
+
+To install them you would need to run `install` command:
+
+```bash
+poetry install
+```
+
+To activate your `virtualenv` run `poetry shell`.
+
+
+## Tests
+
+We use `pytest` and `flake8` for quality control.
+We also use `wemake_python_styleguide` to enforce the code quality.
+
+To run all tests:
+
+```bash
+pytest
+```
+
+To run linting:
+
+```bash
+flake8 .
+```
+
+These steps are mandatory during the CI.
+
+## Type checks
+
+We use `mypy` to run type checks on our code.
+To use it:
+
+```bash
+mypy returns tests/**/*.py
+```
+
+This step is mandatory during the CI.
+
+
+## Submitting your code
+
+We use [trunk based](https://trunkbaseddevelopment.com/)
+development (we also sometimes call it `wemake-git-flow`).
+
+What the point of this method?
+
+1. We use protected `master` branch,
+   so the only way to push your code is via pull request
+2. We use issue branches: to implement a new feature or to fix a bug
+   create a new branch named `issue-$TASKNUMBER`
+3. Then create a pull request to `master` branch
+4. We use `git tag`s to make releases, so we can track what has changed
+   since the latest release
+
+So, this way we achieve an easy and scalable development process
+which frees us from merging hell and long-living branches.
+
+In this method, the latest version of the app is always in the `master` branch.
+
+### Before submitting
+
+Before submitting your code please do the following steps:
+
+1. Run `pytest` to make sure everything was working before
+2. Add any changes you want
+3. Add tests for the new changes
+4. Edit documentation if you have changed something significant
+5. Update `CHANGELOG.md` with a quick summary of your changes
+6. Run `pytest` again to make sure it is still working
+7. Run `mypy` to ensure that types are correct
+8. Run `flake8` to ensure that style is correct
+9. Run `doc8` to ensure that docs are correct
+
+
+## Other help
+
+You can contribute by spreading a word about this library.
+It would also be a huge contribution to write
+a short article on how you are using this project.
+You can also share your best practices with us.

README.md

@@ -13,9 +13,37 @@
 
 -----
 
-Use smart, ad-hoc, typed polymorphism for your data types.
+Smart, pythonic, ad-hoc, typed polymorphism for Python.
 
 
 ## Features
 
-- WIP
+- Provides a bunch of primitives to write declarative business logic
+- Enforces better architecture
+- Fully typed with annotations and checked with `mypy`, [PEP561 compatible](https://www.python.org/dev/peps/pep-0561/)
+- Allows to write a lot of simple code without inheritance or interfaces
+- Pythonic and pleasant to write and to read (!)
+- Easy to start: has lots of docs, tests, and tutorials
+
+
+## Installation
+
+```bash
+pip install classes
+```
+
+You might also want to [configure](https://classes.readthedocs.io/en/latest/pages/container.html#type-safety)
+`mypy` correctly and install our plugin
+to fix [this existing issue](https://github.com/python/mypy/issues/3157):
+
+```ini
+# In setup.cfg or mypy.ini:
+[mypy]
+plugins =
+  classes.contrib.mypy.typeclass_plugin
+```
+
+We also recommend to use the same `mypy` settings [we use](https://github.com/wemake-services/wemake-python-styleguide/blob/master/styles/mypy.toml).
+
+Make sure you know how to get started, [check out our docs](https://classes.readthedocs.io/en/latest/)!
+

classes/__init__.py

@@ -7,4 +7,5 @@
 so mypy's ``implicit_reexport`` rule will be happy.
 """
 
+from classes.typeclass import TypeClass as TypeClass
 from classes.typeclass import typeclass as typeclass

classes/contrib/mypy/typeclass_plugin.py

@@ -5,7 +5,8 @@
 
 Features:
 
-- We return a valid ``typeclass`` generic instance from `@typeclass` contructor
+- We return a valid ``typeclass`` generic instance
+  from ``@typeclass`` contructor
 - We force ``.instance()`` calls to extend the union of allowed types
 - We ensure that when calling the typeclass'es function
   we know what values can be used as inputs
@@ -15,12 +16,13 @@
 
 We use ``pytest-mypy-plugins`` to test that it works correctly, see:
 https://github.com/TypedDjango/pytest-mypy-plugins
+
 """
 
 from typing import Type
 
 from mypy.plugin import Plugin
-from mypy.types import AnyType, UnionType, TypeOfAny, CallableType
+from mypy.types import AnyType, CallableType, TypeOfAny, TypeVarType, UnionType
 
 
 def _adjust_arguments(ctx):
@@ -79,28 +81,28 @@ def _adjust_typeclass_type(self, ctx, instance_type):
             # It means that function was defined without annotation
             # or with explicit `Any`, we prevent our Union from polution.
             # Because `Union[Any, int]` is just `Any`.
-            lambda type_: not isinstance(type_, AnyType),
+            # We also clear accidential type vars.
+            self._filter_out_unified_types,
             [instance_type, ctx.type.args[0]],
         ))
 
-        if len(unified) == 1:
-            # We don't want to mix `Union[A]` into the types,
-            # which sometimes works just like an alias for `Optional[A]`:
-            ctx.type.args[0] = instance_type
-        else:
-            ctx.type.args[0] = UnionType(unified)
+        if not isinstance(instance_type, TypeVarType):
+            ctx.type.args[0] = UnionType.make_union(unified)
+
+    def _filter_out_unified_types(self, type_) -> bool:
+        return not isinstance(type_, (AnyType, TypeVarType))
 
 
 class _TypedDecoratorPlugin(Plugin):
     def get_method_signature_hook(self, fullname: str):
         """Here we fix the calling method types to accept only valid types."""
-        if fullname == 'classes.typeclass._TypeClassMethod.__call__':
+        if fullname == 'classes.typeclass.TypeClass.__call__':
             return _adjust_call_signature
         return None
 
     def get_method_hook(self, fullname: str):
         """Here we adjust the typeclass with new allowed types."""
-        if fullname == 'classes.typeclass._TypeClassMethod.instance':
+        if fullname == 'classes.typeclass.TypeClass.instance':
             return _AdjustInstanceSignature().instance
         return None