scim2-models 0.3.5__py3-none-any.whl → 0.3.7__py3-none-any.whl

scim2_models/rfc7643/resource.py

@@ -1,31 +1,41 @@
 from datetime import datetime
+from typing import TYPE_CHECKING
 from typing import Annotated
 from typing import Any
 from typing import Generic
 from typing import Optional
 from typing import TypeVar
 from typing import Union
+from typing import cast
 from typing import get_args
 from typing import get_origin
 
 from pydantic import Field
+from pydantic import SerializationInfo
+from pydantic import SerializerFunctionWrapHandler
 from pydantic import WrapSerializer
 from pydantic import field_serializer
 
+from ..annotations import CaseExact
+from ..annotations import Mutability
+from ..annotations import Required
+from ..annotations import Returned
+from ..annotations import Uniqueness
+from ..attributes import ComplexAttribute
+from ..attributes import MultiValuedComplexAttribute
+from ..attributes import is_complex_attribute
 from ..base import BaseModel
-from ..base import BaseModelType
-from ..base import CaseExact
-from ..base import ComplexAttribute
-from ..base import ExternalReference
-from ..base import MultiValuedComplexAttribute
-from ..base import Mutability
-from ..base import Required
-from ..base import Returned
-from ..base import Uniqueness
-from ..base import URIReference
-from ..base import is_complex_attribute
+from ..context import Context
+from ..reference import Reference
+from ..scim_object import ScimObject
+from ..scim_object import validate_attribute_urn
+from ..utils import UNION_TYPES
 from ..utils import normalize_attribute_name
 
+if TYPE_CHECKING:
+    from .schema import Attribute
+    from .schema import Schema
+
 
 class Meta(ComplexAttribute):
     """All "meta" sub-attributes are assigned by the service provider (have a "mutability" of "readOnly"), and all of these sub-attributes have a "returned" characteristic of "default".
@@ -78,14 +88,14 @@ class Meta(ComplexAttribute):
     """
 
 
-class Extension(BaseModel):
+class Extension(ScimObject):
     @classmethod
-    def to_schema(cls):
+    def to_schema(cls) -> "Schema":
         """Build a :class:`~scim2_models.Schema` from the current extension class."""
         return model_to_schema(cls)
 
     @classmethod
-    def from_schema(cls, schema) -> "Extension":
+    def from_schema(cls, schema: "Schema") -> type["Extension"]:
         """Build a :class:`~scim2_models.Extension` subclass from the schema definition."""
         from .schema import make_python_model
 
@@ -94,14 +104,18 @@ class Extension(BaseModel):
 
 AnyExtension = TypeVar("AnyExtension", bound="Extension")
 
+_PARAMETERIZED_CLASSES: dict[tuple[type, tuple[Any, ...]], type] = {}
+
 
-def extension_serializer(value: Any, handler, info) -> Optional[dict[str, Any]]:
+def extension_serializer(
+    value: Any, handler: SerializerFunctionWrapHandler, info: SerializationInfo
+) -> Optional[dict[str, Any]]:
     """Exclude the Resource attributes from the extension dump.
 
     For instance, attributes 'meta', 'id' or 'schemas' should not be
     dumped when the model is used as an extension for another model.
     """
-    partial_result = handler(value, info)
+    partial_result = handler(value)
     result = {
         attr_name: value
         for attr_name, value in partial_result.items()
@@ -110,39 +124,7 @@ def extension_serializer(value: Any, handler, info) -> Optional[dict[str, Any]]:
     return result or None
 
 
-class ResourceMetaclass(BaseModelType):
-    def __new__(cls, name, bases, attrs, **kwargs):
-        """Dynamically add a field for each extension."""
-        if "__pydantic_generic_metadata__" in kwargs:
-            extensions = kwargs["__pydantic_generic_metadata__"]["args"][0]
-            extensions = (
-                get_args(extensions)
-                if get_origin(extensions) == Union
-                else [extensions]
-            )
-            for extension in extensions:
-                schema = extension.model_fields["schemas"].default[0]
-                attrs.setdefault("__annotations__", {})[extension.__name__] = Annotated[
-                    Optional[extension],
-                    WrapSerializer(extension_serializer),
-                ]
-                attrs[extension.__name__] = Field(
-                    None,
-                    serialization_alias=schema,
-                    validation_alias=normalize_attribute_name(schema),
-                )
-
-        klass = super().__new__(cls, name, bases, attrs, **kwargs)
-        return klass
-
-
-class Resource(BaseModel, Generic[AnyExtension], metaclass=ResourceMetaclass):
-    schemas: Annotated[list[str], Required.true]
-    """The "schemas" attribute is a REQUIRED attribute and is an array of
-    Strings containing URIs that are used to indicate the namespaces of the
-    SCIM schemas that define the attributes present in the current JSON
-    structure."""
-
+class Resource(ScimObject, Generic[AnyExtension]):
     # Common attributes as defined by
     # https://www.rfc-editor.org/rfc/rfc7643#section-3.1
 
@@ -165,13 +147,74 @@ class Resource(BaseModel, Generic[AnyExtension], metaclass=ResourceMetaclass):
     meta: Annotated[Optional[Meta], Mutability.read_only, Returned.default] = None
     """A complex attribute containing resource metadata."""
 
-    def __getitem__(self, item: Any):
+    @classmethod
+    def __class_getitem__(cls, item: Any) -> type["Resource"]:
+        """Create a Resource class with extension fields dynamically added."""
+        if hasattr(cls, "__scim_extension_metadata__"):
+            return cls
+
+        extensions = get_args(item) if get_origin(item) in UNION_TYPES else [item]
+
+        # Skip TypeVar parameters and Any (used for generic class definitions)
+        valid_extensions = [
+            extension
+            for extension in extensions
+            if not isinstance(extension, TypeVar) and extension is not Any
+        ]
+
+        if not valid_extensions:
+            return cls
+
+        cache_key = (cls, tuple(valid_extensions))
+        if cache_key in _PARAMETERIZED_CLASSES:
+            return _PARAMETERIZED_CLASSES[cache_key]
+
+        for extension in valid_extensions:
+            if not (isinstance(extension, type) and issubclass(extension, Extension)):
+                raise TypeError(f"{extension} is not a valid Extension type")
+
+        class_name = (
+            f"{cls.__name__}[{', '.join(ext.__name__ for ext in valid_extensions)}]"
+        )
+
+        class_attrs = {"__scim_extension_metadata__": valid_extensions}
+
+        for extension in valid_extensions:
+            schema = extension.model_fields["schemas"].default[0]
+            class_attrs[extension.__name__] = Field(
+                default=None,  # type: ignore[arg-type]
+                serialization_alias=schema,
+                validation_alias=normalize_attribute_name(schema),
+            )
+
+        new_annotations = {
+            extension.__name__: Annotated[
+                Optional[extension],
+                WrapSerializer(extension_serializer),
+            ]
+            for extension in valid_extensions
+        }
+
+        new_class = type(
+            class_name,
+            (cls,),
+            {
+                "__annotations__": new_annotations,
+                **class_attrs,
+            },
+        )
+
+        _PARAMETERIZED_CLASSES[cache_key] = new_class
+
+        return new_class
+
+    def __getitem__(self, item: Any) -> Optional[Extension]:
         if not isinstance(item, type) or not issubclass(item, Extension):
             raise KeyError(f"{item} is not a valid extension type")
 
-        return getattr(self, item.__name__)
+        return cast(Optional[Extension], getattr(self, item.__name__))
 
-    def __setitem__(self, item: Any, value: "Resource"):
+    def __setitem__(self, item: Any, value: "Extension") -> None:
         if not isinstance(item, type) or not issubclass(item, Extension):
             raise KeyError(f"{item} is not a valid extension type")
 
@@ -180,20 +223,16 @@ class Resource(BaseModel, Generic[AnyExtension], metaclass=ResourceMetaclass):
     @classmethod
     def get_extension_models(cls) -> dict[str, type[Extension]]:
         """Return extension a dict associating extension models with their schemas."""
-        extension_models = cls.__pydantic_generic_metadata__.get("args", [])
-        extension_models = (
-            get_args(extension_models[0])
-            if len(extension_models) == 1 and get_origin(extension_models[0]) == Union
-            else extension_models
-        )
-
+        extension_models = getattr(cls, "__scim_extension_metadata__", [])
         by_schema = {
             ext.model_fields["schemas"].default[0]: ext for ext in extension_models
         }
         return by_schema
 
     @classmethod
-    def get_extension_model(cls, name_or_schema) -> Optional[type[Extension]]:
+    def get_extension_model(
+        cls, name_or_schema: Union[str, "Schema"]
+    ) -> Optional[type[Extension]]:
         """Return an extension by its name or schema."""
         for schema, extension in cls.get_extension_models().items():
             if schema == name_or_schema or extension.__name__ == name_or_schema:
@@ -202,15 +241,17 @@ class Resource(BaseModel, Generic[AnyExtension], metaclass=ResourceMetaclass):
 
     @staticmethod
     def get_by_schema(
-        resource_types: list[type[BaseModel]], schema: str, with_extensions=True
-    ) -> Optional[type]:
+        resource_types: list[type["Resource"]],
+        schema: str,
+        with_extensions: bool = True,
+    ) -> Optional[Union[type["Resource"], type["Extension"]]]:
         """Given a resource type list and a schema, find the matching resource type."""
-        by_schema = {
+        by_schema: dict[str, Union[type[Resource], type[Extension]]] = {
             resource_type.model_fields["schemas"].default[0].lower(): resource_type
             for resource_type in (resource_types or [])
         }
         if with_extensions:
-            for resource_type in list(by_schema.values()):
+            for resource_type in resource_types:
                 by_schema.update(
                     {
                         schema.lower(): extension
@@ -221,7 +262,11 @@ class Resource(BaseModel, Generic[AnyExtension], metaclass=ResourceMetaclass):
         return by_schema.get(schema.lower())
 
     @staticmethod
-    def get_by_payload(resource_types: list[type], payload: dict, **kwargs):
+    def get_by_payload(
+        resource_types: list[type["Resource"]],
+        payload: dict[str, Any],
+        **kwargs: Any,
+    ) -> Optional[type]:
         """Given a resource type list and a payload, find the matching resource type."""
         if not payload or not payload.get("schemas"):
             return None
@@ -230,7 +275,9 @@ class Resource(BaseModel, Generic[AnyExtension], metaclass=ResourceMetaclass):
         return Resource.get_by_schema(resource_types, schema, **kwargs)
 
     @field_serializer("schemas")
-    def set_extension_schemas(self, schemas: Annotated[list[str], Required.true]):
+    def set_extension_schemas(
+        self, schemas: Annotated[list[str], Required.true]
+    ) -> list[str]:
         """Add model extension ids to the 'schemas' attribute."""
         extension_schemas = self.get_extension_models().keys()
         schemas = self.schemas + [
@@ -239,25 +286,95 @@ class Resource(BaseModel, Generic[AnyExtension], metaclass=ResourceMetaclass):
         return schemas
 
     @classmethod
-    def to_schema(cls):
+    def to_schema(cls) -> "Schema":
         """Build a :class:`~scim2_models.Schema` from the current resource class."""
         return model_to_schema(cls)
 
     @classmethod
-    def from_schema(cls, schema) -> "Resource":
+    def from_schema(cls, schema: "Schema") -> type["Resource"]:
         """Build a :class:`scim2_models.Resource` subclass from the schema definition."""
         from .schema import make_python_model
 
         return make_python_model(schema, cls)
 
+    def _prepare_model_dump(
+        self,
+        scim_ctx: Optional[Context] = Context.DEFAULT,
+        attributes: Optional[list[str]] = None,
+        excluded_attributes: Optional[list[str]] = None,
+        **kwargs: Any,
+    ) -> dict[str, Any]:
+        kwargs = super()._prepare_model_dump(scim_ctx, **kwargs)
+        kwargs["context"]["scim_attributes"] = [
+            validate_attribute_urn(attribute, self.__class__)
+            for attribute in (attributes or [])
+        ]
+        kwargs["context"]["scim_excluded_attributes"] = [
+            validate_attribute_urn(attribute, self.__class__)
+            for attribute in (excluded_attributes or [])
+        ]
+        return kwargs
+
+    def model_dump(
+        self,
+        *args: Any,
+        scim_ctx: Optional[Context] = Context.DEFAULT,
+        attributes: Optional[list[str]] = None,
+        excluded_attributes: Optional[list[str]] = None,
+        **kwargs: Any,
+    ) -> dict[str, Any]:
+        """Create a model representation that can be included in SCIM messages by using Pydantic :code:`BaseModel.model_dump`.
+
+        :param scim_ctx: If a SCIM context is passed, some default values of
+            Pydantic :code:`BaseModel.model_dump` are tuned to generate valid SCIM
+            messages. Pass :data:`None` to get the default Pydantic behavior.
+        :param attributes: A multi-valued list of strings indicating the names of resource
+            attributes to return in the response, overriding the set of attributes that
+            would be returned by default.
+        :param excluded_attributes: A multi-valued list of strings indicating the names of resource
+            attributes to be removed from the default set of attributes to return.
+        """
+        dump_kwargs = self._prepare_model_dump(
+            scim_ctx, attributes, excluded_attributes, **kwargs
+        )
+        if scim_ctx:
+            dump_kwargs.setdefault("mode", "json")
+        return super(ScimObject, self).model_dump(*args, **dump_kwargs)
+
+    def model_dump_json(
+        self,
+        *args: Any,
+        scim_ctx: Optional[Context] = Context.DEFAULT,
+        attributes: Optional[list[str]] = None,
+        excluded_attributes: Optional[list[str]] = None,
+        **kwargs: Any,
+    ) -> str:
+        """Create a JSON model representation that can be included in SCIM messages by using Pydantic :code:`BaseModel.model_dump_json`.
+
+        :param scim_ctx: If a SCIM context is passed, some default values of
+            Pydantic :code:`BaseModel.model_dump` are tuned to generate valid SCIM
+            messages. Pass :data:`None` to get the default Pydantic behavior.
+        :param attributes: A multi-valued list of strings indicating the names of resource
+            attributes to return in the response, overriding the set of attributes that
+            would be returned by default.
+        :param excluded_attributes: A multi-valued list of strings indicating the names of resource
+            attributes to be removed from the default set of attributes to return.
+        """
+        dump_kwargs = self._prepare_model_dump(
+            scim_ctx, attributes, excluded_attributes, **kwargs
+        )
+        return super(ScimObject, self).model_dump_json(*args, **dump_kwargs)
+
 
 AnyResource = TypeVar("AnyResource", bound="Resource")
 
 
-def dedicated_attributes(model, excluded_models):
+def dedicated_attributes(
+    model: type[BaseModel], excluded_models: list[type[BaseModel]]
+) -> dict[str, Any]:
     """Return attributes that are not members the parent 'excluded_models'."""
 
-    def compare_field_infos(fi1, fi2):
+    def compare_field_infos(fi1: Any, fi2: Any) -> bool:
         return (
             fi1
             and fi2
@@ -280,13 +397,13 @@ def dedicated_attributes(model, excluded_models):
     return field_infos
 
 
-def model_to_schema(model: type[BaseModel]):
+def model_to_schema(model: type[BaseModel]) -> "Schema":
     from scim2_models.rfc7643.schema import Schema
 
     schema_urn = model.model_fields["schemas"].default[0]
     field_infos = dedicated_attributes(model, [Resource])
     attributes = [
-        model_attribute_to_attribute(model, attribute_name)
+        model_attribute_to_scim_attribute(model, attribute_name)
         for attribute_name in field_infos
         if attribute_name != "schemas"
     ]
@@ -299,46 +416,37 @@ def model_to_schema(model: type[BaseModel]):
     return schema
 
 
-def get_reference_types(type) -> list[str]:
-    first_arg = get_args(type)[0]
-    types = get_args(first_arg) if get_origin(first_arg) == Union else [first_arg]
-
-    def serialize_ref_type(ref_type):
-        if ref_type == URIReference:
-            return "uri"
-
-        elif ref_type == ExternalReference:
-            return "external"
-
-        return get_args(ref_type)[0]
-
-    return list(map(serialize_ref_type, types))
-
-
-def model_attribute_to_attribute(model, attribute_name):
+def model_attribute_to_scim_attribute(
+    model: type[BaseModel], attribute_name: str
+) -> "Attribute":
     from scim2_models.rfc7643.schema import Attribute
 
     field_info = model.model_fields[attribute_name]
     root_type = model.get_field_root_type(attribute_name)
+    if root_type is None:
+        raise ValueError(
+            f"Could not determine root type for attribute {attribute_name}"
+        )
     attribute_type = Attribute.Type.from_python(root_type)
     sub_attributes = (
         [
-            model_attribute_to_attribute(root_type, sub_attribute_name)
+            model_attribute_to_scim_attribute(root_type, sub_attribute_name)
             for sub_attribute_name in dedicated_attributes(
-                root_type, [MultiValuedComplexAttribute]
+                root_type,
+                [MultiValuedComplexAttribute],
             )
             if (
                 attribute_name != "sub_attributes"
                 or sub_attribute_name != "sub_attributes"
             )
         ]
-        if is_complex_attribute(root_type)
+        if root_type and is_complex_attribute(root_type)
         else None
     )
 
     return Attribute(
         name=field_info.serialization_alias or attribute_name,
-        type=attribute_type,
+        type=Attribute.Type(attribute_type),
         multi_valued=model.get_field_multiplicity(attribute_name),
         description=field_info.description,
         canonical_values=field_info.examples,
@@ -348,7 +456,7 @@ def model_attribute_to_attribute(model, attribute_name):
         returned=model.get_field_annotation(attribute_name, Returned),
         uniqueness=model.get_field_annotation(attribute_name, Uniqueness),
         sub_attributes=sub_attributes,
-        reference_types=get_reference_types(root_type)
+        reference_types=Reference.get_types(root_type)
         if attribute_type == Attribute.Type.reference
         else None,
     )

scim2_models/rfc7643/resource_type.py

@@ -4,13 +4,13 @@ from typing import Optional
 from pydantic import Field
 from typing_extensions import Self
 
-from ..base import CaseExact
-from ..base import ComplexAttribute
-from ..base import Mutability
-from ..base import Reference
-from ..base import Required
-from ..base import Returned
-from ..base import URIReference
+from ..annotations import CaseExact
+from ..annotations import Mutability
+from ..annotations import Required
+from ..annotations import Returned
+from ..attributes import ComplexAttribute
+from ..reference import Reference
+from ..reference import URIReference
 from .resource import Resource
 
 
@@ -82,12 +82,15 @@ class ResourceType(Resource):
         """Build a naive ResourceType from a resource model."""
         schema = resource_model.model_fields["schemas"].default[0]
         name = schema.split(":")[-1]
-        extensions = resource_model.__pydantic_generic_metadata__["args"]
-        return ResourceType(
+
+        # Get extensions from the metadata system
+        extensions = getattr(resource_model, "__scim_extension_metadata__", [])
+
+        return cls(
             id=name,
             name=name,
             description=name,
-            endpoint=f"/{name}s",
+            endpoint=Reference[URIReference](f"/{name}s"),
             schema_=schema,
             schema_extensions=[
                 SchemaExtension(

scim2_models/rfc7643/schema.py

@@ -6,6 +6,7 @@ from typing import Any
 from typing import List  # noqa : UP005,UP035
 from typing import Literal
 from typing import Optional
+from typing import TypeVar
 from typing import Union
 from typing import get_origin
 
@@ -16,24 +17,25 @@ from pydantic.alias_generators import to_pascal
 from pydantic.alias_generators import to_snake
 from pydantic_core import Url
 
+from ..annotations import CaseExact
+from ..annotations import Mutability
+from ..annotations import Required
+from ..annotations import Returned
+from ..annotations import Uniqueness
+from ..attributes import ComplexAttribute
+from ..attributes import MultiValuedComplexAttribute
+from ..attributes import is_complex_attribute
 from ..base import BaseModel
-from ..base import CaseExact
-from ..base import ComplexAttribute
-from ..base import ExternalReference
-from ..base import MultiValuedComplexAttribute
-from ..base import Mutability
-from ..base import Reference
-from ..base import Required
-from ..base import Returned
-from ..base import Uniqueness
-from ..base import URIReference
-from ..base import is_complex_attribute
 from ..constants import RESERVED_WORDS
+from ..reference import ExternalReference
+from ..reference import Reference
+from ..reference import URIReference
 from ..utils import Base64Bytes
 from ..utils import normalize_attribute_name
-from .resource import Extension
 from .resource import Resource
 
+T = TypeVar("T", bound=BaseModel)
+
 
 def make_python_identifier(identifier: str) -> str:
     """Sanitize string to be a suitable Python/Pydantic class attribute name."""
@@ -46,9 +48,9 @@ def make_python_identifier(identifier: str) -> str:
 
 def make_python_model(
     obj: Union["Schema", "Attribute"],
-    base: Optional[type[BaseModel]] = None,
-    multiple=False,
-) -> Union[Resource, Extension]:
+    base: type[T],
+    multiple: bool = False,
+) -> type[T]:
     """Build a Python model from a Schema or an Attribute object."""
     if isinstance(obj, Attribute):
         pydantic_attributes = {
@@ -56,7 +58,6 @@ def make_python_model(
             for attr in (obj.sub_attributes or [])
             if attr.name
         }
-        base = MultiValuedComplexAttribute if multiple else ComplexAttribute
 
     else:
         pydantic_attributes = {
@@ -69,14 +70,17 @@ def make_python_model(
             Field(default=[obj.id]),
         )
 
+    if not obj.name:
+        raise ValueError("Schema or Attribute 'name' must be defined")
+
     model_name = to_pascal(to_snake(obj.name))
-    model = create_model(model_name, __base__=base, **pydantic_attributes)
+    model: type[T] = create_model(model_name, __base__=base, **pydantic_attributes)  # type: ignore[call-overload]
 
     # Set the ComplexType class as a member of the model
     # e.g. make Member an attribute of Group
     for attr_name in model.model_fields:
         attr_type = model.get_field_root_type(attr_name)
-        if is_complex_attribute(attr_type):
+        if attr_type and is_complex_attribute(attr_type):
             setattr(model, attr_type.__name__, attr_type)
 
     return model
@@ -95,7 +99,7 @@ class Attribute(ComplexAttribute):
 
         def to_python(
             self,
-            multiple=False,
+            multiple: bool = False,
             reference_types: Optional[list[str]] = None,
         ) -> type:
             if self.value == self.reference and reference_types is not None:
@@ -122,32 +126,32 @@ class Attribute(ComplexAttribute):
             return attr_types[self.value]
 
         @classmethod
-        def from_python(cls, pytype) -> str:
+        def from_python(cls, pytype: type) -> "Attribute.Type":
             if get_origin(pytype) == Reference:
-                return cls.reference.value
+                return cls.reference
 
-            if is_complex_attribute(pytype):
-                return cls.complex.value
+            if pytype and is_complex_attribute(pytype):
+                return cls.complex
 
             if pytype in (Required, CaseExact):
-                return cls.boolean.value
+                return cls.boolean
 
             attr_types = {
-                str: cls.string.value,
-                bool: cls.boolean.value,
-                float: cls.decimal.value,
-                int: cls.integer.value,
-                datetime: cls.date_time.value,
-                Base64Bytes: cls.binary.value,
+                str: cls.string,
+                bool: cls.boolean,
+                float: cls.decimal,
+                int: cls.integer,
+                datetime: cls.date_time,
+                Base64Bytes: cls.binary,
             }
-            return attr_types.get(pytype, cls.string.value)
+            return attr_types.get(pytype, cls.string)
 
     name: Annotated[
         Optional[str], Mutability.read_only, Required.true, CaseExact.true
     ] = None
     """The attribute's name."""
 
-    type: Annotated[Type, Mutability.read_only, Required.true] = Field(
+    type: Annotated[Optional[Type], Mutability.read_only, Required.true] = Field(
         None, examples=[item.value for item in Type]
     )
     """The attribute's data type."""
@@ -206,15 +210,17 @@ class Attribute(ComplexAttribute):
     """When an attribute is of type "complex", "subAttributes" defines a set of
     sub-attributes."""
 
-    def to_python(self) -> Optional[tuple[Any, Field]]:
+    def to_python(self) -> Optional[tuple[Any, Any]]:
         """Build tuple suited to be passed to pydantic 'create_model'."""
-        if not self.name:
+        if not self.name or not self.type:
             return None
 
-        attr_type = self.type.to_python(self.multi_valued, self.reference_types)
+        attr_type = self.type.to_python(bool(self.multi_valued), self.reference_types)
 
         if attr_type in (ComplexAttribute, MultiValuedComplexAttribute):
-            attr_type = make_python_model(obj=self, multiple=self.multi_valued)
+            attr_type = make_python_model(
+                obj=self, base=attr_type, multiple=bool(self.multi_valued)
+            )
 
         if self.multi_valued:
             attr_type = list[attr_type]  # type: ignore
@@ -245,7 +251,7 @@ class Attribute(ComplexAttribute):
                 return sub_attribute
         return None
 
-    def __getitem__(self, name):
+    def __getitem__(self, name: str) -> "Attribute":
         """Find an attribute by its name."""
         if attribute := self.get_attribute(name):
             return attribute
@@ -287,7 +293,7 @@ class Schema(Resource):
                 return attribute
         return None
 
-    def __getitem__(self, name):
+    def __getitem__(self, name: str) -> "Attribute":  # type: ignore[override]
         """Find an attribute by its name."""
         if attribute := self.get_attribute(name):
             return attribute