autofaker 0.1.0__py3-none-any.whl

autofaker/__init__.py

@@ -0,0 +1,14 @@
+"""
+Provides modules for creation anonymous variables to help minimize the setup/arrange phase when writing unit tests
+"""
+
+__version__ = "0.1.0"
+
+from autofaker.autodata import *
+from autofaker.decorators import *
+from autofaker.registry import (
+    register_predicate,
+    register_type,
+    registry_context,
+    reset_registry,
+)

autofaker/attributes.py

@@ -0,0 +1,19 @@
+class Attributes:
+    def __init__(self, instance):
+        self.instance = instance
+
+    def get_members(self):
+        return [
+            attr
+            for attr in dir(self.instance)
+            if not callable(getattr(self.instance, attr)) and not attr.startswith("__")
+        ]
+
+    def get_attribute(self, member):
+        return getattr(self.instance, member)
+
+    def get_typename(self, member):
+        return type(self.get_attribute(member)).__name__
+
+    def set_value(self, member, value):
+        setattr(self.instance, member, value)

autofaker/autodata.py

@@ -0,0 +1,71 @@
+"""
+Provides classes for anonymous object creation to help minimize
+the setup/arrange phase when writing unit tests
+"""
+
+import typing
+from typing import List
+
+from autofaker.dataframe import PandasDataFrameGenerator
+from autofaker.generator import TypeDataGenerator
+
+
+class Autodata:
+    """
+    Provides anonymous object creation functions to help minimize
+    the setup/arrange phase when writing unit tests
+    """
+
+    @staticmethod
+    def create(t, use_fake_data: bool = False):
+        """
+        Creates an anonymous variable of the requested type
+
+        :param type t: type
+            The type to generate data for
+
+        :param use_fake_data: bool
+            Set this to True to use Faker to generate data
+            otherwise False to generate anonymous data
+        """
+        return TypeDataGenerator.create(t, use_fake_data=use_fake_data).generate()
+
+    @staticmethod
+    def create_many(t, size: int = 3, use_fake_data: bool = False) -> List[typing.Any]:
+        """
+        Creates a list of anonymous variables of the requested
+        type using the specified length (default 3)
+
+        :param type t: (type)
+            The type to generate data for
+
+        :param size: (int)
+            The number of items to generate (default 3)
+
+        :param use_fake_data: (bool)
+            Set this to True to use Faker to generate data,
+            otherwise False to generate anonymous data
+        """
+        items = []
+        for _ in range(size):
+            items.append(Autodata.create(t, use_fake_data=use_fake_data))
+        return items
+
+    @staticmethod
+    def create_pandas_dataframe(t, rows: int = 3, use_fake_data: bool = False):
+        """
+        Create a Pandas DataFrame containing anonymous data
+        with the specified number of rows (default 3)
+
+        :param type t: object
+            The class that represents the DataFrame.
+            This can be a plain old class or a @dataclass
+
+        :param type rows: int
+            The number of rows to generate for the DataFrame (default 3)
+
+        :param use_fake_data: bool
+            Set this to True to use Faker to generate data,
+            otherwise False to generate anonymous data
+        """
+        return PandasDataFrameGenerator(t, rows, use_fake_data=use_fake_data).generate()

autofaker/base.py

@@ -0,0 +1,7 @@
+from abc import abstractmethod
+
+
+class TypeDataGeneratorBase:
+    @abstractmethod
+    def generate(self):
+        pass

autofaker/builtins.py

@@ -0,0 +1,105 @@
+import decimal
+import pathlib
+import random
+import uuid
+
+from autofaker.base import TypeDataGeneratorBase
+
+
+class IntegerGenerator(TypeDataGeneratorBase):
+    def generate(self):
+        return random.randint(1, 10000)
+
+
+class StringGenerator(TypeDataGeneratorBase):
+    def generate(self):
+        return str(uuid.uuid4())
+
+
+class FloatGenerator(TypeDataGeneratorBase):
+    def generate(self):
+        return random.uniform(0, 10000)
+
+
+class BooleanGenerator(TypeDataGeneratorBase):
+    def generate(self):
+        return bool(random.getrandbits(1))
+
+
+class ComplexGenerator(TypeDataGeneratorBase):
+    def generate(self):
+        return complex(IntegerGenerator().generate())
+
+
+class RangeGenerator(TypeDataGeneratorBase):
+    def generate(self):
+        return range(IntegerGenerator().generate())
+
+
+class BytesGenerator(TypeDataGeneratorBase):
+    def generate(self):
+        return bytes(range(random.randint(1, 256)))
+
+
+class ByteArrayGenerator(TypeDataGeneratorBase):
+    def generate(self):
+        return bytearray(range(random.randint(1, 256)))
+
+
+class MemoryViewGenerator(TypeDataGeneratorBase):
+    def generate(self):
+        return memoryview(BytesGenerator().generate())
+
+
+class TupleGenerator(TypeDataGeneratorBase):
+    def generate(self):
+        return (
+            IntegerGenerator().generate(),
+            StringGenerator().generate(),
+            FloatGenerator().generate(),
+        )
+
+
+class SetGenerator(TypeDataGeneratorBase):
+    def generate(self):
+        return {
+            StringGenerator().generate(),
+            StringGenerator().generate(),
+            StringGenerator().generate(),
+        }
+
+
+class FrozenSetGenerator(TypeDataGeneratorBase):
+    def generate(self):
+        return frozenset({
+            StringGenerator().generate(),
+            StringGenerator().generate(),
+            StringGenerator().generate(),
+        })
+
+
+class DictGenerator(TypeDataGeneratorBase):
+    def generate(self):
+        return {
+            StringGenerator().generate(): IntegerGenerator().generate(),
+            StringGenerator().generate(): IntegerGenerator().generate(),
+            StringGenerator().generate(): IntegerGenerator().generate(),
+        }
+
+
+class DecimalGenerator(TypeDataGeneratorBase):
+    def generate(self):
+        return decimal.Decimal(str(random.uniform(0, 10000)))
+
+
+class UUIDGenerator(TypeDataGeneratorBase):
+    def generate(self):
+        return uuid.uuid4()
+
+
+class PathGenerator(TypeDataGeneratorBase):
+    def generate(self):
+        return pathlib.Path(
+            StringGenerator().generate(),
+            StringGenerator().generate(),
+        )

autofaker/dataframe.py

@@ -0,0 +1,38 @@
+import dataclasses
+
+import pandas as pd
+
+from autofaker.attributes import Attributes
+from autofaker.generator import TypeDataGenerator
+
+
+class PandasDataFrameGenerator:
+    def __init__(self, t, rows: int = 3, use_fake_data: bool = False):
+        self.t = t
+        self.data = []
+        for _ in range(rows):
+            row = TypeDataGenerator.create(t, use_fake_data=use_fake_data).generate()
+            self.data.append(row)
+
+    def _get_columns(self, instance):
+        return [
+            attr
+            for attr in dir(instance)
+            if (dataclasses.is_dataclass(getattr(instance, attr))
+            or not callable(getattr(instance, attr)))
+            and not attr.startswith("__")
+        ]
+
+    def generate(self):
+        if not self.data:
+            sample = TypeDataGenerator.create(self.t).generate()
+            columns = self._get_columns(sample)
+            return pd.DataFrame(columns=columns)
+        members = self._get_columns(self.data[0])
+        rows = []
+        for d in self.data:
+            row = []
+            for member in members:
+                row.append(Attributes(d).get_attribute(member))
+            rows.append(row)
+        return pd.DataFrame(rows, columns=members)

autofaker/dates.py

@@ -0,0 +1,51 @@
+import datetime
+import random
+
+from autofaker.base import TypeDataGeneratorBase
+
+
+def is_date_type(type_name) -> bool:
+    return type_name in ["datetime", "date", "time", "timedelta"]
+
+
+class DatetimeGenerator(TypeDataGeneratorBase):
+    def generate(self):
+        year = datetime.date.today().year
+        return datetime.datetime(
+            random.randint(year - 10, year + 10),
+            random.randint(1, 12),
+            random.randint(1, 28),
+            random.randint(0, 23),
+            random.randint(0, 59),
+            random.randint(0, 59),
+            random.randint(0, 999999),
+        )
+
+
+class DateGenerator(TypeDataGeneratorBase):
+    def generate(self):
+        year = datetime.date.today().year
+        return datetime.date(
+            random.randint(year - 10, year + 10),
+            random.randint(1, 12),
+            random.randint(1, 28),
+        )
+
+
+class TimeGenerator(TypeDataGeneratorBase):
+    def generate(self):
+        return datetime.time(
+            random.randint(0, 23),
+            random.randint(0, 59),
+            random.randint(0, 59),
+            random.randint(0, 999999),
+        )
+
+
+class TimedeltaGenerator(TypeDataGeneratorBase):
+    def generate(self):
+        return datetime.timedelta(
+            days=random.randint(0, 365),
+            seconds=random.randint(0, 86399),
+            microseconds=random.randint(0, 999999),
+        )

autofaker/decorators.py

@@ -0,0 +1,209 @@
+"""
+Provides anonymous object creation functions to help minimize
+the setup/arrange phase when writing unit tests
+"""
+
+import inspect
+import unittest
+from typing import List
+
+from autofaker import Autodata, PandasDataFrameGenerator
+
+
+def autodata(*types: object, use_fake_data: bool = False):
+    """
+    Creates anonymous variable of the requested types
+    and pass them as arguments to a unit test function
+
+    Example:
+
+    import unittest
+
+    from autofaker import autodata
+
+    class SampleTest(unittest.TestCase):
+        @autodata(str, int, float, bool)
+
+        def test_create_str_argument_using_decorator(self, text, number, decimal, boolean):
+            self.assertIsNotNone(text)
+
+
+    :param use_fake_data: bool
+        Set this to True to use Faker to generate data,
+        otherwise False to generate anonymous data
+
+    :param type types: tuple
+        The types to generate data.
+        This is optional and will use the arguments
+        from the function being decorated if not specified
+    """
+    if _is_bare_decoration(types):
+        return _make_arg_decorator((), use_fake_data=use_fake_data)(types[0])
+    return _make_arg_decorator(types, use_fake_data=use_fake_data)
+
+
+def fakedata(*types: object):
+    """
+    Creates fake values for the variables of the requested types
+    and pass them as arguments to a unit test function
+
+    Example:
+
+    import unittest
+
+    from autofaker import fakedata
+
+    class SampleTest(unittest.TestCase):
+        @fakedata()
+
+        def test_create_fake_arguments(self, text: str, number: int, decimal: float, boolean: bool):
+            self.assertIsNotNone(text)
+
+
+    :param types: object
+        The types to generate data.
+        This is optional and will use the arguments from the function
+        being decorated if not specified
+    """
+    if _is_bare_decoration(types):
+        return _make_arg_decorator((), use_fake_data=True)(types[0])
+    return _make_arg_decorator(types, use_fake_data=True)
+
+
+def autopandas(t: object, rows: int = 3, use_fake_data: bool = False):
+    """
+    Create a Pandas DataFrame containing anonymous data
+    with the specified number of rows (default 3)
+
+    :param type t: object
+        The class that represents the DataFrame.
+        This can be a plain old class or a @dataclass
+
+    :param type rows: int
+        The number of rows to generate for the DataFrame (default 3)
+
+    :param use_fake_data: bool
+        Set this to True to use Faker to generate data,
+        otherwise False to generate anonymous data
+    """
+
+    def decorator(function):
+        def wrapper(*args):
+            pdf = PandasDataFrameGenerator(
+                t, rows, use_fake_data=use_fake_data
+            ).generate()
+            return _invoke(function, args, lambda: [pdf])
+
+        return wrapper
+
+    return decorator
+
+
+def fakepandas(t, rows: int = 3):
+    """
+    Create a Pandas DataFrame containing fake data with
+    the specified number of rows (default 3)
+
+    :param type t: object
+        The class that represents the DataFrame.
+        This can be a plain old class or a @dataclass
+
+    :param type rows: int
+        The number of rows to generate for the DataFrame (default 3)
+    """
+    return autopandas(t, rows, use_fake_data=True)
+
+
+def _is_bare_decoration(types) -> bool:
+    """True when a decorator was applied without parentheses (``@autodata``).
+
+    In that case the decorated function itself is passed as the single
+    positional argument. Distinguished from a callable type argument by the
+    presence of ``__code__`` and not being a class.
+    """
+    return (
+        len(types) == 1
+        and callable(types[0])
+        and not isinstance(types[0], type)
+        and hasattr(types[0], "__code__")
+    )
+
+
+def _make_arg_decorator(types, use_fake_data: bool):
+    """Build a decorator that injects generated arguments into a test function.
+
+    When ``types`` is empty the argument types are taken from the decorated
+    function's annotations; otherwise the explicit ``types`` are used.
+    """
+
+    def decorator(function):
+        def wrapper(*args):
+            return _invoke(
+                function,
+                args,
+                lambda: __create_function_args(
+                    function, *tuple(types), use_fake_data=use_fake_data
+                ),
+            )
+
+        return wrapper
+
+    return decorator
+
+
+def _invoke(function, call_args, build_args):
+    """Call ``function`` with generated arguments.
+
+    When the decorated function is a ``unittest.TestCase`` method, its instance
+    (``self``) is recovered from the wrapper's call arguments and prepended.
+    The test-class check runs before ``build_args`` so an invalid target raises
+    ``NotImplementedError`` ahead of any argument-shape error. ``build_args`` is
+    a thunk to defer that work until the target is known.
+    """
+    if __get_class_that_defined_method(function) is None:
+        function(*build_args())
+        return None
+    test_class = __get_test_class(*call_args)
+    function(test_class, *build_args())
+    return None
+
+
+def __get_test_class(*args):
+    test_class = args[0]
+    if not issubclass(test_class.__class__, unittest.TestCase):
+        raise NotImplementedError(
+            "This way of creating anonymous objects are only supported from unit tests"
+        )
+    return test_class
+
+
+def __get_class_that_defined_method(meth):
+    if inspect.isfunction(meth):
+        cls = getattr(
+            inspect.getmodule(meth),
+            meth.__qualname__.split(".<locals>", 1)[0].rsplit(".", 1)[0],
+            None,
+        )
+        if isinstance(cls, type):
+            return cls
+    return getattr(meth, "__objclass__", None)  # handle special descriptor objects
+
+
+def __create_function_args(function, *types, use_fake_data: bool = False) -> List:
+    values = []
+    argtypes = inspect.getfullargspec(function)
+    annotations = {
+        k: v for k, v in argtypes.annotations.items() if k != 'return'
+    }
+    args = annotations.values() if types is None or len(types) == 0 else types
+    for t in args:
+        value = Autodata.create(t, use_fake_data)
+        values.append(value)
+    pos = 1
+    if __get_class_that_defined_method(function) is None:
+        pos = 0
+    if len(argtypes.args) - pos != len(values):
+        raise ValueError(
+            "Missing argument annotations. Please declare the type of every argument"
+        )
+    return values

autofaker/enums.py

@@ -0,0 +1,16 @@
+import random
+from enum import Enum
+
+from autofaker.base import TypeDataGeneratorBase
+
+
+def is_enum(t) -> bool:
+    return isinstance(t, Enum.__class__)
+
+
+class EnumGenerator(TypeDataGeneratorBase):
+    def __init__(self, enum):
+        self.enum = enum
+
+    def generate(self):
+        return random.choice(list(self.enum))

autofaker/fakes.py

@@ -0,0 +1,30 @@
+from faker import Faker
+
+from autofaker.attributes import Attributes
+from autofaker.base import TypeDataGeneratorBase
+from autofaker.builtins import StringGenerator
+
+faker = Faker()
+
+
+def generate(field_name: str):
+    try:
+        attributes = Attributes(faker)
+        func = attributes.get_attribute(field_name)
+        return func()
+    except AttributeError:
+        return None
+
+
+class FakeStringGenerator(TypeDataGeneratorBase):
+    def __init__(self, field_name: str):
+        self.field_name = field_name
+
+    def generate(self):
+        fake = generate(self.field_name)
+        return fake if fake is not None else StringGenerator().generate()
+
+
+class FakeIntegerGenerator(TypeDataGeneratorBase):
+    def generate(self):
+        return faker.random_int(min=1, max=10000)