fix: improve docstrings and format

Signed-off-by: Frost Ming <me@frostming.com>

Author: frostming

src/dep_logic/markers/base.py

@@ -24,9 +24,11 @@ def __or__(self, other: Any) -> BaseMarker:
         raise NotImplementedError
 
     def is_any(self) -> bool:
+        """Returns True if the marker allows any environment."""
         return False
 
     def is_empty(self) -> bool:
+        """Returns True if the marker disallows any environment."""
         return False
 
     @abstractmethod
@@ -35,18 +37,28 @@ def evaluate(
         environment: dict[str, str | set[str]] | None = None,
         context: EvaluationContext = "metadata",
     ) -> bool:
+        """Evaluates the marker against the given environment.
+
+        Args:
+            environment: The environment to evaluate against.
+            context: The context in which the evaluation is performed,
+                can be "lock_file", "metadata", or "requirement".
+        """
         raise NotImplementedError
 
     @abstractmethod
     def without_extras(self) -> BaseMarker:
+        """Generate a new marker from the current marker but without "extra" markers."""
         raise NotImplementedError
 
     @abstractmethod
     def exclude(self, marker_name: str) -> BaseMarker:
+        """Generate a new marker from the current marker but without the given marker."""
         raise NotImplementedError
 
     @abstractmethod
     def only(self, *marker_names: str) -> BaseMarker:
+        """Generate a new marker from the current marker but only with the given markers."""
         raise NotImplementedError
 
     def __repr__(self) -> str:

src/dep_logic/specifiers/range.py

@@ -81,7 +81,7 @@ def __str__(self) -> str:
         simplified = self._simplified_form
         if simplified is not None:
             return simplified
-        return f'{">=" if self.include_min else ">"}{self.min},{"<=" if self.include_max else "<"}{self.max}'
+        return f"{'>=' if self.include_min else '>'}{self.min},{'<=' if self.include_max else '<'}{self.max}"
 
     def contains(
         self, version: UnparsedVersion, prereleases: bool | None = None
@@ -115,11 +115,8 @@ def allows_lower(self, other: RangeSpecifier) -> bool:
         if self.min is None:
             return True
 
-        return (
-            self.min < other.min
-            or self.min == other.min
-            and self.include_min
-            and not other.include_min
+        return self.min < other.min or (
+            self.min == other.min and self.include_min and not other.include_min
         )
 
     def allows_higher(self, other: RangeSpecifier) -> bool:
@@ -128,11 +125,8 @@ def allows_higher(self, other: RangeSpecifier) -> bool:
         if self.max is None:
             return True
 
-        return (
-            self.max > other.max
-            or self.max == other.max
-            and self.include_max
-            and not other.include_max
+        return self.max > other.max or (
+            self.max == other.max and self.include_max and not other.include_max
         )
 
     def is_strictly_lower(self, other: RangeSpecifier) -> bool:
@@ -142,10 +136,8 @@ def is_strictly_lower(self, other: RangeSpecifier) -> bool:
         if self.max is None or other.min is None:
             return False
 
-        return (
-            self.max < other.min
-            or self.max == other.min
-            and False in (self.include_max, other.include_min)
+        return self.max < other.min or (
+            self.max == other.min and False in (self.include_max, other.include_min)
         )
 
     def is_adjacent_to(self, other: RangeSpecifier) -> bool:
@@ -162,22 +154,24 @@ def __lt__(self, other: Any) -> bool:
         return self.allows_lower(other)
 
     def is_superset(self, other: RangeSpecifier) -> bool:
-        min_lower = (
-            self.min is None
-            or other.min is not None
+        min_lower = self.min is None or (
+            other.min is not None
             and (
                 self.min < other.min
-                or self.min == other.min
-                and not (not self.include_min and other.include_min)
+                or (
+                    self.min == other.min
+                    and not (not self.include_min and other.include_min)
+                )
             )
         )
-        max_higher = (
-            self.max is None
-            or other.max is not None
+        max_higher = self.max is None or (
+            other.max is not None
             and (
                 self.max > other.max
-                or self.max == other.max
-                and not (not self.include_max and other.include_max)
+                or (
+                    self.max == other.max
+                    and not (not self.include_max and other.include_max)
+                )
             )
         )
         return min_lower and max_higher