implement core functionality with tests and docs

Author: json2d

.gitignore

@@ -1,3 +1,5 @@
+.vscode
+
 # Byte-compiled / optimized / DLL files
 __pycache__/
 *.py[cod]

README.md

@@ -1,2 +1,50 @@
 # validium
 a Python utility library for performing validations flexibly
+
+## Installation
+
+```bash
+pip install validium
+```
+
+## Quick Start
+
+Here's an example of how to create and use some very simple validators for some numbers:
+
+```py
+import validium as V
+
+PI = 3.14
+ONE = 1
+
+is_number = V.Validator(lambda x: isinstance(x, Number), 'must be a number')
+
+is_number.validate(PI) # pass
+is_number.validate(ONE) # pass
+
+is_positive = V.Validator(lambda x: x > 0, 'must be positive')
+
+is_positive.validate(PI) # pass
+is_positive.validate(ONE) # pass
+
+is_not_one = V.Validator(lambda x: not x == 1, 'must not equal 1')
+
+is_not_one.validate(PI) # pass
+is_not_one.validate(ONE) # AssertionError: must not equal 1
+
+```
+
+### Building Up
+
+Here's an example of how to parameterize and reuse a common validator pattern:
+
+```py
+is_not = lambda y: V.Validator(lambda x: not x == y, 'must not equal {}'.format(x)) # u
+
+is_not(-1).validate(ONE) # pass
+is_not(0).validate(ONE) # pass
+is_not(1).validate(ONE) # AssertionError: must not equal 1
+
+```
+
+This approach will help keep your code nice and DRY in the event you need handful of validators that behave mostly the same but slightly different.

docker-compose.shell.yml

@@ -0,0 +1,11 @@
+version: '3'
+services:
+  test-runner:
+    build: 
+      context: .
+      dockerfile: python3.Dockerfile
+    command: python
+    volumes:
+     - .:/app
+    stdin_open: true
+    tty: true

docker-compose.test-runner.yml

@@ -0,0 +1,20 @@
+version: '3'
+services:
+  test-runner:
+    build: 
+      context: .
+      dockerfile: python3.Dockerfile
+    command: python tests/units.py
+    volumes:
+     - .:/app
+    stdin_open: true
+    tty: true
+  test-runner-2:
+    build: 
+      context: .
+      dockerfile: python2.Dockerfile
+    command: python tests/units.py
+    volumes:
+      - .:/app
+    stdin_open: true
+    tty: true

python2.Dockerfile

@@ -0,0 +1,6 @@
+FROM python:2.7
+
+WORKDIR /app
+
+COPY requirements.txt ./
+RUN pip install --no-cache-dir -r requirements.txt

python3.Dockerfile

@@ -0,0 +1,6 @@
+FROM python:3.8
+
+WORKDIR /app
+
+COPY requirements.txt ./
+RUN pip install --no-cache-dir -r requirements.txt

requirements.txt

@@ -0,0 +1,2 @@
+pandas==1.0.1
+ramda==0.5.5

tests/units.py

@@ -0,0 +1,161 @@
+import sys
+from os import path
+sys.path.append( path.dirname( path.dirname( path.abspath(__file__) ) ) )
+
+from numbers import Number
+
+# from helpers import *
+
+# from functools import reduce
+
+import unittest
+import ramda as R
+import pandas as pd
+
+import validium as V
+
+# extensions for some missing ramda functions
+R.isinstance = lambda x: lambda y: isinstance(y,x)
+
+class TestEverything(unittest.TestCase):
+
+  # use `_test` prefix isntead of `test` (w/o leading underscore) so test runner doesn't use it
+  def _test_should_fail(self, fail_validators, foo):
+    for validator in fail_validators:
+      with self.assertRaises(AssertionError):
+        validator.validate(foo)
+
+  def _test_should_pass(self, pass_validators, foo):
+    try:
+      for validator in pass_validators:
+        validator.validate(foo)
+    except:
+      self.fail('validation should have passed but exception was raised')
+
+  def test_base(self):
+
+    foo = 3.14
+    
+    pass_validators = [
+      V.Validator(
+        lambda x: isinstance(x, Number), 
+        'must be a number'
+      ),
+
+      V.Validator(
+        lambda x: isinstance(x, float), 
+        'must be a float'
+      ),
+
+      V.Validator(
+        lambda x: x > 0 and x < 100, 
+        'must be greater than 0 and less than 100'
+      ),
+
+      V.Validator(
+        lambda x: x == 3.14, 
+        'must equal 3.14'
+      ),
+    ]
+
+    self._test_should_pass(pass_validators, foo)
+
+    fail_validators = [
+
+      V.Validator(
+        R.isinstance(str),
+        'must be a string'
+      ),
+
+      V.Validator(R.equals(42), 'must equal 42'),
+
+      V.Validator(
+        lambda x: x < 0, 
+        'must be less than 0',
+      )
+    ]
+
+    self._test_should_fail(fail_validators, foo)
+
+  def test_list(self):
+
+    class Mystery:
+      pass
+
+    bars = [1, 2, .14, None, 'hello', 'world']
+    
+    pass_validators = [
+      V.Validator(
+        lambda xs: isinstance(xs, list), 
+        'must be a list'
+      ),
+
+      V.Validator(
+        lambda xs: len(xs) == 6, 
+        'must be of length 6'
+      ),
+
+      V.Validator(
+        lambda xs: all([not isinstance(x, Mystery) for x in xs]),  
+        'all must not be Mystery'
+      ),
+
+      V.Validator(
+        lambda xs: all([x > 0 for x in filter(lambda x: isinstance(x, Number), xs)]), 
+        'all numbers must be greater than 0'
+      ),
+
+      V.Validator(
+        lambda xs: ' '.join(filter(lambda x: isinstance(x, str), xs)) == 'hello world', 
+        'all strings joined with a space must equal "hello world"'
+      ),
+
+      V.Validator(
+        R.any(R.equals('hello')), 
+        'any must equal "hello"'
+      ),
+
+      V.Validator(
+        R.all(R.isinstance((Number, type(None), str))), 
+        'all must be number, None or str'
+      ),
+
+      V.Validator(
+        R.pipe(R.filter(R.isinstance(Number)), R.sum, R.equals(3.14)),
+        'all numbers summed must equal 3.14'
+      ),
+      
+      V.Validator(
+        R.pipe(R.filter(R.isinstance(str)), R.length, R.equals(2)),
+        'the count of str must be 2'
+      ),
+    ]
+
+    self._test_should_pass(pass_validators, bars)
+
+    fail_validators = [
+      V.Validator(
+        R.all(R.pipe(R.isinstance(type(None)), R.negate)),
+        'all must not be None'
+      ),
+      
+      V.Validator(
+        R.any(R.isinstance(dict)),
+        'any must be dict'
+      ),
+
+      V.Validator(
+        R.pipe(R.filter(R.isinstance(Number)), R.sum, R.equals(42)),
+        'all numbers summed must equal 42'
+      ),
+
+      V.Validator(
+        R.pipe(R.filter(R.isinstance(str)), R.length, R.equals(4)),
+        'the count of str must be 4'
+      ),
+
+    ]
+
+    self._test_should_fail(fail_validators, bars)
+
+unittest.main()

validium/__init__.py

@@ -0,0 +1 @@
+from .core import Validator

validium/core.py

@@ -0,0 +1,14 @@
+class Validator:
+
+  def __init__(self, predicate, fail_msg=None):
+
+    assert callable(predicate), "the argument 'predicate' must be callable"
+    assert fail_msg is None or isinstance(fail_msg, str), "the argument 'fail_msg' must be None or an instance of str"
+
+    self.__dict__ = dict(
+      predicate=predicate,
+      fail_msg=fail_msg,
+    )
+
+  def validate(self, target):
+    assert self.predicate(target), self.fail_msg