plain.models 0.50.0__py3-none-any.whl → 0.51.0__py3-none-any.whl

plain/models/preflight.py

@@ -30,7 +30,9 @@ class CheckAllModels(PreflightCheck):
         errors = []
         models = models_registry.get_models()
         for model in models:
-            db_table_models[model._meta.db_table].append(model._meta.label)
+            db_table_models[model.model_options.db_table].append(
+                model.model_options.label
+            )
             if not inspect.ismethod(model.preflight):
                 errors.append(
                     PreflightResult(
@@ -41,10 +43,10 @@ class CheckAllModels(PreflightCheck):
                 )
             else:
                 errors.extend(model.preflight())
-            for model_index in model._meta.indexes:
-                indexes[model_index.name].append(model._meta.label)
-            for model_constraint in model._meta.constraints:
-                constraints[model_constraint.name].append(model._meta.label)
+            for model_index in model.model_options.indexes:
+                indexes[model_index.name].append(model.model_options.label)
+            for model_constraint in model.model_options.constraints:
+                constraints[model_constraint.name].append(model.model_options.label)
         for db_table, model_labels in db_table_models.items():
             if len(model_labels) != 1:
                 model_labels_str = ", ".join(model_labels)

plain/models/query.py

@@ -10,7 +10,7 @@ import warnings
 from collections.abc import Callable, Iterator
 from functools import cached_property
 from itertools import chain, islice
-from typing import TYPE_CHECKING, Any, Generic, TypeVar
+from typing import TYPE_CHECKING, Any, Generic, Self, TypeVar
 
 import plain.runtime
 from plain.exceptions import ValidationError
@@ -151,7 +151,10 @@ class RawModelIterable(BaseIterable):
                 raise FieldDoesNotExist("Raw query must include the primary key")
             fields = [self.queryset.model_fields.get(c) for c in self.queryset.columns]
             converters = compiler.get_converters(
-                [f.get_col(f.model._meta.db_table) if f else None for f in fields]
+                [
+                    f.get_col(f.model.model_options.db_table) if f else None
+                    for f in fields
+                ]
             )
             if converters:
                 query_iterator = compiler.apply_converters(query_iterator, converters)
@@ -270,25 +273,72 @@ class FlatValuesListIterable(BaseIterable):
 
 
 class QuerySet(Generic[T]):
-    """Represent a lazy database lookup for a set of objects."""
+    """
+    Represent a lazy database lookup for a set of objects.
 
-    def __init__(self, *, model: type[T], query: sql.Query | None = None):
-        self.model = model
-        self._query = query or sql.Query(self.model)
-        self._result_cache: list[T] | None = None
-        self._sticky_filter = False
-        self._for_write = False
-        self._prefetch_related_lookups: tuple[Any, ...] = ()
-        self._prefetch_done = False
-        self._known_related_objects: dict[
-            Any, dict[Any, Any]
-        ] = {}  # {rel_field: {id: rel_obj}}
-        self._iterable_class: type[BaseIterable] = ModelIterable
-        self._fields: tuple[str, ...] | None = None
-        self._defer_next_filter = False
-        self._deferred_filter: tuple[bool, tuple[Any, ...], dict[str, Any]] | None = (
-            None
-        )
+    Usage:
+        MyModel.query.filter(name="test").all()
+
+    Custom QuerySets:
+        from typing import Self
+
+        class TaskQuerySet(QuerySet["Task"]):
+            def active(self) -> Self:
+                return self.filter(is_active=True)
+
+        class Task(Model):
+            is_active = BooleanField(default=True)
+            query = TaskQuerySet()
+
+        Task.query.active().filter(name="test")  # Full type inference
+
+    Custom methods should return `Self` to preserve type through method chaining.
+    """
+
+    # Instance attributes (set in from_model())
+    model: type[T]
+    _query: sql.Query
+    _result_cache: list[T] | None
+    _sticky_filter: bool
+    _for_write: bool
+    _prefetch_related_lookups: tuple[Any, ...]
+    _prefetch_done: bool
+    _known_related_objects: dict[Any, dict[Any, Any]]
+    _iterable_class: type[BaseIterable]
+    _fields: tuple[str, ...] | None
+    _defer_next_filter: bool
+    _deferred_filter: tuple[bool, tuple[Any, ...], dict[str, Any]] | None
+
+    def __init__(self):
+        """Minimal init for descriptor mode. Use from_model() to create instances."""
+        pass
+
+    @classmethod
+    def from_model(cls, model: type[T], query: sql.Query | None = None) -> Self:
+        """Create a QuerySet instance bound to a model."""
+        instance = cls()
+        instance.model = model
+        instance._query = query or sql.Query(model)
+        instance._result_cache = None
+        instance._sticky_filter = False
+        instance._for_write = False
+        instance._prefetch_related_lookups = ()
+        instance._prefetch_done = False
+        instance._known_related_objects = {}
+        instance._iterable_class = ModelIterable
+        instance._fields = None
+        instance._defer_next_filter = False
+        instance._deferred_filter = None
+        return instance
+
+    def __get__(self, instance: Any, owner: type[T]) -> Self:
+        """Descriptor protocol - return a new QuerySet bound to the model."""
+        if instance is not None:
+            raise AttributeError(
+                f"QuerySet is only accessible from the model class, not instances. "
+                f"Use {owner.__name__}.query instead."
+            )
+        return self.from_model(owner)
 
     @property
     def sql_query(self) -> sql.Query:
@@ -310,7 +360,7 @@ class QuerySet(Generic[T]):
 
     def __deepcopy__(self, memo: dict[int, Any]) -> QuerySet[T]:
         """Don't populate the QuerySet's cache."""
-        obj = self.__class__(model=self.model)
+        obj = self.__class__.from_model(self.model)
         for k, v in self.__dict__.items():
             if k == "_result_cache":
                 obj.__dict__[k] = None
@@ -434,12 +484,14 @@ class QuerySet(Generic[T]):
         query = (
             self
             if self.sql_query.can_filter()
-            else self.model._meta.base_queryset.filter(id__in=self.values("id"))  # type: ignore[attr-defined]
+            else self.model._model_meta.base_queryset.filter(id__in=self.values("id"))
         )
         combined = query._chain()
         combined._merge_known_related_objects(other)
         if not other.sql_query.can_filter():
-            other = other.model._meta.base_queryset.filter(id__in=other.values("id"))  # type: ignore[attr-defined]
+            other = other.model._model_meta.base_queryset.filter(
+                id__in=other.values("id")
+            )
         combined.sql_query.combine(other.sql_query, sql.OR)
         return combined
 
@@ -453,12 +505,14 @@ class QuerySet(Generic[T]):
         query = (
             self
             if self.sql_query.can_filter()
-            else self.model._meta.base_queryset.filter(id__in=self.values("id"))  # type: ignore[attr-defined]
+            else self.model._model_meta.base_queryset.filter(id__in=self.values("id"))
         )
         combined = query._chain()
         combined._merge_known_related_objects(other)
         if not other.sql_query.can_filter():
-            other = other.model._meta.base_queryset.filter(id__in=other.values("id"))  # type: ignore[attr-defined]
+            other = other.model._model_meta.base_queryset.filter(
+                id__in=other.values("id")
+            )
         combined.sql_query.combine(other.sql_query, sql.XOR)
         return combined
 
@@ -565,11 +619,11 @@ class QuerySet(Generic[T]):
             return clone._result_cache[0]
         if not num:
             raise self.model.DoesNotExist(
-                f"{self.model._meta.object_name} matching query does not exist."
+                f"{self.model.model_options.object_name} matching query does not exist."
             )
         raise self.model.MultipleObjectsReturned(
             "get() returned more than one {} -- it returned {}!".format(
-                self.model._meta.object_name,
+                self.model.model_options.object_name,
                 num if not limit or num < limit else "more than %s" % (limit - 1),
             )
         )
@@ -595,7 +649,7 @@ class QuerySet(Generic[T]):
         return obj
 
     def _prepare_for_bulk_create(self, objs: list[T]) -> None:
-        id_field = self.model._meta.get_field("id")  # type: ignore[attr-defined]
+        id_field = self.model._model_meta.get_field("id")
         for obj in objs:
             if obj.id is None:  # type: ignore[attr-defined]
                 # Populate new primary key values.
@@ -679,18 +733,18 @@ class QuerySet(Generic[T]):
 
         if not objs:
             return objs
-        opts = self.model._meta
+        meta = self.model._model_meta
         if unique_fields:
-            unique_fields = [self.model._meta.get_field(name) for name in unique_fields]
+            unique_fields = [meta.get_field(name) for name in unique_fields]
         if update_fields:
-            update_fields = [self.model._meta.get_field(name) for name in update_fields]
+            update_fields = [meta.get_field(name) for name in update_fields]
         on_conflict = self._check_bulk_create_options(
             update_conflicts,
             update_fields,
             unique_fields,
         )
         self._for_write = True
-        fields = opts.concrete_fields
+        fields = meta.concrete_fields
         objs = list(objs)
         self._prepare_for_bulk_create(objs)
         with transaction.atomic(savepoint=False):
@@ -704,9 +758,9 @@ class QuerySet(Generic[T]):
                     update_fields=update_fields,
                     unique_fields=unique_fields,
                 )
-                id_field = opts.get_field("id")
+                id_field = meta.get_field("id")
                 for obj_with_id, results in zip(objs_with_id, returned_columns):
-                    for result, field in zip(results, opts.db_returning_fields):
+                    for result, field in zip(results, meta.db_returning_fields):
                         if field != id_field:
                             setattr(obj_with_id, field.attname, result)
                 for obj_with_id in objs_with_id:
@@ -727,7 +781,7 @@ class QuerySet(Generic[T]):
                 ):
                     assert len(returned_columns) == len(objs_without_id)
                 for obj_without_id, results in zip(objs_without_id, returned_columns):
-                    for result, field in zip(results, opts.db_returning_fields):
+                    for result, field in zip(results, meta.db_returning_fields):
                         setattr(obj_without_id, field.attname, result)
                     obj_without_id._state.adding = False
 
@@ -746,7 +800,7 @@ class QuerySet(Generic[T]):
         objs_tuple = tuple(objs)
         if any(obj.id is None for obj in objs_tuple):  # type: ignore[attr-defined]
             raise ValueError("All bulk_update() objects must have a primary key set.")
-        fields_list = [self.model._meta.get_field(name) for name in fields]  # type: ignore[attr-defined]
+        fields_list = [self.model._model_meta.get_field(name) for name in fields]
         if any(not f.concrete or f.many_to_many for f in fields_list):
             raise ValueError("bulk_update() can only be used with concrete fields.")
         if any(f.primary_key for f in fields_list):
@@ -856,14 +910,14 @@ class QuerySet(Generic[T]):
                 setattr(obj, k, v)
 
             update_fields = set(update_defaults)
-            concrete_field_names = self.model._meta._non_pk_concrete_field_names  # type: ignore[attr-defined]
+            concrete_field_names = self.model._model_meta._non_pk_concrete_field_names
             # update_fields does not support non-concrete fields.
             if concrete_field_names.issuperset(update_fields):
                 # Add fields which are set on pre_save(), e.g. auto_now fields.
                 # This is to maintain backward compatibility as these fields
                 # are not updated unless explicitly specified in the
                 # update_fields list.
-                for field in self.model._meta.local_concrete_fields:  # type: ignore[attr-defined]
+                for field in self.model._model_meta.local_concrete_fields:
                     if not (
                         field.primary_key or field.__class__.pre_save is Field.pre_save
                     ):
@@ -885,11 +939,11 @@ class QuerySet(Generic[T]):
         defaults = defaults or {}
         params = {k: v for k, v in kwargs.items() if LOOKUP_SEP not in k}
         params.update(defaults)
-        property_names = self.model._meta._property_names  # type: ignore[attr-defined]
+        property_names = self.model._model_meta._property_names
         invalid_params = []
         for param in params:
             try:
-                self.model._meta.get_field(param)  # type: ignore[attr-defined]
+                self.model._model_meta.get_field(param)
             except FieldDoesNotExist:
                 # It's okay to use a model's property if it has a setter.
                 if not (param in property_names and getattr(self.model, param).fset):
@@ -897,7 +951,7 @@ class QuerySet(Generic[T]):
         if invalid_params:
             raise FieldError(
                 "Invalid field name(s) for model {}: '{}'.".format(
-                    self.model._meta.object_name,  # type: ignore[attr-defined]
+                    self.model.model_options.object_name,
                     "', '".join(sorted(invalid_params)),
                 )
             )
@@ -925,15 +979,15 @@ class QuerySet(Generic[T]):
         """
         if self.sql_query.is_sliced:
             raise TypeError("Cannot use 'limit' or 'offset' with in_bulk().")
-        opts = self.model._meta  # type: ignore[attr-defined]
+        meta = self.model._model_meta
         unique_fields = [
             constraint.fields[0]
-            for constraint in opts.total_unique_constraints
+            for constraint in self.model.model_options.total_unique_constraints
             if len(constraint.fields) == 1
         ]
         if (
             field_name != "id"
-            and not opts.get_field(field_name).primary_key
+            and not meta.get_field(field_name).primary_key
             and field_name not in unique_fields
             and self.sql_query.distinct_fields != (field_name,)
         ):
@@ -1241,14 +1295,14 @@ class QuerySet(Generic[T]):
     # PUBLIC METHODS THAT ALTER ATTRIBUTES AND RETURN A NEW QUERYSET #
     ##################################################################
 
-    def all(self) -> QuerySet[T]:
+    def all(self) -> Self:
         """
         Return a new QuerySet that is a copy of the current one. This allows a
         QuerySet to proxy for a model queryset in some cases.
         """
         return self._chain()
 
-    def filter(self, *args: Any, **kwargs: Any) -> QuerySet[T]:
+    def filter(self, *args: Any, **kwargs: Any) -> Self:
         """
         Return a new QuerySet instance with the args ANDed to the existing
         set.
@@ -1256,7 +1310,7 @@ class QuerySet(Generic[T]):
         self._not_support_combined_queries("filter")
         return self._filter_or_exclude(False, args, kwargs)
 
-    def exclude(self, *args: Any, **kwargs: Any) -> QuerySet[T]:
+    def exclude(self, *args: Any, **kwargs: Any) -> Self:
         """
         Return a new QuerySet instance with NOT (args) ANDed to the existing
         set.
@@ -1266,7 +1320,7 @@ class QuerySet(Generic[T]):
 
     def _filter_or_exclude(
         self, negate: bool, args: tuple[Any, ...], kwargs: dict[str, Any]
-    ) -> QuerySet[T]:
+    ) -> Self:
         if (args or kwargs) and self.sql_query.is_sliced:
             raise TypeError("Cannot filter a query once a slice has been taken.")
         clone = self._chain()
@@ -1365,7 +1419,7 @@ class QuerySet(Generic[T]):
         obj.sql_query.select_for_no_key_update = no_key
         return obj
 
-    def select_related(self, *fields: str | None) -> QuerySet[T]:
+    def select_related(self, *fields: str | None) -> Self:
         """
         Return a new QuerySet instance that will select related objects.
 
@@ -1389,7 +1443,7 @@ class QuerySet(Generic[T]):
             obj.sql_query.select_related = True
         return obj
 
-    def prefetch_related(self, *lookups: str | Prefetch | None) -> QuerySet[T]:
+    def prefetch_related(self, *lookups: str | Prefetch | None) -> Self:
         """
         Return a new QuerySet instance that will prefetch the specified
         Many-To-One and Many-To-Many related objects when the QuerySet is
@@ -1417,7 +1471,7 @@ class QuerySet(Generic[T]):
             clone._prefetch_related_lookups = clone._prefetch_related_lookups + lookups
         return clone
 
-    def annotate(self, *args: Any, **kwargs: Any) -> QuerySet[T]:
+    def annotate(self, *args: Any, **kwargs: Any) -> Self:
         """
         Return a query set in which the returned objects have been annotated
         with extra data or aggregations.
@@ -1425,7 +1479,7 @@ class QuerySet(Generic[T]):
         self._not_support_combined_queries("annotate")
         return self._annotate(args, kwargs, select=True)
 
-    def alias(self, *args: Any, **kwargs: Any) -> QuerySet[T]:
+    def alias(self, *args: Any, **kwargs: Any) -> Self:
         """
         Return a query set with added aliases for extra data or aggregations.
         """
@@ -1434,7 +1488,7 @@ class QuerySet(Generic[T]):
 
     def _annotate(
         self, args: tuple[Any, ...], kwargs: dict[str, Any], select: bool = True
-    ) -> QuerySet[T]:
+    ) -> Self:
         self._validate_values_are_expressions(
             args + tuple(kwargs.values()), method_name="annotate"
         )
@@ -1460,7 +1514,7 @@ class QuerySet(Generic[T]):
                     (field.name, field.attname)
                     if hasattr(field, "attname")
                     else (field.name,)
-                    for field in self.model._meta.get_fields()  # type: ignore[attr-defined]
+                    for field in self.model._model_meta.get_fields()
                 )
             )
 
@@ -1487,7 +1541,7 @@ class QuerySet(Generic[T]):
 
         return clone
 
-    def order_by(self, *field_names: str) -> QuerySet[T]:
+    def order_by(self, *field_names: str) -> Self:
         """Return a new QuerySet instance with the ordering changed."""
         if self.sql_query.is_sliced:
             raise TypeError("Cannot reorder a query once a slice has been taken.")
@@ -1496,7 +1550,7 @@ class QuerySet(Generic[T]):
         obj.sql_query.add_ordering(*field_names)
         return obj
 
-    def distinct(self, *field_names: str) -> QuerySet[T]:
+    def distinct(self, *field_names: str) -> Self:
         """
         Return a new QuerySet instance that will select only distinct results.
         """
@@ -1590,7 +1644,7 @@ class QuerySet(Generic[T]):
             return True
         elif (
             self.sql_query.default_ordering
-            and self.sql_query.get_meta().ordering
+            and self.sql_query.get_model_meta().ordering
             and
             # A default ordering doesn't affect GROUP BY queries.
             not self.sql_query.group_by
@@ -1650,7 +1704,7 @@ class QuerySet(Generic[T]):
                     self._insert(
                         item,
                         fields=fields,
-                        returning_fields=self.model._meta.db_returning_fields,  # type: ignore[attr-defined]
+                        returning_fields=self.model._model_meta.db_returning_fields,
                     )
                 )
             else:
@@ -1663,7 +1717,7 @@ class QuerySet(Generic[T]):
                 )
         return inserted_rows
 
-    def _chain(self) -> QuerySet[T]:
+    def _chain(self) -> Self:
         """
         Return a copy of the current QuerySet that's ready for another
         operation.
@@ -1674,12 +1728,12 @@ class QuerySet(Generic[T]):
             obj._sticky_filter = False
         return obj
 
-    def _clone(self) -> QuerySet[T]:
+    def _clone(self) -> Self:
         """
         Return a copy of the current QuerySet. A lightweight alternative
         to deepcopy().
         """
-        c = self.__class__(
+        c = self.__class__.from_model(
             model=self.model,
             query=self.sql_query.chain(),
         )
@@ -1817,7 +1871,7 @@ class RawQuerySet:
         converter = db_connection.introspection.identifier_converter
         model_init_fields = [
             f
-            for f in self.model._meta.fields  # type: ignore[attr-defined]
+            for f in self.model._model_meta.fields
             if converter(f.column) in self.columns
         ]
         annotation_fields = [
@@ -1906,7 +1960,7 @@ class RawQuerySet:
         """A dict mapping column names to model field names."""
         converter = db_connection.introspection.identifier_converter
         model_fields = {}
-        for field in self.model._meta.fields:  # type: ignore[attr-defined]
+        for field in self.model._model_meta.fields:
             name, column = field.get_attname_column()
             model_fields[converter(column)] = field
         return model_fields
@@ -2268,7 +2322,7 @@ def prefetch_one_level(
         # of prefetch_related), so what applies to first object applies to all.
         model = instances[0].__class__
         try:
-            model._meta.get_field(to_attr)
+            model._model_meta.get_field(to_attr)
         except FieldDoesNotExist:
             pass
         else:
@@ -2308,7 +2362,7 @@ def prefetch_one_level(
                     # We need a QuerySet instance to cache the prefetched values
                     if isinstance(queryset, QuerySet):
                         # It's already a QuerySet, create a new instance
-                        qs = queryset.__class__(model=queryset.model)
+                        qs = queryset.__class__.from_model(queryset.model)
                     else:
                         # It's a related manager, get its QuerySet
                         # The manager's query property returns a properly filtered QuerySet

plain/models/query_utils.py

@@ -22,16 +22,19 @@ from plain.utils import tree
 
 if TYPE_CHECKING:
     from plain.models.backends.base.base import BaseDatabaseWrapper
+    from plain.models.base import Model
+    from plain.models.fields import Field
+    from plain.models.meta import Meta
     from plain.models.sql.compiler import SQLCompiler
 
 logger = logging.getLogger("plain.models")
 
 # PathInfo is used when converting lookups (fk__somecol). The contents
-# describe the relation in Model terms (model Options and Fields for both
-# sides of the relation. The join_field is the field backing the relation.
+# describe the relation in Model terms (Meta and Fields for both
+# sides of the relation). The join_field is the field backing the relation.
 PathInfo = namedtuple(
     "PathInfo",
-    "from_opts to_opts target_fields join_field m2m direct filtered_relation",
+    "from_meta to_meta target_fields join_field m2m direct filtered_relation",
 )
 
 
@@ -360,7 +363,7 @@ def select_related_descend(
         and field not in select_mask
     ):
         raise FieldError(
-            f"Field {field.model._meta.object_name}.{field.name} cannot be both "
+            f"Field {field.model.model_options.object_name}.{field.name} cannot be both "
             "deferred and traversed using select_related at the same time."
         )
     return True
@@ -381,16 +384,18 @@ def refs_expression(
     return None, ()
 
 
-def check_rel_lookup_compatibility(model: type, target_opts: Any, field: Any) -> bool:
+def check_rel_lookup_compatibility(
+    model: type[Model], target_meta: Meta, field: Field
+) -> bool:
     """
-    Check that self.model is compatible with target_opts. Compatibility
+    Check that model is compatible with target_meta. Compatibility
     is OK if:
-      1) model and opts match (where proxy inheritance is removed)
-      2) model is parent of opts' model or the other way around
+      1) model and meta.model match (where proxy inheritance is removed)
+      2) model is parent of meta's model or the other way around
     """
 
-    def check(opts: Any) -> bool:
-        return model == opts.model
+    def check(meta: Meta) -> bool:
+        return model == meta.model
 
     # If the field is a primary key, then doing a query against the field's
     # model is ok, too. Consider the case:
@@ -398,11 +403,11 @@ def check_rel_lookup_compatibility(model: type, target_opts: Any, field: Any) ->
     #     place = OneToOneField(Place, primary_key=True):
     # Restaurant.query.filter(id__in=Restaurant.query.all()).
     # If we didn't have the primary key check, then id__in (== place__in) would
-    # give Place's opts as the target opts, but Restaurant isn't compatible
+    # give Place's meta as the target meta, but Restaurant isn't compatible
     # with that. This logic applies only to primary keys, as when doing __in=qs,
     # we are going to turn this into __in=qs.values('id') later on.
-    return check(target_opts) or (
-        getattr(field, "primary_key", False) and check(field.model._meta)
+    return check(target_meta) or (
+        getattr(field, "primary_key", False) and check(field.model._model_meta)
     )
 
 

plain/models/registry.py

@@ -107,7 +107,7 @@ class ModelsRegistry:
         # Since this method is called when models are imported, it cannot
         # perform imports because of the risk of import loops. It mustn't
         # call get_package_config().
-        model_name = model._meta.model_name
+        model_name = model.model_options.model_name
         app_models = self.all_models[package_label]
         if model_name in app_models:
             if (
@@ -156,7 +156,7 @@ class ModelsRegistry:
             # This particularly prevents that an empty value is cached while cloning.
             for package_models in self.all_models.values():
                 for model in package_models.values():
-                    model._meta._expire_cache()
+                    model._model_meta._expire_cache()
 
     def lazy_model_operation(
         self, function: Callable[..., None], *model_keys: tuple[str, str]
@@ -205,7 +205,7 @@ class ModelsRegistry:
         Take a newly-prepared model and pass it to each function waiting for
         it. This is called at the very end of Models.register_model().
         """
-        key = model._meta.package_label, model._meta.model_name
+        key = model.model_options.package_label, model.model_options.model_name
         for function in self._pending_operations.pop(key, []):
             function(model)
 
@@ -215,7 +215,8 @@ models_registry = ModelsRegistry()
 
 # Decorator to register a model (using the internal registry for the correct state).
 def register_model(model_class: M) -> M:
-    model_class._meta.models_registry.register_model(
-        model_class._meta.package_label, model_class
+    model_class._model_meta.models_registry.register_model(
+        model_class.model_options.package_label,
+        model_class,  # type: ignore[arg-type]
     )
     return model_class