'Refactored by Sourcery'

Author: Sourcery AI

django_sorcery/db/fields.py

@@ -45,11 +45,8 @@ class Field(sa.Column):
     def __init__(self, *args, **kwargs):
         self.db = kwargs.pop("db", None)
 
-        name = None
         args = list(args)
-        if args and isinstance(args[0], str):
-            name = args.pop(0)
-
+        name = args.pop(0) if args and isinstance(args[0], str) else None
         column_type = kwargs.pop("type_", None)
         if args and hasattr(args[0], "_sqla_type"):
             column_type = args.pop(0)
@@ -266,11 +263,14 @@ def get_django_dialect_ranges(self):
         ops = operations.BaseDatabaseOperations
         with suppress(ImportError):
             ops = (
-                import_string(DIALECT_MAP_TO_DJANGO.get(self.db.url.get_dialect().name) + ".base.DatabaseOperations")
+                import_string(
+                    f"{DIALECT_MAP_TO_DJANGO.get(self.db.url.get_dialect().name)}.base.DatabaseOperations"
+                )
                 if self.db
                 else operations.BaseDatabaseOperations
             )
 
+
         return ops.integer_field_ranges
 
     def get_dialect_range(self):

django_sorcery/db/meta/column.py

@@ -166,7 +166,7 @@ def clean(self, value, instance):
 
     def validate(self, value, instance):
         """Validate value and raise ValidationError if necessary."""
-        getattr(instance, "clean_" + self.name, bool)()
+        getattr(instance, f"clean_{self.name}", bool)()
 
     def run_validators(self, value):
         """Run field's validators and raise ValidationError if necessary."""
@@ -194,9 +194,7 @@ def __init__(self, column, prop=None, parent=None, name=None):
         self.field_kwargs["max_length"] = self.column.type.length
 
     def to_python(self, value):
-        if value is None:
-            return value
-        return str(value).strip()
+        return value if value is None else str(value).strip()
 
 
 class text_column_info(string_column_info):
@@ -324,9 +322,7 @@ def to_python(self, value):
             return bool(value)
         if value in ("t", "T"):
             return True
-        if value in ("f", "F"):
-            return False
-        return self.coercer.to_python(value)
+        return False if value in ("f", "F") else self.coercer.to_python(value)
 
 
 class date_column_info(column_info):

django_sorcery/db/meta/model.py

@@ -76,8 +76,8 @@ def __init__(self, model):
             app_config = apps.get_containing_app_config(self.model_class.__module__)
             self.app_label = getattr(app_config, "label", None) or "django_sorcery"
 
-        self.label = "{}.{}".format(self.app_label, self.object_name)
-        self.label_lower = "{}.{}".format(self.app_label, self.model_name)
+        self.label = f"{self.app_label}.{self.object_name}"
+        self.label_lower = f"{self.app_label}.{self.model_name}"
 
         sa.event.listen(self.mapper, "mapper_configured", self._init)
         self._init(self.mapper, self.model_class)
@@ -148,10 +148,16 @@ def __getattr__(self, name):
 
     def __repr__(self):
         reprs = ["<model_info({!s})>".format(self.model_class.__name__)]
-        reprs.extend("    " + repr(i) for i in self.primary_keys.values())
-        reprs.extend("    " + repr(i) for _, i in sorted(self.properties.items()))
-        reprs.extend("    " + i for i in chain(*[repr(c).split("\n") for _, c in sorted(self.composites.items())]))
-        reprs.extend("    " + repr(i) for _, i in sorted(self.relationships.items()))
+        reprs.extend(f"    {repr(i)}" for i in self.primary_keys.values())
+        reprs.extend(f"    {repr(i)}" for _, i in sorted(self.properties.items()))
+        reprs.extend(
+            f"    {i}"
+            for i in chain(
+                *[repr(c).split("\n") for _, c in sorted(self.composites.items())]
+            )
+        )
+
+        reprs.extend(f"    {repr(i)}" for _, i in sorted(self.relationships.items()))
         return "\n".join(reprs)
 
     @property
@@ -186,10 +192,7 @@ def primary_keys_from_dict(self, kwargs):
         if any(pk is None for pk in pks):
             return None
 
-        if len(pks) < 2:
-            return next(iter(pks), None)
-
-        return tuple(pks)
+        return next(iter(pks), None) if len(pks) < 2 else tuple(pks)
 
     def primary_keys_from_instance(self, instance):
         """Return a dict containing the primary keys of the ``instance``"""

django_sorcery/db/meta/relations.py

@@ -55,8 +55,10 @@ def __init__(self, relationship):
         self.local_remote_pairs_for_identity_key = []
         try:
             # ensure local_remote pairs are of same order as remote pk
-            for i in target_pk:
-                self.local_remote_pairs_for_identity_key.append((pairs[i], i))
+            self.local_remote_pairs_for_identity_key.extend(
+                (pairs[i], i) for i in target_pk
+            )
+
         except KeyError:
             # if relation is missing one of related pk columns
             # but actual constraint has it defined
@@ -78,8 +80,10 @@ def __init__(self, relationship):
 
             if len(matching_constraints) == 1:
                 pairs = {i.column: i.parent for i in matching_constraints[0].elements}
-                for i in target_pk:
-                    self.local_remote_pairs_for_identity_key.append((pairs[i], i))
+                self.local_remote_pairs_for_identity_key.extend(
+                    (pairs[i], i) for i in target_pk
+                )
+
             else:
                 # if everything fails, return default pairs
                 self.local_remote_pairs_for_identity_key = self.local_remote_pairs[:]
@@ -98,10 +102,7 @@ def get_form_class(self):
         from ...fields import ModelChoiceField
         from ...fields import ModelMultipleChoiceField
 
-        if self.uselist:
-            return ModelMultipleChoiceField
-
-        return ModelChoiceField
+        return ModelMultipleChoiceField if self.uselist else ModelChoiceField
 
     def __repr__(self):
-        return "<relation_info({}.{})>".format(self.parent_model.__name__, self.name)
+        return f"<relation_info({self.parent_model.__name__}.{self.name})>"

django_sorcery/db/models.py

@@ -233,9 +233,9 @@ class BaseMeta(sqlalchemy.ext.declarative.DeclarativeMeta):
     """Base metaclass for models which registers models to DB model registry
     when models are created."""
 
-    def __new__(mcs, name, bases, attrs):
-        klass = super().__new__(mcs, name, bases, attrs)
-        mcs.db.models_registry.append(klass)
+    def __new__(cls, name, bases, attrs):
+        klass = super().__new__(cls, name, bases, attrs)
+        cls.db.models_registry.append(klass)
         return klass
 
 

django_sorcery/db/profiler.py

@@ -190,17 +190,20 @@ def process_response(self, request, response):
         try:
             stats = self.profiler.stats
             if stats["duration"] or self.log_results:
-                self.log(**{"sa_{}".format(k): v for k, v in stats.items()})
+                self.log(**{f"sa_{k}": v for k, v in stats.items()})
         except Exception:  # pragma: nocover
             # The show must go on...
             pass  # pragma: nocover
         else:
             if self.header_results:
                 for k, v in stats.items():
-                    response["X-SA-{}".format("".join(i.title() for i in k.split("_")))] = v
+                    response[f'X-SA-{"".join(i.title() for i in k.split("_"))}'] = v
         self.profiler.clear()
         return response
 
     def log(self, **kwargs):
         """Log sqlalchemy stats for current request."""
-        self.logger.info("SQLAlchemy profiler %s", " ".join("{}={}".format(k, v) for k, v in kwargs.items()))
+        self.logger.info(
+            "SQLAlchemy profiler %s",
+            " ".join(f"{k}={v}" for k, v in kwargs.items()),
+        )

django_sorcery/db/query.py

@@ -1,4 +1,5 @@
 """sqlalchemy query related things."""
+
 from collections import namedtuple
 from functools import partial
 
@@ -14,34 +15,31 @@
 # todo add transforms support - e.g. column__date__gt
 LOOKUP_TO_EXPRESSION = {
     "contains": lambda column, value: column.contains(value),
-    # "date"
-    # "day"
     "endswith": lambda column, value: column.endswith(value),
     "exact": lambda column, value: column == value,
     "gt": lambda column, value: column > value,
     "gte": lambda column, value: column >= value,
-    # "hour"
-    "icontains": lambda column, value: sa.func.lower(column).contains(lower(value)),
-    "iendswith": lambda column, value: sa.func.lower(column).endswith(lower(value)),
+    "icontains": lambda column, value: sa.func.lower(column).contains(
+        lower(value)
+    ),
+    "iendswith": lambda column, value: sa.func.lower(column).endswith(
+        lower(value)
+    ),
     "iexact": lambda column, value: sa.func.lower(column) == lower(value),
-    "iin": lambda column, value: sa.func.lower(column).in_(lower(i) for i in value),
+    "iin": lambda column, value: sa.func.lower(column).in_(
+        lower(i) for i in value
+    ),
     "in": lambda column, value: column.in_(value),
-    # "iregex"
-    "isnull": lambda column, value: column == None if value else column != None,  # noqa
-    "istartswith": lambda column, value: sa.func.lower(column).startswith(lower(value)),
+    "isnull": lambda column, value: column is None
+    if value
+    else column != None,
+    "istartswith": lambda column, value: sa.func.lower(column).startswith(
+        lower(value)
+    ),
     "lt": lambda column, value: column < value,
     "lte": lambda column, value: column <= value,
-    # "minute"
-    # "month"
-    # "quarter"
     "range": lambda column, value: column.between(*value),
-    # "regex"
-    # "second"
     "startswith": lambda column, value: column.startswith(value),
-    # "time"
-    # "week"
-    # "week_day"
-    # "year"
 }
 
 
@@ -58,11 +56,7 @@ def get(self, *args, **kwargs):
             mapper = self._only_full_mapper_zero("get")
             pk = meta.model_info(mapper).primary_keys_from_dict(kwargs)
 
-            if pk is not None:
-                return super().get(pk)
-
-            return None
-
+            return super().get(pk) if pk is not None else None
         return super().get(*args, **kwargs)
 
     def order_by(self, *criterion):
@@ -236,11 +230,10 @@ def __get__(self, instance, owner):
 
         if not model:
             raise AttributeError(
-                "Cannot access {} when not bound to a model. "
-                "You can explicitly instantiate descriptor with model class - `db.queryproperty(Model)`."
-                "".format(self.__class__.__name__)
+                f"Cannot access {self.__class__.__name__} when not bound to a model. You can explicitly instantiate descriptor with model class - `db.queryproperty(Model)`."
             )
 
+
         try:
             mapper = sa.orm.class_mapper(model)
         except sa.orm.exc.UnmappedClassError:

django_sorcery/db/sqlalchemy.py

@@ -36,8 +36,8 @@ def get(self):
 
 
 class _sqla_meta(type):
-    def __new__(mcs, name, bases, attrs):
-        typ = super().__new__(mcs, name, bases, attrs)
+    def __new__(cls, name, bases, attrs):
+        typ = super().__new__(cls, name, bases, attrs)
 
         # figure out all props to be proxied
         dummy = sa.orm.Session()

django_sorcery/forms.py

@@ -191,11 +191,15 @@ class ModelFormMetaclass(DeclarativeFieldsMetaclass):
     def __new__(mcs, name, bases, attrs):
         cls = super().__new__(mcs, name, bases, attrs)
 
-        base_formfield_callback = None
-        for base in bases:
-            if hasattr(base, "Meta") and hasattr(base.Meta, "formfield_callback"):
-                base_formfield_callback = base.Meta.formfield_callback
-                break
+        base_formfield_callback = next(
+            (
+                base.Meta.formfield_callback
+                for base in bases
+                if hasattr(base, "Meta")
+                and hasattr(base.Meta, "formfield_callback")
+            ),
+            None,
+        )
 
         formfield_callback = attrs.pop("formfield_callback", base_formfield_callback)
 
@@ -331,9 +335,10 @@ def save(self, flush=True, **kwargs):
 
         if self.errors:
             raise ValueError(
-                "The {} could not be saved because the data didn't validate.".format(self.instance.__class__.__name__)
+                f"The {self.instance.__class__.__name__} could not be saved because the data didn't validate."
             )
 
+
         if self.instance not in opts.session:
             opts.session.add(self.instance)
 
@@ -372,7 +377,7 @@ def save_instance(self, instance=None, cleaned_data=None):
     def update_attribute(self, instance, name, field, value):
         """Provides hooks for updating form instance's attribute for a field
         with value."""
-        field_setter = getattr(self, "set_" + name, None)
+        field_setter = getattr(self, f"set_{name}", None)
         if field_setter:
             field_setter(instance, name, field, value)
         else:
@@ -408,7 +413,7 @@ def modelform_factory(model, form=ModelForm, formfield_callback=None, **kwargs):
     if formfield_callback:
         meta_.formfield_callback = staticmethod(formfield_callback)
 
-    class_name = model.__name__ + "Form"
+    class_name = f"{model.__name__}Form"
 
     if getattr(meta_, "fields", None) is None and getattr(meta_, "exclude", None) is None:
         raise ImproperlyConfigured(

django_sorcery/formsets/base.py

@@ -30,10 +30,11 @@ def __init__(self, data=None, files=None, auto_id="id_%s", prefix=None, queryset
 
     def initial_form_count(self):
         """Return the number of forms that are required in this FormSet."""
-        if not (self.data or self.files):
-            return len(self.get_queryset())
-
-        return super().initial_form_count()
+        return (
+            super().initial_form_count()
+            if (self.data or self.files)
+            else len(self.get_queryset())
+        )
 
     def _existing_object(self, pk):
         info = meta.model_info(self.model)
@@ -54,7 +55,7 @@ def _construct_form(self, i, **kwargs):
                 info = meta.model_info(self.model)
                 pks = {}
                 for name, pk_info in info.primary_keys.items():
-                    pk_key = "{}-{}".format(self.add_prefix(i), name)
+                    pk_key = f"{self.add_prefix(i)}-{name}"
                     pk_val = self.data.get(pk_key)
                     pks[name] = pk_info.column.type.python_type(pk_val) if pk_val else None
 
@@ -194,5 +195,5 @@ def modelformset_factory(
         validate_min=validate_min,
         validate_max=validate_max,
     )
-    class_name = model.__name__ + "FormSet"
+    class_name = f"{model.__name__}FormSet"
     return type(form)(str(class_name), (FormSet,), {"model": model, "session": session})