fix: enable ruff linting rules (#51)

Author: bchampp

pyproject.toml

@@ -72,7 +72,7 @@ exclude_lines = ["no cov", "if __name__ == .__main__.:", "if TYPE_CHECKING:"]
 line-length = 88
 
 [tool.ruff.lint]
-preview = false
+preview = true
 
 [tool.ruff.lint.per-file-ignores]
 "tests/**" = [
@@ -81,6 +81,7 @@ preview = false
   "ARG005",
   "S101",
   "PLR2004",
+  "PLR6301",
   "SIM117",
   "TRY301",
 ]

src/aws_durable_execution_sdk_python/concurrency.py

@@ -12,6 +12,7 @@
 from enum import Enum
 from typing import TYPE_CHECKING, Generic, Self, TypeVar
 
+from aws_durable_execution_sdk_python.config import ChildConfig
 from aws_durable_execution_sdk_python.exceptions import (
     InvalidStateError,
     SuspendExecution,
@@ -23,7 +24,7 @@
 if TYPE_CHECKING:
     from collections.abc import Callable
 
-    from aws_durable_execution_sdk_python.config import ChildConfig, CompletionConfig
+    from aws_durable_execution_sdk_python.config import CompletionConfig
     from aws_durable_execution_sdk_python.lambda_service import OperationSubType
     from aws_durable_execution_sdk_python.serdes import SerDes
     from aws_durable_execution_sdk_python.state import ExecutionState
@@ -92,7 +93,7 @@ def from_dict(cls, data: dict) -> BatchItem[R]:
 
 
 @dataclass(frozen=True)
-class BatchResult(Generic[R], BatchResultProtocol[R]):
+class BatchResult(Generic[R], BatchResultProtocol[R]):  # noqa: PYI059
     all: list[BatchItem[R]]
     completion_reason: CompletionReason
 
@@ -353,10 +354,7 @@ def should_complete(self) -> bool:
             # Impossible to succeed condition
             # TODO: should this keep running? TS doesn't currently handle this either.
             remaining_tasks = self.total_tasks - self.success_count - self.failure_count
-            if self.success_count + remaining_tasks < self.min_successful:
-                return True
-
-            return False
+            return self.success_count + remaining_tasks < self.min_successful
 
     def is_all_completed(self) -> bool:
         """True if all tasks completed successfully."""
@@ -493,11 +491,7 @@ def __init__(
         self._suspend_exception: SuspendExecution | None = None
 
         # ExecutionCounters will keep track of completion criteria and on-going counters
-        min_successful = (
-            self.completion_config.min_successful
-            if self.completion_config.min_successful
-            else len(self.executables)
-        )
+        min_successful = self.completion_config.min_successful or len(self.executables)
         tolerated_failure_count = self.completion_config.tolerated_failure_count
         tolerated_failure_percentage = (
             self.completion_config.tolerated_failure_percentage
@@ -532,9 +526,7 @@ def execute(
             "▶️ Executing concurrent operation, items: %d", len(self.executables)
         )
 
-        max_workers = (
-            self.max_concurrency if self.max_concurrency else len(self.executables)
-        )
+        max_workers = self.max_concurrency or len(self.executables)
 
         self.executables_with_state = [
             ExecutableWithState(executable=exe) for exe in self.executables
@@ -588,7 +580,7 @@ def should_execution_suspend(self) -> SuspendResult:
         ) = None
 
         for exe_state in self.executables_with_state:
-            if exe_state.status in (BranchStatus.PENDING, BranchStatus.RUNNING):
+            if exe_state.status in {BranchStatus.PENDING, BranchStatus.RUNNING}:
                 # Exit here! Still have tasks that can make progress, don't suspend.
                 return SuspendResult.do_not_suspend()
             if exe_state.status is BranchStatus.SUSPENDED_WITH_TIMEOUT:
@@ -692,7 +684,6 @@ def _execute_item_in_child_context(
         executable: Executable[CallableType],
     ) -> ResultType:
         """Execute a single item in a child context."""
-        from aws_durable_execution_sdk_python.config import ChildConfig
 
         def execute_in_child_context(child_context: DurableContext) -> ResultType:
             return self.execute_item(child_context, executable)

src/aws_durable_execution_sdk_python/context.py

@@ -94,7 +94,7 @@ def function_with_arguments(child_context: DurableContext):
     return wrapper
 
 
-class Callback(Generic[T], CallbackProtocol[T]):
+class Callback(Generic[T], CallbackProtocol[T]):  # noqa: PYI059
     """A future that will block on result() until callback_id returns."""
 
     def __init__(
@@ -162,13 +162,9 @@ def __init__(
             execution_arn=state.durable_execution_arn, parent_id=parent_id
         )
         self._log_info = log_info
-        self.logger: Logger = (
-            logger
-            if logger
-            else Logger.from_log_info(
-                logger=logging.getLogger(),
-                info=log_info,
-            )
+        self.logger: Logger = logger or Logger.from_log_info(
+            logger=logging.getLogger(),
+            info=log_info,
         )
 
     # region factories
@@ -207,7 +203,7 @@ def _resolve_step_name(name: str | None, func: Callable) -> str | None:
             str | None: The provided name, and if that doesn't exist the callable function's name if it has one.
         """
         # callable's name will override name if name is falsy ('' or None)
-        return name if name else getattr(func, "_original_name", None)
+        return name or getattr(func, "_original_name", None)
 
     def set_logger(self, new_logger: LoggerInterface):
         """Set the logger for the current context."""

src/aws_durable_execution_sdk_python/operation/child.py

@@ -64,9 +64,7 @@ def child_handler(
         )
     if checkpointed_result.is_failed():
         checkpointed_result.raise_callable_error()
-    sub_type = (
-        config.sub_type if config.sub_type else OperationSubType.RUN_IN_CHILD_CONTEXT
-    )
+    sub_type = config.sub_type or OperationSubType.RUN_IN_CHILD_CONTEXT
 
     if not checkpointed_result.is_existent():
         start_operation = OperationUpdate.create_context_start(

src/aws_durable_execution_sdk_python/operation/map.py

@@ -29,7 +29,7 @@
 R = TypeVar("R")
 
 
-class MapExecutor(Generic[T, R], ConcurrentExecutor[Callable, R]):
+class MapExecutor(Generic[T, R], ConcurrentExecutor[Callable, R]):  # noqa: PYI059
     def __init__(
         self,
         executables: list[Executable[Callable]],
@@ -94,6 +94,6 @@ def map_handler(
 ) -> BatchResult[R]:
     """Execute a callable for each item in parallel."""
     executor: MapExecutor[T, R] = MapExecutor.from_items(
-        items=items, func=func, config=config if config else MapConfig()
+        items=items, func=func, config=config or MapConfig()
     )
     return executor.execute(execution_state, run_in_child_context)

src/aws_durable_execution_sdk_python/operation/parallel.py

@@ -64,7 +64,7 @@ def from_callables(
             serdes=config.serdes,
         )
 
-    def execute_item(self, child_context, executable: Executable[Callable]) -> R:
+    def execute_item(self, child_context, executable: Executable[Callable]) -> R:  # noqa: PLR6301
         logger.debug("🔀 Processing parallel branch: %s", executable.index)
         result: R = executable.func(child_context)
         logger.debug("✅ Processed parallel branch: %s", executable.index)
@@ -80,7 +80,5 @@ def parallel_handler(
     ],
 ) -> BatchResult[R]:
     """Execute multiple operations in parallel."""
-    executor = ParallelExecutor.from_callables(
-        callables, config if config else ParallelConfig()
-    )
+    executor = ParallelExecutor.from_callables(callables, config or ParallelConfig())
     return executor.execute(execution_state, run_in_child_context)

src/aws_durable_execution_sdk_python/operation/step.py

@@ -183,9 +183,7 @@ def retry_handler(
     """Checkpoint and suspend for replay if retry required, otherwise raise error."""
     error_object = ErrorObject.from_exception(error)
 
-    retry_strategy = (
-        config.retry_strategy if config.retry_strategy else RetryPresets.default()
-    )
+    retry_strategy = config.retry_strategy or RetryPresets.default()
 
     retry_attempt: int = (
         checkpointed_result.operation.step_details.attempt

src/aws_durable_execution_sdk_python/serdes.py

@@ -30,10 +30,10 @@ def deserialize(self, data: str, serdes_context: SerDesContext) -> T:
 
 
 class JsonSerDes(SerDes[T]):
-    def serialize(self, value: T, _: SerDesContext) -> str:
+    def serialize(self, value: T, _: SerDesContext) -> str:  # noqa: PLR6301
         return json.dumps(value)
 
-    def deserialize(self, data: str, _: SerDesContext) -> T:
+    def deserialize(self, data: str, _: SerDesContext) -> T:  # noqa: PLR6301
         return json.loads(data)
 
 

src/aws_durable_execution_sdk_python/state.py

@@ -105,7 +105,7 @@ def is_started_or_ready(self) -> bool:
         op = self.operation
         if not op:
             return False
-        return op.status in (OperationStatus.STARTED, OperationStatus.READY)
+        return op.status in {OperationStatus.STARTED, OperationStatus.READY}
 
     def is_pending(self) -> bool:
         """Return True if the checkpointed operation is PENDING."""

tests/context_test.py

@@ -8,10 +8,12 @@
 from aws_durable_execution_sdk_python.config import (
     CallbackConfig,
     ChildConfig,
+    InvokeConfig,
     MapConfig,
     ParallelConfig,
     StepConfig,
     WaitForConditionConfig,
+    WaitForConditionDecision,
 )
 from aws_durable_execution_sdk_python.context import Callback, DurableContext
 from aws_durable_execution_sdk_python.exceptions import (
@@ -472,8 +474,6 @@ def test_invoke_basic(mock_handler):
 @patch("aws_durable_execution_sdk_python.context.invoke_handler")
 def test_invoke_with_name_and_config(mock_handler):
     """Test invoke with name and config."""
-    from aws_durable_execution_sdk_python.config import InvokeConfig
-
     mock_handler.return_value = "configured_result"
     mock_state = Mock(spec=ExecutionState)
     mock_state.durable_execution_arn = (
@@ -578,8 +578,6 @@ def test_invoke_with_custom_serdes(mock_handler):
         "arn:aws:durable:us-east-1:123456789012:execution/test"
     )
 
-    from aws_durable_execution_sdk_python.config import InvokeConfig
-
     config = InvokeConfig[dict, dict](
         serdes_payload=CustomDictSerDes(),
         serdes_result=CustomDictSerDes(),
@@ -1019,8 +1017,6 @@ def test_function(context, item, index, items):
 @patch("aws_durable_execution_sdk_python.context.map_handler")
 def test_map_with_name_and_config(mock_handler):
     """Test map with name and config."""
-    from aws_durable_execution_sdk_python.config import MapConfig
-
     mock_handler.return_value = "configured_map_result"
     mock_state = Mock(spec=ExecutionState)
     mock_state.durable_execution_arn = (
@@ -1155,8 +1151,6 @@ def task2(context):
 @patch("aws_durable_execution_sdk_python.context.parallel_handler")
 def test_parallel_with_name_and_config(mock_handler):
     """Test parallel with name and config."""
-    from aws_durable_execution_sdk_python.config import ParallelConfig
-
     mock_handler.return_value = "configured_parallel_result"
     mock_state = Mock(spec=ExecutionState)
     mock_state.durable_execution_arn = (
@@ -1492,8 +1486,6 @@ def test_check(state, check_context):
         return state
 
     def test_wait_strategy(state, attempt):
-        from aws_durable_execution_sdk_python.config import WaitForConditionDecision
-
         return WaitForConditionDecision.STOP
 
     # Create mock state and context