Boost line length to 120

Author: francoisfreitag

MANIFEST.in

@@ -1,5 +1,5 @@
 include ChangeLog CODE_OF_CONDUCT.md CONTRIBUTING.rst CREDITS LICENSE README.rst
-include Makefile tox.ini
+include Makefile pyproject.toml tox.ini
 
 graft factory
 

docs/conf.py

@@ -64,9 +64,7 @@
 
 if "READTHEDOCS_VERSION" in os.environ:
     # Use the readthedocs version string in preference to our known version.
-    html_title = "{} {} documentation".format(
-        project, os.environ["READTHEDOCS_VERSION"]
-    )
+    html_title = "{} {} documentation".format(project, os.environ["READTHEDOCS_VERSION"])
 
 # Add any paths that contain custom static files (such as style sheets) here,
 # relative to this directory. They are copied after the builtin static files,

examples/django_demo/generic_foreignkey/factories.py

@@ -22,9 +22,7 @@ class Meta:
 
 class TaggedItemFactory(factory.django.DjangoModelFactory):
     object_id = factory.SelfAttribute("content_object.id")
-    content_type = factory.LazyAttribute(
-        lambda o: ContentType.objects.get_for_model(o.content_object)
-    )
+    content_type = factory.LazyAttribute(lambda o: ContentType.objects.get_for_model(o.content_object))
 
     class Meta:
         exclude = ["content_object"]

factory/alchemy.py

@@ -57,8 +57,7 @@ def _get_or_create(cls, model_class, session, args, kwargs):
             if field not in kwargs:
                 raise errors.FactoryError(
                     "sqlalchemy_get_or_create - "
-                    "Unable to find initialization value for '%s' in factory %s"
-                    % (field, cls.__name__)
+                    "Unable to find initialization value for '%s' in factory %s" % (field, cls.__name__)
                 )
             key_fields[field] = kwargs.pop(field)
 
@@ -76,11 +75,7 @@ def _get_or_create(cls, model_class, session, args, kwargs):
                 }
                 if get_or_create_params:
                     try:
-                        obj = (
-                            session.query(model_class)
-                            .filter_by(**get_or_create_params)
-                            .one()
-                        )
+                        obj = session.query(model_class).filter_by(**get_or_create_params).one()
                     except NoResultFound:
                         # Original params are not a valid lookup and triggered a create(),
                         # that resulted in an IntegrityError.

factory/base.py

@@ -41,9 +41,7 @@ def __call__(cls, **kwargs):
         elif cls._meta.strategy == enums.STUB_STRATEGY:
             return cls.stub(**kwargs)
         else:
-            raise errors.UnknownStrategy(
-                "Unknown Meta.strategy: {}".format(cls._meta.strategy)
-            )
+            raise errors.UnknownStrategy("Unknown Meta.strategy: {}".format(cls._meta.strategy))
 
     def __new__(mcs, class_name, bases, attrs):
         """Record attributes as a pattern for later instance construction.
@@ -193,23 +191,18 @@ def _fill_from_meta(self, meta, base_meta):
             }
 
         for option in self._build_default_options():
-            assert not hasattr(self, option.name), (
-                "Can't override field %s." % option.name
-            )
+            assert not hasattr(self, option.name), "Can't override field %s." % option.name
             value = option.apply(meta, base_meta)
             meta_attrs.pop(option.name, None)
             setattr(self, option.name, value)
 
         if meta_attrs:
             # Some attributes in the Meta aren't allowed here
             raise TypeError(
-                "'class Meta' for %r got unknown attribute(s) %s"
-                % (self.factory, ",".join(sorted(meta_attrs.keys())))
+                "'class Meta' for %r got unknown attribute(s) %s" % (self.factory, ",".join(sorted(meta_attrs.keys())))
             )
 
-    def contribute_to_class(
-        self, factory, meta=None, base_meta=None, base_factory=None, params=None
-    ):
+    def contribute_to_class(self, factory, meta=None, base_meta=None, base_factory=None, params=None):
 
         self.factory = factory
         self.base_factory = base_factory
@@ -235,17 +228,13 @@ def contribute_to_class(
                 self.base_declarations[k] = v
 
         if params is not None:
-            for k, v in utils.sort_ordered_objects(
-                vars(params).items(), getter=lambda item: item[1]
-            ):
+            for k, v in utils.sort_ordered_objects(vars(params).items(), getter=lambda item: item[1]):
                 if not k.startswith("_"):
                     self.parameters[k] = declarations.SimpleParameter.wrap(v)
 
         self._check_parameter_dependencies(self.parameters)
 
-        self.pre_declarations, self.post_declarations = builder.parse_declarations(
-            self.declarations
-        )
+        self.pre_declarations, self.post_declarations = builder.parse_declarations(self.declarations)
 
     def _get_counter_reference(self):
         """Identify which factory should be used for a shared counter."""
@@ -311,7 +300,7 @@ def prepare_arguments(self, attributes):
             for k, v in kwargs.items()
             if k not in self.exclude
             and k not in self.parameters
-            and v is not declarations.SKIP
+            and v is not declarations.SKIP  # fmt: skip
         }
 
         # 3. Rename fields
@@ -373,21 +362,16 @@ def _check_parameter_dependencies(self, parameters):
                 field_revdeps = parameter.get_revdeps(parameters)
                 if not field_revdeps:
                     continue
-                deep_revdeps[name] = set.union(
-                    *(deep_revdeps[dep] for dep in field_revdeps)
-                )
+                deep_revdeps[name] = set.union(*(deep_revdeps[dep] for dep in field_revdeps))
                 deep_revdeps[name] |= set(field_revdeps)
                 for dep in field_revdeps:
                     deps[dep].add(name)
 
         # Check for cyclical dependencies
-        cyclic = [
-            name for name, field_deps in deep_revdeps.items() if name in field_deps
-        ]
+        cyclic = [name for name, field_deps in deep_revdeps.items() if name in field_deps]
         if cyclic:
             raise errors.CyclicDefinitionError(
-                "Cyclic definition detected on %r; Params around %s"
-                % (self.factory, ", ".join(cyclic))
+                "Cyclic definition detected on %r; Params around %s" % (self.factory, ", ".join(cyclic))
             )
         return deps
 

factory/builder.py

@@ -78,7 +78,7 @@ def update(self, values):
                     {
                         self.join(root, sub): v
                         for root in extra_context_keys
-                        for sub, v in self.contexts[root].items()
+                        for sub, v in self.contexts[root].items()  # fmt: skip
                     },
                     sorted(self.declarations),
                 )
@@ -148,18 +148,15 @@ def parse_declarations(decls, base_pre=None, base_post=None):
                 # Conflict: PostGenerationDeclaration with the same
                 # name as a BaseDeclaration
                 raise errors.InvalidDeclarationError(
-                    "PostGenerationDeclaration %s=%r shadows declaration %r"
-                    % (k, v, pre_declarations[k])
+                    "PostGenerationDeclaration %s=%r shadows declaration %r" % (k, v, pre_declarations[k])
                 )
             extra_post[k] = v
         elif k in post_declarations:
             # Passing in a scalar value to a PostGenerationDeclaration
             # Set it as `key__`
             magic_key = post_declarations.join(k, "")
             extra_post[magic_key] = v
-        elif k in pre_declarations and isinstance(
-            pre_declarations[k].declaration, declarations.Transformer
-        ):
+        elif k in pre_declarations and isinstance(pre_declarations[k].declaration, declarations.Transformer):
             extra_maybenonpost[k] = pre_declarations[k].declaration.function(v)
         else:
             extra_maybenonpost[k] = v
@@ -214,8 +211,7 @@ def recurse(self, factory, declarations, force_sequence=None):
 
         if not issubclass(factory, base.BaseFactory):
             raise errors.AssociatedClassError(
-                "%r: Attempting to recursing into a non-factory object %r"
-                % (self, factory)
+                "%r: Attempting to recursing into a non-factory object %r" % (self, factory)
             )
         builder = self.builder.recurse(factory._meta, declarations)
         return builder.build(parent_step=self, force_sequence=force_sequence)
@@ -337,8 +333,7 @@ def __getattr__(self, name):
         """
         if name in self.__pending:
             raise errors.CyclicDefinitionError(
-                "Cyclic lazy attribute definition for %r; cycle found in %r."
-                % (name, self.__pending)
+                "Cyclic lazy attribute definition for %r; cycle found in %r." % (name, self.__pending)
             )
         elif name in self.__values:
             return self.__values[name]

factory/declarations.py

@@ -210,9 +210,7 @@ def __init__(self, iterator, cycle=True, getter=None):
         self.iterator = None
 
         if cycle:
-            self.iterator_builder = lambda: utils.ResetableIterator(
-                itertools.cycle(iterator)
-            )
+            self.iterator_builder = lambda: utils.ResetableIterator(itertools.cycle(iterator))
         else:
             self.iterator_builder = lambda: utils.ResetableIterator(iterator)
 
@@ -305,10 +303,7 @@ def evaluate(self, instance, step, extra):
         # Strip the current instance from the chain
         chain = step.chain[1:]
         if self.strict and not chain:
-            raise TypeError(
-                "A ContainerAttribute in 'strict' mode can only be used "
-                "within a SubFactory."
-            )
+            raise TypeError("A ContainerAttribute in 'strict' mode can only be used " "within a SubFactory.")
 
         return self.function(instance, chain)
 
@@ -484,26 +479,18 @@ def __init__(self, decider, yes_declaration=SKIP, no_declaration=SKIP):
         if len(used_phases) > 1:
             raise TypeError(f"Inconsistent phases for {self!r}: {phases!r}")
 
-        self.FACTORY_BUILDER_PHASE = (
-            used_phases.pop()
-            if used_phases
-            else enums.BuilderPhase.ATTRIBUTE_RESOLUTION
-        )
+        self.FACTORY_BUILDER_PHASE = used_phases.pop() if used_phases else enums.BuilderPhase.ATTRIBUTE_RESOLUTION
 
     def evaluate_post(self, instance, step, overrides):
         """Handle post-generation declarations"""
         decider_phase = enums.get_builder_phase(self.decider)
         if decider_phase == enums.BuilderPhase.ATTRIBUTE_RESOLUTION:
             # Note: we work on the *builder stub*, not on the actual instance.
             # This gives us access to all Params-level definitions.
-            choice = self.decider.evaluate_pre(
-                instance=step.stub, step=step, overrides=overrides
-            )
+            choice = self.decider.evaluate_pre(instance=step.stub, step=step, overrides=overrides)
         else:
             assert decider_phase == enums.BuilderPhase.POST_INSTANTIATION
-            choice = self.decider.evaluate_post(
-                instance=instance, step=step, overrides={}
-            )
+            choice = self.decider.evaluate_post(instance=instance, step=step, overrides={})
 
         target = self.yes if choice else self.no
         if enums.get_builder_phase(target) == enums.BuilderPhase.POST_INSTANTIATION:

factory/django.py

@@ -101,9 +101,7 @@ def _load_model_class(cls, definition):
     @classmethod
     def _get_manager(cls, model_class):
         if model_class is None:
-            raise errors.AssociatedClassError(
-                f"No model set on {cls.__module__}.{cls.__name__}.Meta"
-            )
+            raise errors.AssociatedClassError(f"No model set on {cls.__module__}.{cls.__name__}.Meta")
 
         try:
             manager = model_class.objects
@@ -129,18 +127,15 @@ def _get_or_create(cls, model_class, *args, **kwargs):
         manager = cls._get_manager(model_class)
 
         assert "defaults" not in cls._meta.django_get_or_create, (
-            "'defaults' is a reserved keyword for get_or_create "
-            "(in %s._meta.django_get_or_create=%r)"
-            % (cls, cls._meta.django_get_or_create)
-        )
+            "'defaults' is a reserved keyword for get_or_create (in %s._meta.django_get_or_create=%r)"
+        ) % (cls, cls._meta.django_get_or_create)
 
         key_fields = {}
         for field in cls._meta.django_get_or_create:
             if field not in kwargs:
                 raise errors.FactoryError(
                     "django_get_or_create - "
-                    "Unable to find initialization value for '%s' in factory %s"
-                    % (field, cls.__name__)
+                    "Unable to find initialization value for '%s' in factory %s" % (field, cls.__name__)
                 )
             key_fields[field] = kwargs.pop(field)
         key_fields["defaults"] = kwargs

factory/fuzzy.py

@@ -168,18 +168,13 @@ def __init__(self, start_date, end_date=None):
             end_date = datetime.date.today()
 
         if start_date > end_date:
-            raise ValueError(
-                "FuzzyDate boundaries should have start <= end; got %r > %r."
-                % (start_date, end_date)
-            )
+            raise ValueError("FuzzyDate boundaries should have start <= end; got %r > %r." % (start_date, end_date))
 
         self.start_date = start_date.toordinal()
         self.end_date = end_date.toordinal()
 
     def fuzz(self):
-        return datetime.date.fromordinal(
-            random.randgen.randint(self.start_date, self.end_date)
-        )
+        return datetime.date.fromordinal(random.randgen.randint(self.start_date, self.end_date))
 
 
 class BaseFuzzyDateTime(BaseFuzzyAttribute):
@@ -191,8 +186,7 @@ class BaseFuzzyDateTime(BaseFuzzyAttribute):
     def _check_bounds(self, start_dt, end_dt):
         if start_dt > end_dt:
             raise ValueError(
-                """%s boundaries should have start <= end, got %r > %r"""
-                % (self.__class__.__name__, start_dt, end_dt)
+                """%s boundaries should have start <= end, got %r > %r""" % (self.__class__.__name__, start_dt, end_dt)
             )
 
     def _now(self):
@@ -232,9 +226,7 @@ def __init__(
 
     def fuzz(self):
         delta = self.end_dt - self.start_dt
-        microseconds = delta.microseconds + 1000000 * (
-            delta.seconds + (delta.days * 86400)
-        )
+        microseconds = delta.microseconds + 1000000 * (delta.seconds + (delta.days * 86400))
 
         offset = random.randgen.randint(0, microseconds)
         result = self.start_dt + datetime.timedelta(microseconds=offset)
@@ -268,14 +260,9 @@ def _now(self):
 
     def _check_bounds(self, start_dt, end_dt):
         if start_dt.tzinfo is not None:
-            raise ValueError(
-                "FuzzyNaiveDateTime only handles naive datetimes, got start=%r"
-                % start_dt
-            )
+            raise ValueError("FuzzyNaiveDateTime only handles naive datetimes, got start=%r" % start_dt)
         if end_dt.tzinfo is not None:
-            raise ValueError(
-                "FuzzyNaiveDateTime only handles naive datetimes, got end=%r" % end_dt
-            )
+            raise ValueError("FuzzyNaiveDateTime only handles naive datetimes, got end=%r" % end_dt)
         super()._check_bounds(start_dt, end_dt)
 
 
@@ -291,12 +278,7 @@ def _now(self):
 
     def _check_bounds(self, start_dt, end_dt):
         if start_dt.tzinfo is None:
-            raise ValueError(
-                "FuzzyDateTime requires timezone-aware datetimes, got start=%r"
-                % start_dt
-            )
+            raise ValueError("FuzzyDateTime requires timezone-aware datetimes, got start=%r" % start_dt)
         if end_dt.tzinfo is None:
-            raise ValueError(
-                "FuzzyDateTime requires timezone-aware datetimes, got end=%r" % end_dt
-            )
+            raise ValueError("FuzzyDateTime requires timezone-aware datetimes, got end=%r" % end_dt)
         super()._check_bounds(start_dt, end_dt)

factory/utils.py

@@ -34,8 +34,7 @@ def __repr__(self):
 
     def __str__(self):
         return ", ".join(
-            [repr(arg) for arg in self.args]
-            + ["%s=%s" % (key, repr(value)) for key, value in self.kwargs.items()]
+            [repr(arg) for arg in self.args] + ["%s=%s" % (key, repr(value)) for key, value in self.kwargs.items()]
         )