factory-bot 0.0.1__py3-none-any.whl

factory_bot/__init__.py

@@ -0,0 +1,25 @@
+from ._core import (
+    FactoryError,
+    attributes_for,
+    build,
+    clear_factories,
+    factory,
+    reset_sequences,
+    sequence,
+)
+from ._fake import fake, seed
+
+__author__ = "dpepper"
+__version__ = "0.0.1"
+
+__all__ = [
+    "FactoryError",
+    "attributes_for",
+    "build",
+    "clear_factories",
+    "factory",
+    "fake",
+    "reset_sequences",
+    "seed",
+    "sequence",
+]

factory_bot/_core.py

@@ -0,0 +1,210 @@
+import copy
+import difflib
+import inspect
+import itertools
+import os
+import weakref
+
+_registry: dict[str, "_Factory"] = {}
+_sequences: weakref.WeakSet["_Sequence"] = weakref.WeakSet()
+
+
+class FactoryError(Exception):
+    pass
+
+
+def factory(model):
+    """Register the decorated function as a factory for `model`, e.g. @factory(User)."""
+    if _is_body(model):
+        raise FactoryError(
+            f"@factory needs a model: write @factory(User) or @factory(dict) above def {model.__name__}"
+        )
+
+    def register(body):
+        name = body.__name__
+        if not callable(model):
+            raise FactoryError(f"Factory {name!r}: model {model!r} is not callable")
+        if name in _registry:
+            raise FactoryError(
+                f"Factory {name!r} is already defined{_where(_registry[name].body)}"
+            )
+        _registry[name] = _Factory(name, model, body)
+        return body
+
+    return register
+
+
+def build(name, /, *traits, **overrides):
+    fac = _lookup(name)
+    return fac.model(**fac.attributes_for(traits, overrides))
+
+
+def attributes_for(name, /, *traits, **overrides):
+    return _lookup(name).attributes_for(traits, overrides)
+
+
+def sequence(fn):
+    """A value built from a counter that starts at 1, e.g. sequence(lambda n: f"user{n}")."""
+    try:
+        inspect.signature(fn).bind(1)
+    except TypeError:
+        raise FactoryError(
+            f'sequence() takes a function of the counter, e.g. sequence(lambda n: f"user{{n}}"), not {fn!r}'
+        ) from None
+    except ValueError:  # no inspectable signature; trust it
+        pass
+    return _Sequence(fn)
+
+
+def clear_factories():
+    _registry.clear()
+
+
+def reset_sequences():
+    for seq in _sequences:
+        seq.reset()
+
+
+class _Factory:
+    def __init__(self, name, model, body):
+        self.name, self.model, self.body = name, model, body
+        self.attributes = {}
+        self.traits = {}
+        body(_Definition(self, self.attributes))
+
+    def attributes_for(self, traits, overrides):
+        return _Evaluator(self.name, self.definitions(traits), overrides).attributes()
+
+    def definitions(self, traits):
+        definitions = dict(self.attributes)
+        for trait in traits:
+            if trait not in self.traits:
+                raise FactoryError(
+                    f"Factory {self.name!r} has no trait {trait!r}.{_suggest(trait, self.traits)}"
+                    f" Traits: {', '.join(self.traits) or '(none)'}"
+                )
+            definitions |= self.traits[trait]
+        return definitions
+
+
+class _Sequence:
+    def __init__(self, fn):
+        self.fn = fn
+        self.reset()
+        _sequences.add(self)
+
+    def reset(self):
+        self.counter = itertools.count(1)
+
+    def next(self):
+        return self.fn(next(self.counter))
+
+
+class _Definition:
+    """The `f` in `def user(f):`. Assigning to it declares an attribute."""
+
+    def __init__(self, factory, attributes):
+        object.__setattr__(self, "_factory", factory)
+        object.__setattr__(self, "_attributes", attributes)
+
+    def __setattr__(self, name, value):
+        self._attributes[name] = value
+
+    def trait(self, body):
+        # Run the body now, once: re-running it per build would restart its sequences.
+        attributes = {}
+        body(_Definition(self._factory, attributes))
+        self._factory.traits[body.__name__] = attributes
+        return body
+
+    def __getattr__(self, name):
+        raise FactoryError(
+            f"Factory {self._factory.name!r}: can't read f.{name} in a definition."
+            f" To use another attribute, take it as a parameter: lambda {name}: ..."
+        )
+
+
+class _Evaluator:
+    """Resolves one build's attributes, each at most once, in dependency order."""
+
+    def __init__(self, factory_name, definitions, overrides):
+        self.factory_name = factory_name
+        self.definitions = definitions
+        self.values = dict(overrides)  # overrides are plain values, never called
+        self.resolving = []
+
+    def attributes(self):
+        names = (self.definitions | self.values).keys()  # declaration order
+        return {name: self.get(name) for name in names}
+
+    def get(self, name, needed_by=None):
+        if name in self.values:
+            return self.values[name]
+        definitions = self.definitions
+        if name not in definitions:
+            raise FactoryError(
+                f"Factory {self.factory_name!r}: {needed_by!r} depends on {name!r}, which is not defined."
+                f"{_suggest(name, definitions)}{_where(definitions[needed_by])}"
+            )
+        if name in self.resolving:
+            cycle = " -> ".join([*self.resolving[self.resolving.index(name) :], name])
+            raise FactoryError(
+                f"Factory {self.factory_name!r}: circular dependency: {cycle}"
+            )
+        self.resolving.append(name)
+        try:
+            self.values[name] = self.evaluate(name, definitions[name])
+        finally:
+            self.resolving.pop()
+        return self.values[name]
+
+    def evaluate(self, name, value):
+        if isinstance(value, _Sequence):
+            return value.next()
+        if callable(value):
+            return value(
+                **{dep: self.get(dep, needed_by=name) for dep in _dependencies(value)}
+            )
+        if isinstance(value, (list, dict, set)):
+            return copy.copy(value)
+        return value
+
+
+def _dependencies(fn):
+    # Only required params: fake.paragraph(nb_sentences=3) must not be injected.
+    try:
+        params = inspect.signature(fn).parameters.values()
+    except (TypeError, ValueError):  # some builtins (dict, str) have no signature
+        return []
+    keyword = (inspect.Parameter.POSITIONAL_OR_KEYWORD, inspect.Parameter.KEYWORD_ONLY)
+    return [p.name for p in params if p.kind in keyword and p.default is p.empty]
+
+
+def _lookup(name):
+    if name not in _registry:
+        raise FactoryError(f"No factory named {name!r}.{_suggest(name, _registry)}")
+    return _registry[name]
+
+
+def _is_body(model):
+    # Bare @factory hands us the body itself: a function of exactly one required argument.
+    if not inspect.isfunction(model):
+        return False
+    params = list(inspect.signature(model).parameters.values())
+    return (
+        len(params) == 1
+        and params[0].kind is params[0].POSITIONAL_OR_KEYWORD
+        and params[0].default is params[0].empty
+    )
+
+
+def _suggest(name, options):
+    close = difflib.get_close_matches(name, list(options), n=1)
+    return f" Did you mean {close[0]!r}?" if close else ""
+
+
+def _where(fn):
+    code = getattr(fn, "__code__", None)
+    return (
+        f" ({os.path.basename(code.co_filename)}:{code.co_firstlineno})" if code else ""
+    )

factory_bot/_fake.py

@@ -0,0 +1,8 @@
+from faker import Faker
+
+fake = Faker()
+
+
+def seed(value):
+    """Seed `fake` so a test's generated data is reproducible."""
+    fake.seed_instance(value)

factory_bot-0.0.1.dist-info/METADATA

@@ -0,0 +1,60 @@
+Metadata-Version: 2.5
+Name: factory_bot
+Version: 0.0.1
+Summary: Test data factories with the ergonomics of Ruby's factory_bot
+Project-URL: Homepage, https://github.com/dpep/py_factory_bot
+Project-URL: Issues, https://github.com/dpep/py_factory_bot/issues
+Project-URL: Changelog, https://github.com/dpep/py_factory_bot/blob/main/CHANGELOG.md
+Author: Daniel Pepper
+License-Expression: MIT
+License-File: LICENSE.txt
+Keywords: factories,factory_bot,fixtures,testing
+Classifier: Development Status :: 2 - Pre-Alpha
+Classifier: Framework :: Pytest
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Software Development :: Testing
+Classifier: Typing :: Typed
+Requires-Python: >=3.11
+Requires-Dist: faker
+Provides-Extra: django
+Requires-Dist: django; extra == 'django'
+Provides-Extra: sqlalchemy
+Requires-Dist: sqlalchemy>=2; extra == 'sqlalchemy'
+Description-Content-Type: text/markdown
+
+factory_bot
+======
+Test data factories with the ergonomics of Ruby's [factory_bot](https://github.com/thoughtbot/factory_bot).
+
+Early development: the API is still settling.
+
+
+### Install
+```pip install factory_bot```
+
+
+### Usage
+```python
+from factory_bot import build, factory, fake, sequence
+
+@factory(User)
+def user(f):
+    f.first_name = fake.first_name                    # callables run per build
+    f.email = lambda first_name: f"{first_name}@example.com".lower()  # dependencies by name
+    f.username = sequence(lambda n: f"user{n}")
+    f.admin = False
+
+    @f.trait
+    def admin(f):
+        f.admin = True
+
+build("user")
+# User(first_name='Dennis', email='dennis@example.com', username='user1', admin=False)
+
+build("user", "admin", first_name="Jane")
+# User(first_name='Jane', email='jane@example.com', username='user2', admin=True)
+```
+
+----
+[![installs](https://img.shields.io/pypi/dm/factory_bot?label=installs)](https://pypi.org/project/factory_bot)

factory_bot-0.0.1.dist-info/RECORD

@@ -0,0 +1,8 @@
+factory_bot/__init__.py,sha256=bHyqKz_ktpyMOmS5y1Y1q5zRzXBvQDBoRBzDxRtE9FY,388
+factory_bot/_core.py,sha256=rYNAbKjtOx5ebZAiTtvAnkQM3dj7rtNzs-OfZR1ql6A,6710
+factory_bot/_fake.py,sha256=dt2DExXTNJHOiq5CK3a9tB-YxW5FYd9hrFwTpoEoJAs,155
+factory_bot/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+factory_bot-0.0.1.dist-info/METADATA,sha256=yFTr6pj9ht-kKKU3T7SgqEzzGxlrWoKOkqcAxyENqTU,1912
+factory_bot-0.0.1.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+factory_bot-0.0.1.dist-info/licenses/LICENSE.txt,sha256=8wraChDgxAQ-M5oTPDPth7_QcFWz8XfyDNltRxD9MwM,1080
+factory_bot-0.0.1.dist-info/RECORD,,

factory_bot-0.0.1.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.32.4
+Root-Is-Purelib: true
+Tag: py3-none-any

factory_bot-0.0.1.dist-info/licenses/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2024 Daniel Pepper
+
+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.