chore: use ruff pydocstyle 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/codespell-project/codespell
     rev: v2.3.0
     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]
@@ -84,6 +95,7 @@ force-single-line = true
 [tool.ruff.format]
 docstring-code-format = true
 
+
 [tool.pytest.ini_options]
 addopts = "--doctest-modules --doctest-glob='*.rst'"
 doctest_optionflags= "ALLOW_UNICODE IGNORE_EXCEPTION_DETAIL ELLIPSIS"

scim2_server/backend.py

@@ -37,30 +37,30 @@ def __init__(self):
         self.models_dict: dict[str, BaseModel] = {}
 
     def __enter__(self):
-        """Allows the backend to be used as a context manager.
+        """Allow the backend to be used as a context manager.
 
         This enables support for transactions.
         """
         return self
 
     def __exit__(self, exc_type, exc_val, exc_tb):
-        """Exits the transaction."""
+        """Exit the transaction."""
         pass
 
     def register_schema(self, schema: Schema):
-        """Registers a Schema for use with the backend."""
+        """Register a Schema for use with the backend."""
         self.schemas[schema.id] = schema
 
     def get_schemas(self):
-        """Returns all schemas registered with the backend."""
+        """Return all schemas registered with the backend."""
         return self.schemas.values()
 
     def get_schema(self, schema_id: str) -> Schema | None:
-        """Gets a schema by its id."""
+        """Get a schema by its id."""
         return self.schemas.get(schema_id)
 
     def register_resource_type(self, resource_type: ResourceType):
-        """Registers a ResourceType for use with the backend.
+        """Register a ResourceType for use with the backend.
 
         The schemas used for the resource and its extensions must have
         been registered with the Backend beforehand.
@@ -86,31 +86,31 @@ def register_resource_type(self, resource_type: ResourceType):
             ]
 
     def get_resource_types(self):
-        """Returns all resource types registered with the backend."""
+        """Return all resource types registered with the backend."""
         return self.resource_types.values()
 
     def get_resource_type(self, resource_type_id: str) -> ResourceType | None:
-        """Returns the resource type by its id."""
+        """Return the resource type by its id."""
         return self.resource_types.get(resource_type_id)
 
     def get_resource_type_by_endpoint(self, endpoint: str) -> ResourceType | None:
-        """Returns the resource type by its endpoint."""
+        """Return the resource type by its endpoint."""
         return self.resource_types_by_endpoint.get(endpoint.lower())
 
     def get_model(self, resource_type_id: str) -> BaseModel | None:
-        """Returns the Pydantic Python model for a given resource type."""
+        """Return the Pydantic Python model for a given resource type."""
         return self.models_dict.get(resource_type_id)
 
     def get_models(self):
-        """Returns all Pydantic Python models for all known resource types."""
+        """Return all Pydantic Python models for all known resource types."""
         return self.models_dict.values()
 
     def query_resources(
         self,
         search_request: SearchRequest,
         resource_type_id: str | None = None,
     ) -> tuple[int, list[Resource]]:
-        """Queries the backend for a set of resources.
+        """Query the backend for a set of resources.
 
         :param search_request: SearchRequest instance describing the
             query.
@@ -128,7 +128,7 @@ def query_resources(
         raise NotImplementedError
 
     def get_resource(self, resource_type_id: str, object_id: str) -> Resource | None:
-        """Queries the backend for a resources by its ID.
+        """Query the backend for a resources by its ID.
 
         :param resource_type_id: ID of the resource type to get the
             object from.
@@ -140,7 +140,7 @@ def get_resource(self, resource_type_id: str, object_id: str) -> Resource | None
         raise NotImplementedError
 
     def delete_resource(self, resource_type_id: str, object_id: str) -> bool:
-        """Deletes a resource.
+        """Delete a resource.
 
         :param resource_type_id: ID of the resource type to delete the
             object from.
@@ -152,7 +152,7 @@ def delete_resource(self, resource_type_id: str, object_id: str) -> bool:
     def create_resource(
         self, resource_type_id: str, resource: Resource
     ) -> Resource | None:
-        """Creates a resource.
+        """Create a resource.
 
         :param resource_type_id: ID of the resource type to create.
         :param resource: Resource to create.
@@ -165,7 +165,7 @@ def create_resource(
     def update_resource(
         self, resource_type_id: str, resource: Resource
     ) -> Resource | None:
-        """Updates a resource. The resource is identified by its ID.
+        """Update a resource. The resource is identified by its ID.
 
         :param resource_type_id: ID of the resource type to update.
         :param resource: Resource to update.
@@ -177,7 +177,7 @@ def update_resource(
 
 
 class InMemoryBackend(Backend):
-    """This is an example in-memory backend for the SCIM provider.
+    """An example in-memory backend for the SCIM provider.
 
     It is not optimized for performance. Many operations are O(n) or
     worse, whereas they would perform better with an actual production

scim2_server/cli.py

@@ -14,7 +14,7 @@
 
 
 def log_environ(handler):
-    """A simple decorator to log all WSGI environment variables."""
+    """Build a simple decorator to log all WSGI environment variables."""
 
     def _inner(environ, start_fn):
         logging.getLogger("log_environ").debug(pprint.pformat(environ))

scim2_server/filter.py

@@ -13,8 +13,9 @@
 def evaluate_filter(
     obj: BaseModel | list[BaseModel], tree: scim2ast.AST
 ) -> bool | list[bool]:
-    """This implementation is limited by the specifics of the
-    scim2_filter_parser module.
+    """Resolve filters.
+
+    This implementation is limited by the specifics of the scim2_filter_parser module.
 
     It works well enough for simple cases, though. It should be re-
     implemented in the future. Probably once
@@ -117,8 +118,7 @@ def evaluate_filter(
 
 
 def check_comparable_value(value):
-    """Certain values may not be compared in a filter, see RFC 7644, section
-    3.4.2.2:
+    """Certain values may not be compared in a filter, see RFC 7644, section 3.4.2.2.
 
     "Boolean and Binary attributes SHALL cause a failed response (HTTP
     status code 400) with "scimType" of "invalidFilter"."

scim2_server/operators.py

@@ -26,7 +26,7 @@
 
 
 def patch_resource(resource: Resource, operation: PatchOperation):
-    """Runs a patch operation against a resource."""
+    """Run a patch operation against a resource."""
     match operation.op:
         case PatchOperation.Op.add:
             operator = AddOperator(operation.path, operation.value)
@@ -40,7 +40,7 @@ def patch_resource(resource: Resource, operation: PatchOperation):
 
 
 def parse_attribute_path(attribute_path: str | None) -> dict[str, Any] | None:
-    """Parses an attribute path and returns a dictionary of attributes.
+    """Parse an attribute path and returns a dictionary of attributes.
 
     The attributes are the named captures in the regex
     ATTRIBUTE_PATH_REGEX.
@@ -61,8 +61,7 @@ def parse_attribute_path(attribute_path: str | None) -> dict[str, Any] | None:
 
 
 class Operator:
-    """An operator operates on a resource and is constructed using a path and a
-    value."""
+    """An operator operates on a resource and is constructed using a path and a value."""
 
     OPERATE_ON_ROOT = True  # Whether the operator may operate on the root of a resource (e.g. remove may not)
     REQUIRES_VALUE = True  # Whether the operator modifies the resource or not
@@ -76,22 +75,22 @@ def __init__(self, path: str | None, value: Any | None):
     def init_return(
         cls, model: BaseModel, attribute: str, sub_attribute: str | None, value: Any
     ):
-        """Initializes the return value if the operator returns something."""
+        """Initialize the return value if the operator returns something."""
         pass
 
     def do_return(self):
-        """Returns the return value for the operator."""
+        """Return the return value for the operator."""
         return None
 
     @classmethod
     def operation(
         cls, model: BaseModel, attribute: str, value: Any, index: int | None = None
     ):
-        """Performs the actual operation of the operator."""
+        """Perform the actual operation of the operator."""
         raise NotImplementedError
 
     def parse_path(self, model: BaseModel):
-        """Parses a path and optionally handles model extensions.
+        """Parse a path and optionally handles model extensions.
 
         :return: A tuple of the model to operate on and the parsed path.
         """
@@ -101,7 +100,7 @@ def parse_path(self, model: BaseModel):
         return model, parse_attribute_path(path)
 
     def __call__(self, model: BaseModel):
-        """Executes the operator against a model."""
+        """Execute the operator against a model."""
         if not self.path:
             self.call_on_root(model)
             return self.do_return()
@@ -302,8 +301,7 @@ def operation(cls, model: BaseModel, attribute: str, value: Any):
 
 
 class ResolveResult:
-    """A descriptor for the result returned from the "ResolveOperator", used to
-    resolve attributes from a model."""
+    """A descriptor for the result returned from the "ResolveOperator", used to resolve attributes from a model."""
 
     def __init__(self):
         self.records = []
@@ -313,11 +311,11 @@ def __init__(self):
         self.sub_attribute = None
 
     def add_result(self, model: BaseModel, attribute_name: str):
-        """Adds a result to the descriptor."""
+        """Add a result to the descriptor."""
         self.records.append((model, attribute_name))
 
     def add_result_index(self, model: BaseModel, attribute_name: str, index: int):
-        """Adds a result to the descriptor.
+        """Add a result to the descriptor.
 
         The resulting attribute is part of a multi-valued attribute
         described by its index.
@@ -387,13 +385,13 @@ def operation(
 
 
 class ResolveSortOperator(ResolveOperator):
-    """
-    Helper-Operator that implements sorting, according to RFC 7644, Section 3.4.2.3
+    """Implement sorting in a helper Operator, according to RFC 7644, Section 3.4.2.3.
+
     The ResolveResult returned by this operator contains at most 1 value, according to
     the specification:
     "[...] if it's a multi-valued attribute, resources are sorted by the value of the
     primary attribute (see Section 2.4 of [RFC7643]), if any, or else the first value
-    in the list, if any. [...]"
+    in the list, if any. [...]".
 
     Since a Query can result in resources of different types, sorting by an attribute
     that is not defined for a certain resource type does not result in an error. No
@@ -464,7 +462,7 @@ def __call__(self, model: BaseModel):
         return self.value
 
     def select_candidate(self, values: list[Any]) -> tuple[Any | None, int]:
-        """Selects a viable candidate from a list of possible values."""
+        """Select a viable candidate from a list of possible values."""
         for value in values:
             primary = getattr(value, "primary", False)
             if primary: