chore: use ruff instead of docformatter

Author: azmeuk

.pre-commit-config.yaml

@@ -15,10 +15,6 @@ repos:
       - id: end-of-file-fixer
         exclude: "\\.svg$|\\.map$|\\.min\\.css$|\\.min\\.js$|\\.po$|\\.pot$"
       - id: check-toml
-  - repo: https://github.com/PyCQA/docformatter
-    rev: v1.7.5
-    hooks:
-      - id: docformatter
   - repo: https://github.com/pre-commit/mirrors-mypy
     rev: v1.11.2
     hooks:

pyproject.toml

@@ -68,6 +68,7 @@ exclude_lines = [
 
 [tool.ruff.lint]
 select = [
+    "D", # pydocstyle
     "E", # pycodestyle
     "F", # pyflakes
     "I", # isort
@@ -76,6 +77,16 @@ select = [
 ignore = [
     "E501", # line-too-long
     "E722", # bare-except
+    "D100", # public module
+    "D101", # public class
+    "D102", # public method
+    "D103", # public function
+    "D104", # public package
+    "D105", # magic method
+    "D106", # nested class
+    "D107", # public init
+    "D203", # no-blank-line-before-class
+    "D213", # multi-line-summary-second-line
 ]
 
 [tool.ruff.lint.isort]

scim2_models/base.py

@@ -38,9 +38,7 @@
 
 
 def validate_model_attribute(model: type["BaseModel"], attribute_base: str) -> None:
-    """Validate that an attribute name or a sub-attribute path exist for a
-    given model."""
-
+    """Validate that an attribute name or a sub-attribute path exist for a given model."""
     from scim2_models.base import BaseModel
 
     attribute_name, *sub_attribute_blocks = attribute_base.split(".")
@@ -85,7 +83,6 @@ def validate_attribute_urn(
     :resource_types: The available resources in which to look for the attribute.
     :return: The normalized attribute URN.
     """
-
     from scim2_models.rfc7643.resource import Resource
 
     if not resource_types:
@@ -133,6 +130,7 @@ class Reference(UserString, Generic[ReferenceTypes]):
         - :data:`~scim2_models.URIReference`
 
     Examples
+    --------
 
     .. code-block:: python
 
@@ -141,6 +139,7 @@ class Foobar(Resource):
             managers: Reference[Union["User", "Group"]]
             photo: Reference[ExternalReference]
             website: Reference[URIReference]
+
     """
 
     @classmethod
@@ -159,8 +158,7 @@ def _validate(cls, input_value: str, /) -> str:
 
 
 class Context(Enum):
-    """Represent the different HTTP contexts detailed in :rfc:`RFC7644 §3.2
-    <7644#section-3.2>`
+    """Represent the different HTTP contexts detailed in :rfc:`RFC7644 §3.2 <7644#section-3.2>`.
 
     Contexts are intended to be used during model validation and serialization.
     For instance a client preparing a resource creation POST request can use
@@ -298,8 +296,7 @@ def is_response(cls, ctx: "Context") -> bool:
 
 
 class Mutability(str, Enum):
-    """A single keyword indicating the circumstances under which the value of
-    the attribute can be (re)defined:"""
+    """A single keyword indicating the circumstances under which the value of the attribute can be (re)defined."""
 
     read_only = "readOnly"
     """The attribute SHALL NOT be modified."""
@@ -326,9 +323,7 @@ class Mutability(str, Enum):
 
 
 class Returned(str, Enum):
-    """A single keyword that indicates when an attribute and associated values
-    are returned in response to a GET request or in response to a PUT, POST, or
-    PATCH request."""
+    """A single keyword that indicates when an attribute and associated values are returned in response to a GET request or in response to a PUT, POST, or PATCH request."""
 
     always = "always"  # cannot be excluded
     """The attribute is always returned, regardless of the contents of the
@@ -353,8 +348,7 @@ class Returned(str, Enum):
 
 
 class Uniqueness(str, Enum):
-    """A single keyword value that specifies how the service provider enforces
-    uniqueness of attribute values."""
+    """A single keyword value that specifies how the service provider enforces uniqueness of attribute values."""
 
     none = "none"
     """The values are not intended to be unique in any way."""
@@ -393,8 +387,7 @@ def __bool__(self):
 
 
 class CaseExact(Enum):
-    """A Boolean value that specifies whether a string attribute is case-
-    sensitive or not."""
+    """A Boolean value that specifies whether a string attribute is case- sensitive or not."""
 
     true = True
     false = False
@@ -421,8 +414,7 @@ class BaseModel(PydanticBaseModel):
 
     @classmethod
     def get_field_annotation(cls, field_name: str, annotation_type: type) -> Any:
-        """Return the annotation of type 'annotation_type' of the field
-        'field_name'."""
+        """Return the annotation of type 'annotation_type' of the field 'field_name'."""
         field_metadata = cls.model_fields[field_name].metadata
 
         default_value = getattr(annotation_type, "_default", None)
@@ -442,7 +434,6 @@ def get_field_root_type(cls, attribute_name: str) -> type:
         For example, return 'GroupMember' for
         'Optional[List[GroupMember]]'
         """
-
         attribute_type = cls.model_fields[attribute_name].annotation
 
         # extract 'x' from 'Optional[x]'
@@ -462,10 +453,7 @@ def get_field_root_type(cls, attribute_name: str) -> type:
     def check_request_attributes_mutability(
         cls, value: Any, info: ValidationInfo
     ) -> Any:
-        """Check and fix that the field mutability is expected according to the
-        requests validation context, as defined in :rfc:`RFC7643 §7
-        <7653#section-7>`."""
-
+        """Check and fix that the field mutability is expected according to the requests validation context, as defined in :rfc:`RFC7643 §7 <7653#section-7>`."""
         if (
             not info.context
             or not info.context.get("scim")
@@ -534,10 +522,7 @@ def normalize_value(value: Any) -> Any:
     def check_response_attributes_returnability(
         cls, value: Any, handler: ValidatorFunctionWrapHandler, info: ValidationInfo
     ) -> Self:
-        """Check that the fields returnability is expected according to the
-        responses validation context, as defined in :rfc:`RFC7643 §7
-        <7653#section-7>`."""
-
+        """Check that the fields returnability is expected according to the responses validation context, as defined in :rfc:`RFC7643 §7 <7653#section-7>`."""
         value = handler(value)
 
         if (
@@ -578,9 +563,7 @@ def check_response_attributes_returnability(
     def check_response_attributes_necessity(
         cls, value: Any, handler: ValidatorFunctionWrapHandler, info: ValidationInfo
     ) -> Self:
-        """Check that the required attributes are present in creations and
-        replacement requests."""
-
+        """Check that the required attributes are present in creations and replacement requests."""
         value = handler(value)
 
         if (
@@ -609,12 +592,7 @@ def check_response_attributes_necessity(
         return value
 
     def mark_with_schema(self):
-        """Navigate through attributes and sub-attributes of type
-        ComplexAttribute, and mark them with a '_schema' attribute.
-
-        '_schema' will later be used by 'get_attribute_urn'.
-        """
-
+        """Navigate through attributes and sub-attributes of type ComplexAttribute, and mark them with a '_schema' attribute. '_schema' will later be used by 'get_attribute_urn'."""
         from scim2_models.rfc7643.resource import Resource
 
         for field_name, field in self.model_fields.items():
@@ -644,9 +622,7 @@ def scim_serializer(
         handler: SerializerFunctionWrapHandler,
         info: SerializationInfo,
     ) -> Any:
-        """Serialize the fields according to mutability indications passed in
-        the serialization context."""
-
+        """Serialize the fields according to mutability indications passed in the serialization context."""
         value = handler(value)
 
         if info.context.get("scim") and Context.is_request(info.context["scim"]):
@@ -658,9 +634,7 @@ def scim_serializer(
         return value
 
     def scim_request_serializer(self, value: Any, info: SerializationInfo) -> Any:
-        """Serialize the fields according to mutability indications passed in
-        the serialization context."""
-
+        """Serialize the fields according to mutability indications passed in the serialization context."""
         mutability = self.get_field_annotation(info.field_name, Mutability)
         context = info.context.get("scim")
 
@@ -689,9 +663,7 @@ def scim_request_serializer(self, value: Any, info: SerializationInfo) -> Any:
         return value
 
     def scim_response_serializer(self, value: Any, info: SerializationInfo) -> Any:
-        """Serialize the fields according to returnability indications passed
-        in the serialization context."""
-
+        """Serialize the fields according to returnability indications passed in the serialization context."""
         returnability = self.get_field_annotation(info.field_name, Returned)
         attribute_urn = self.get_attribute_urn(info.field_name)
         included_urns = info.context.get("scim_attributes", [])
@@ -724,9 +696,7 @@ def scim_response_serializer(self, value: Any, info: SerializationInfo) -> Any:
     def model_serializer_exclude_none(
         self, handler, info: SerializationInfo
     ) -> dict[str, Any]:
-        """Remove `None` values inserted by the
-        :meth:`~scim2_models.base.BaseModel.scim_serializer`."""
-
+        """Remove `None` values inserted by the :meth:`~scim2_models.base.BaseModel.scim_serializer`."""
         self.mark_with_schema()
         result = handler(self)
         return {key: value for key, value in result.items() if value is not None}
@@ -735,9 +705,7 @@ def model_serializer_exclude_none(
     def model_validate(
         cls, *args, scim_ctx: Optional[Context] = Context.DEFAULT, **kwargs
     ) -> "BaseModel":
-        """Validate SCIM payloads and generate model representation by using
-        Pydantic :code:`BaseModel.model_validate`."""
-
+        """Validate SCIM payloads and generate model representation by using Pydantic :code:`BaseModel.model_validate`."""
         kwargs.setdefault("context", {}).setdefault("scim", scim_ctx)
         return super().model_validate(*args, **kwargs)
 
@@ -749,14 +717,12 @@ def model_dump(
         excluded_attributes: Optional[list[str]] = None,
         **kwargs,
     ):
-        """Create a model representation that can be included in SCIM messages
-        by using Pydantic :code:`BaseModel.model_dump`.
+        """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.
         """
-
         kwargs.setdefault("context", {}).setdefault("scim", scim_ctx)
         kwargs["context"]["scim_attributes"] = [
             validate_attribute_urn(attribute, self.__class__)
@@ -788,8 +754,7 @@ def get_attribute_urn(self, field_name: str) -> str:
 
 
 class ComplexAttribute(BaseModel):
-    """A complex attribute as defined in :rfc:`RFC7643 §2.3.8
-    <7643#section-2.3.8>`."""
+    """A complex attribute as defined in :rfc:`RFC7643 §2.3.8 <7643#section-2.3.8>`."""
 
     _schema: Optional[str] = None
 

scim2_models/rfc7643/resource.py

@@ -27,13 +27,9 @@
 
 
 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".
+    """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".
 
-    This attribute SHALL be
-    ignored when provided by clients.  "meta" contains the following
-    sub-attributes:
+    This attribute SHALL be ignored when provided by clients.  "meta" contains the following sub-attributes:
     """
 
     resource_type: Optional[str] = None
@@ -84,16 +80,12 @@ class Meta(ComplexAttribute):
 class Extension(BaseModel):
     @classmethod
     def to_schema(cls):
-        """Build a :class:`~scim2_models.Schema` from the current extension
-        class."""
-
+        """Build a :class:`~scim2_models.Schema` from the current extension class."""
         return model_to_schema(cls)
 
     @classmethod
     def from_schema(cls, schema) -> "Extension":
-        """Build a :class:`~scim2_models.Extension` subclass from the schema
-        definition."""
-
+        """Build a :class:`~scim2_models.Extension` subclass from the schema definition."""
         from .schema import make_python_model
 
         return make_python_model(schema, cls)
@@ -108,7 +100,6 @@ def extension_serializer(value: Any, handler, info) -> Optional[dict[str, Any]]:
     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)
     result = {
         attr_name: value
@@ -121,7 +112,6 @@ def extension_serializer(value: Any, handler, info) -> Optional[dict[str, Any]]:
 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 = (
@@ -188,9 +178,7 @@ def __setitem__(self, item: Any, value: "Resource"):
 
     @classmethod
     def get_extension_models(cls) -> dict[str, type]:
-        """Return extension a dict associating extension models with their
-        schemas."""
-
+        """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])
@@ -207,9 +195,7 @@ def get_extension_models(cls) -> dict[str, type]:
     def get_by_schema(
         resource_types: list[type[BaseModel]], schema: str, with_extensions=True
     ) -> Optional[type]:
-        """Given a resource type list and a schema, find the matching resource
-        type."""
-
+        """Given a resource type list and a schema, find the matching resource type."""
         by_schema = {
             resource_type.model_fields["schemas"].default[0].lower(): resource_type
             for resource_type in (resource_types or [])
@@ -227,9 +213,7 @@ def get_by_schema(
 
     @staticmethod
     def get_by_payload(resource_types: list[type], payload: dict, **kwargs):
-        """Given a resource type list and a payload, find the matching resource
-        type."""
-
+        """Given a resource type list and a payload, find the matching resource type."""
         if not payload or not payload.get("schemas"):
             return None
 
@@ -239,7 +223,6 @@ def get_by_payload(resource_types: list[type], payload: dict, **kwargs):
     @field_serializer("schemas")
     def set_extension_schemas(self, schemas: list[str]):
         """Add model extension ids to the 'schemas' attribute."""
-
         extension_schemas = self.get_extension_models().keys()
         schemas = self.schemas + [
             schema for schema in extension_schemas if schema not in self.schemas
@@ -248,16 +231,12 @@ def set_extension_schemas(self, schemas: list[str]):
 
     @classmethod
     def to_schema(cls):
-        """Build a :class:`~scim2_models.Schema` from the current resource
-        class."""
-
+        """Build a :class:`~scim2_models.Schema` from the current resource class."""
         return model_to_schema(cls)
 
     @classmethod
     def from_schema(cls, schema) -> "Resource":
-        """Build a :class:`scim2_models.Resource` subclass from the schema
-        definition."""
-
+        """Build a :class:`scim2_models.Resource` subclass from the schema definition."""
         from .schema import make_python_model
 
         return make_python_model(schema, cls)