chore: expand linting rules and harden adapters/tests

Author: HosseinNejatiJavaremi

.cursor/rules/checks.mdc

@@ -168,23 +168,46 @@ class ElasticsearchConfig(BaseModel):
 **Enabled Rules**:
 - A: flake8-builtins
 - ANN: flake8-annotations
+- ARG: flake8-unused-arguments
 - ASYNC: flake8-async
 - B: flake8-bugbear
+- C4: flake8-comprehensions
 - D: pydocstyle (Google-style, except D100, D104, D107)
 - E/W: pycodestyle (except E501)
+- EM: flake8-errmsg
 - ERA: eradicate
 - F: pyflakes (except F811 in steps)
+- FAST: FastAPI best practices
+- FURB: refurb (modern Python patterns)
 - G: logging (allow G004 f-strings)
 - I: isort (future → stdlib → third-party → first-party → local)
+- ICN: flake8-import-conventions
+- LOG: flake8-logging
+- PERF: Perflint (performance)
+- PIE: flake8-pie
+- PL: Pylint (PLC, PLE, PLR, PLW)
+- PTH: flake8-use-pathlib
+- PYI: flake8-pyi (stub files)
 - RUF: Ruff rules (except RUF001/RUF003 for Persian)
 - S: Bandit (allow S101 assert, S301/S403 pickle)
+- SIM: flake8-simplify
+- SLOT: flake8-slots
+- T10: flake8-debugger
+- T20: flake8-print
+- TC: flake8-type-checking
+- TID: flake8-tidy-imports
 - TRY: tryceratops (except TRY003, TRY301)
 - UP: pyupgrade
 
 **Ignored**:
 - C901: McCabe max 10
+- EM101/EM102: Exception message formatting
 - F811: Redefinition in steps
 - G004: f-strings in logging
+- PERF203: try-except in loop
+- PLR0904/PLR0914/PLR1702: Complexity thresholds
+- SIM102/SIM108: Simplification preferences
+- TC001/TC003: TYPE_CHECKING imports (Pydantic compatibility)
 
 ## Development Tools
 

archipy/adapters/base/sqlalchemy/adapters.py

@@ -79,11 +79,21 @@ class SQLAlchemyFilterMixin:
     Supports equality, inequality, string operations, list operations, and NULL checks.
     """
 
+    @staticmethod
+    def _validate_list_operation(
+        value: str | float | bool | list | UUID | None,
+        operation: FilterOperationType,
+    ) -> list:
+        """Validate that value is a list for list operations."""
+        if not isinstance(value, list):
+            raise InvalidArgumentError(f"{operation.value} operation requires a list, got {type(value)}")
+        return value
+
     @staticmethod
     def _apply_filter(
         query: Select | Update | Delete,
         field: InstrumentedAttribute,
-        value: str | int | float | bool | list | UUID | None,
+        value: str | float | bool | list | UUID | None,
         operation: FilterOperationType,
     ) -> Select | Update | Delete:
         """Apply a filter to a SQLAlchemy query based on the specified operation.
@@ -97,42 +107,36 @@ def _apply_filter(
         Returns:
             The updated query with the filter applied.
         """
-        if value is not None or operation in [FilterOperationType.IS_NULL, FilterOperationType.IS_NOT_NULL]:
-            match operation:
-                case FilterOperationType.EQUAL:
-                    return query.where(field == value)
-                case FilterOperationType.NOT_EQUAL:
-                    return query.where(field != value)
-                case FilterOperationType.LESS_THAN:
-                    return query.where(field < value)
-                case FilterOperationType.LESS_THAN_OR_EQUAL:
-                    return query.where(field <= value)
-                case FilterOperationType.GREATER_THAN:
-                    return query.where(field > value)
-                case FilterOperationType.GREATER_THAN_OR_EQUAL:
-                    return query.where(field >= value)
-                case FilterOperationType.IN_LIST:
-                    if not isinstance(value, list):
-                        raise InvalidArgumentError(f"IN_LIST operation requires a list, got {type(value)}")
-                    return query.where(field.in_(value))
-                case FilterOperationType.NOT_IN_LIST:
-                    if not isinstance(value, list):
-                        raise InvalidArgumentError(f"NOT_IN_LIST operation requires a list, got {type(value)}")
-                    return query.where(~field.in_(value))
-                case FilterOperationType.LIKE:
-                    return query.where(field.like(f"%{value}%"))
-                case FilterOperationType.ILIKE:
-                    return query.where(field.ilike(f"%{value}%"))
-                case FilterOperationType.STARTS_WITH:
-                    return query.where(field.startswith(value))
-                case FilterOperationType.ENDS_WITH:
-                    return query.where(field.endswith(value))
-                case FilterOperationType.CONTAINS:
-                    return query.where(field.contains(value))
-                case FilterOperationType.IS_NULL:
-                    return query.where(field.is_(None))
-                case FilterOperationType.IS_NOT_NULL:
-                    return query.where(field.isnot(None))
+        # Skip filter if value is None (except for IS_NULL/IS_NOT_NULL operations)
+        if value is None and operation not in [FilterOperationType.IS_NULL, FilterOperationType.IS_NOT_NULL]:
+            return query
+
+        # Map operations to their corresponding SQLAlchemy expressions
+        filter_map = {
+            FilterOperationType.EQUAL: lambda: field == value,
+            FilterOperationType.NOT_EQUAL: lambda: field != value,
+            FilterOperationType.LESS_THAN: lambda: field < value,
+            FilterOperationType.LESS_THAN_OR_EQUAL: lambda: field <= value,
+            FilterOperationType.GREATER_THAN: lambda: field > value,
+            FilterOperationType.GREATER_THAN_OR_EQUAL: lambda: field >= value,
+            FilterOperationType.IN_LIST: lambda: field.in_(
+                SQLAlchemyFilterMixin._validate_list_operation(value, operation),
+            ),
+            FilterOperationType.NOT_IN_LIST: lambda: ~field.in_(
+                SQLAlchemyFilterMixin._validate_list_operation(value, operation),
+            ),
+            FilterOperationType.LIKE: lambda: field.like(f"%{value}%"),
+            FilterOperationType.ILIKE: lambda: field.ilike(f"%{value}%"),
+            FilterOperationType.STARTS_WITH: lambda: field.startswith(value),
+            FilterOperationType.ENDS_WITH: lambda: field.endswith(value),
+            FilterOperationType.CONTAINS: lambda: field.contains(value),
+            FilterOperationType.IS_NULL: lambda: field.is_(None),
+            FilterOperationType.IS_NOT_NULL: lambda: field.isnot(None),
+        }
+
+        filter_expr = filter_map.get(operation)
+        if filter_expr:
+            return query.where(filter_expr())
         return query
 
 

archipy/adapters/base/sqlalchemy/session_managers.py

@@ -71,7 +71,6 @@ def _expected_config_type(self) -> type[SQLAlchemyConfig]:
         Returns:
             The SQLAlchemy configuration class expected by this session manager.
         """
-        pass
 
     @abstractmethod
     def _get_database_name(self) -> str:
@@ -80,7 +79,6 @@ def _get_database_name(self) -> str:
         Returns:
             str: The name of the database (e.g., 'postgresql', 'sqlite', 'starrocks').
         """
-        pass
 
     @abstractmethod
     def _create_url(self, configs: ConfigT) -> URL:
@@ -95,7 +93,6 @@ def _create_url(self, configs: ConfigT) -> URL:
         Raises:
             DatabaseConnectionError: If there's an error creating the URL.
         """
-        pass
 
     def _create_engine(self, configs: ConfigT) -> Engine:
         """Create a SQLAlchemy engine with common configuration.
@@ -257,7 +254,6 @@ def _expected_config_type(self) -> type[SQLAlchemyConfig]:
         Returns:
             The SQLAlchemy configuration class expected by this session manager.
         """
-        pass
 
     @abstractmethod
     def _get_database_name(self) -> str:
@@ -266,7 +262,6 @@ def _get_database_name(self) -> str:
         Returns:
             str: The name of the database (e.g., 'postgresql', 'sqlite', 'starrocks').
         """
-        pass
 
     @abstractmethod
     def _create_url(self, configs: ConfigT) -> URL:
@@ -281,7 +276,6 @@ def _create_url(self, configs: ConfigT) -> URL:
         Raises:
             DatabaseConnectionError: If there's an error creating the URL.
         """
-        pass
 
     def _create_async_engine(self, configs: ConfigT) -> AsyncEngine:
         """Create an async SQLAlchemy engine with common configuration.

archipy/adapters/email/adapters.py

@@ -9,6 +9,7 @@
 from email.mime.image import MIMEImage
 from email.mime.multipart import MIMEMultipart
 from email.mime.text import MIMEText
+from pathlib import Path
 from queue import Queue
 from typing import BinaryIO, override
 
@@ -24,6 +25,8 @@
 from archipy.models.errors import InvalidArgumentError
 from archipy.models.types.email_types import EmailAttachmentDispositionType, EmailAttachmentType
 
+logger = logging.getLogger(__name__)
+
 
 class EmailConnectionManager:
     """Manages SMTP connections with connection pooling and timeout handling."""
@@ -135,10 +138,10 @@ def create_attachment(
     def _process_source(source: str | bytes | BinaryIO | HttpUrl, attachment_type: EmailAttachmentType) -> bytes:
         """Process different types of attachment sources."""
         if attachment_type == EmailAttachmentType.FILE:
-            if isinstance(source, (str, os.PathLike)):
-                file_path = os.fspath(source)
-                with open(file_path, "rb") as f:
-                    return f.read()
+            if isinstance(source, str):
+                return Path(source).read_bytes()
+            if isinstance(source, os.PathLike):
+                return Path(os.fspath(source)).read_bytes()
             raise ValueError(f"File attachment type requires string path, got {type(source)}")
         elif attachment_type == EmailAttachmentType.BASE64:
             if isinstance(source, str | bytes):
@@ -252,7 +255,7 @@ def send_email(
                 try:
                     if connection.smtp_connection:
                         connection.smtp_connection.send_message(msg, to_addrs=recipients)
-                        logging.debug(f"Email sent successfully to {to_email}")
+                        logger.debug(f"Email sent successfully to {to_email}")
                         return
                     else:
                         connection.connect()
@@ -300,7 +303,7 @@ def _create_message(
                     # Treat as file path
                     attachment_obj = AttachmentHandler.create_attachment(
                         source=attachment,
-                        filename=os.path.basename(attachment),
+                        filename=Path(attachment).name,
                         attachment_type=EmailAttachmentType.FILE,
                     )
                 else:

archipy/adapters/kafka/adapters.py

@@ -1,3 +1,4 @@
+import contextlib
 import logging
 from typing import override
 
@@ -50,10 +51,8 @@ def _handle_kafka_exception(cls, exception: Exception, operation: str) -> None:
             # Extract timeout value if available
             timeout = None
             if hasattr(exception, "args") and len(exception.args) > 1:
-                try:
+                with contextlib.suppress(IndexError, ValueError):
                     timeout = int(exception.args[1])
-                except (IndexError, ValueError):
-                    pass
             raise ConnectionTimeoutError(service="Kafka", timeout=timeout) from exception
 
         # Network/connectivity errors

archipy/adapters/scylladb/adapters.py

@@ -209,7 +209,7 @@ def _create_cluster(self) -> Any:
             port=self.config.PORT,
             auth_provider=auth_provider,
             protocol_version=self.config.PROTOCOL_VERSION,
-            compression=True if self.config.COMPRESSION else False,
+            compression=bool(self.config.COMPRESSION),
             connect_timeout=self.config.CONNECT_TIMEOUT,
             load_balancing_policy=load_balancing_policy,
             default_retry_policy=retry_policy,
@@ -405,7 +405,7 @@ def insert(self, table: str, data: dict[str, Any], ttl: int | None = None, if_no
                               This prevents errors on duplicate primary keys but is slow
         """
         columns = ", ".join(data.keys())
-        placeholders = ", ".join(["%s" for _ in data.keys()])
+        placeholders = ", ".join(["%s" for _ in data])
         query = f"INSERT INTO {table} ({columns}) VALUES ({placeholders})"
 
         if if_not_exists:
@@ -442,7 +442,7 @@ def select(
 
         params = None
         if conditions:
-            where_clause = " AND ".join([f"{key} = %s" for key in conditions.keys()])
+            where_clause = " AND ".join([f"{key} = %s" for key in conditions])
             query += f" WHERE {where_clause}"
             params = tuple(conditions.values())
 
@@ -463,8 +463,8 @@ def update(self, table: str, data: dict[str, Any], conditions: dict[str, Any], t
             conditions (dict[str, Any]): WHERE clause conditions as key-value pairs.
             ttl (int | None): Time to live in seconds. If None, data persists indefinitely.
         """
-        set_clause = ", ".join([f"{key} = %s" for key in data.keys()])
-        where_clause = " AND ".join([f"{key} = %s" for key in conditions.keys()])
+        set_clause = ", ".join([f"{key} = %s" for key in data])
+        where_clause = " AND ".join([f"{key} = %s" for key in conditions])
         query = f"UPDATE {table}"
 
         if ttl is not None:
@@ -489,7 +489,7 @@ def delete(self, table: str, conditions: dict[str, Any]) -> None:
             table (str): The name of the table.
             conditions (dict[str, Any]): WHERE clause conditions as key-value pairs.
         """
-        where_clause = " AND ".join([f"{key} = %s" for key in conditions.keys()])
+        where_clause = " AND ".join([f"{key} = %s" for key in conditions])
         query = f"DELETE FROM {table} WHERE {where_clause}"
 
         try:
@@ -610,7 +610,7 @@ def count(self, table: str, conditions: dict[str, Any] | None = None) -> int:
 
         params = None
         if conditions:
-            where_clause = " AND ".join([f"{key} = %s" for key in conditions.keys()])
+            where_clause = " AND ".join([f"{key} = %s" for key in conditions])
             query += f" WHERE {where_clause} ALLOW FILTERING"
             params = tuple(conditions.values())
 
@@ -634,7 +634,7 @@ def exists(self, table: str, conditions: dict[str, Any]) -> bool:
         Returns:
             bool: True if at least one row exists, False otherwise.
         """
-        where_clause = " AND ".join([f"{key} = %s" for key in conditions.keys()])
+        where_clause = " AND ".join([f"{key} = %s" for key in conditions])
         query = f"SELECT COUNT(*) FROM {table} WHERE {where_clause} LIMIT 1 ALLOW FILTERING"
 
         try:
@@ -792,7 +792,7 @@ def _create_cluster(self) -> Any:
             port=self.config.PORT,
             auth_provider=auth_provider,
             protocol_version=self.config.PROTOCOL_VERSION,
-            compression=True if self.config.COMPRESSION else False,
+            compression=bool(self.config.COMPRESSION),
             connect_timeout=self.config.CONNECT_TIMEOUT,
             load_balancing_policy=load_balancing_policy,
             default_retry_policy=retry_policy,
@@ -1008,7 +1008,7 @@ async def insert(
                               This prevents errors on duplicate primary keys but is slow
         """
         columns = ", ".join(data.keys())
-        placeholders = ", ".join(["%s" for _ in data.keys()])
+        placeholders = ", ".join(["%s" for _ in data])
         query = f"INSERT INTO {table} ({columns}) VALUES ({placeholders})"
 
         if if_not_exists:
@@ -1045,7 +1045,7 @@ async def select(
 
         params = None
         if conditions:
-            where_clause = " AND ".join([f"{key} = %s" for key in conditions.keys()])
+            where_clause = " AND ".join([f"{key} = %s" for key in conditions])
             query += f" WHERE {where_clause}"
             params = tuple(conditions.values())
 
@@ -1072,8 +1072,8 @@ async def update(
             conditions (dict[str, Any]): WHERE clause conditions as key-value pairs.
             ttl (int | None): Time to live in seconds. If None, data persists indefinitely.
         """
-        set_clause = ", ".join([f"{key} = %s" for key in data.keys()])
-        where_clause = " AND ".join([f"{key} = %s" for key in conditions.keys()])
+        set_clause = ", ".join([f"{key} = %s" for key in data])
+        where_clause = " AND ".join([f"{key} = %s" for key in conditions])
         query = f"UPDATE {table}"
 
         if ttl is not None:
@@ -1098,7 +1098,7 @@ async def delete(self, table: str, conditions: dict[str, Any]) -> None:
             table (str): The name of the table.
             conditions (dict[str, Any]): WHERE clause conditions as key-value pairs.
         """
-        where_clause = " AND ".join([f"{key} = %s" for key in conditions.keys()])
+        where_clause = " AND ".join([f"{key} = %s" for key in conditions])
         query = f"DELETE FROM {table} WHERE {where_clause}"
 
         try:
@@ -1225,7 +1225,7 @@ async def count(self, table: str, conditions: dict[str, Any] | None = None) -> i
 
         params = None
         if conditions:
-            where_clause = " AND ".join([f"{key} = %s" for key in conditions.keys()])
+            where_clause = " AND ".join([f"{key} = %s" for key in conditions])
             query += f" WHERE {where_clause} ALLOW FILTERING"
             params = tuple(conditions.values())
 
@@ -1249,7 +1249,7 @@ async def exists(self, table: str, conditions: dict[str, Any]) -> bool:
         Returns:
             bool: True if at least one row exists, False otherwise.
         """
-        where_clause = " AND ".join([f"{key} = %s" for key in conditions.keys()])
+        where_clause = " AND ".join([f"{key} = %s" for key in conditions])
         query = f"SELECT COUNT(*) FROM {table} WHERE {where_clause} LIMIT 1 ALLOW FILTERING"
 
         try: