style: tox -e ruff

Signed-off-by: Samantha Coyle <[email protected]>

Author: sicoyle

dapr_agents/agents/base.py

@@ -103,7 +103,7 @@ class AgentBase(BaseModel, ABC):
     )
     registry_store: Optional[str] = Field(
         default=None,
-        description="Agent registry store name for storing static agent information. Defaults to memory_store state store name if not provided."
+        description="Agent registry store name for storing static agent information. Defaults to memory_store state store name if not provided.",
     )
 
     DEFAULT_SYSTEM_PROMPT: ClassVar[str]
@@ -181,11 +181,7 @@ def model_post_init(self, __context: Any) -> None:
 
         # Initialize Dapr client if storage is persistent
         # This is needed for state store access and agent registration
-        if (
-            self.memory_store
-            and self.memory_store.name
-            and self._dapr_client is None
-        ):
+        if self.memory_store and self.memory_store.name and self._dapr_client is None:
             from dapr.clients import DaprClient
 
             self._dapr_client = DaprClient()
@@ -210,7 +206,7 @@ def model_post_init(self, __context: Any) -> None:
                 "statestore_name": self.memory_store.name,
                 "registry_name": self.registry_store,
             }
-            
+
             self.register_agent(
                 store_name=self.registry_store,
                 store_key="agent_registry",
@@ -620,16 +616,20 @@ def register_agent(
                     )
 
                     # reread to obtain the freshly minted ETag
-                    response = self._dapr_client.get_state(store_name=store_name, key=store_key)
+                    response = self._dapr_client.get_state(
+                        store_name=store_name, key=store_key
+                    )
                     if not response.etag:
                         raise RuntimeError("ETag still missing after init")
-                    
-                existing = self._deserialize_state(response.data) if response.data else {}
+
+                existing = (
+                    self._deserialize_state(response.data) if response.data else {}
+                )
 
                 if existing.get(agent_name) == agent_metadata:
                     logger.debug(f"Agent '{agent_name}' already registered")
                     return
-                
+
                 safe_metadata = self._serialize_metadata(agent_metadata)
 
                 merged = {**existing, agent_name: safe_metadata}
@@ -711,12 +711,13 @@ def _deserialize_state(self, raw: Union[bytes, str, dict]) -> dict:
                 raise ValueError(f"State is not valid JSON: {exc}") from exc
 
         raise TypeError(f"Unsupported state type {type(raw)!r}")
-    
+
     def _serialize_metadata(self, metadata: Any) -> Any:
         """
         Recursively convert Pydantic models (e.g., AgentTool), lists, dicts to JSON-serializable format.
         Handles mixed tools: [AgentTool(...), "string", ...] → [{"name": "..."}, "string", ...]
         """
+
         def convert(obj: Any) -> Any:
             if hasattr(obj, "model_dump"):
                 return obj.model_dump()
@@ -727,4 +728,5 @@ def convert(obj: Any) -> Any:
             if isinstance(obj, dict):
                 return {k: convert(v) for k, v in obj.items()}
             return obj
-        return convert(metadata)
+
+        return convert(metadata)

dapr_agents/agents/durableagent/agent.py

@@ -122,7 +122,9 @@ def model_post_init(self, __context: Any) -> None:
 
         # Load the current workflow instance ID from state using session_id
         logger.debug(f"State after loading: {self.memory_store._current_state}")
-        if self.memory_store._current_state and self.memory_store._current_state.get("instances"):
+        if self.memory_store._current_state and self.memory_store._current_state.get(
+            "instances"
+        ):
             logger.debug(
                 f"Found {len(self.memory_store._current_state['instances'])} instances in state"
             )

dapr_agents/agents/memory_store.py

@@ -11,6 +11,7 @@
 
 logger = logging.getLogger(__name__)
 
+
 class MemoryStore(BaseModel):
     """
     Unified storage for both Agent and DurableAgent.
@@ -61,7 +62,9 @@ class MemoryStore(BaseModel):
     def model_post_init(self, __context: Any) -> None:
         if self.name is None:
             if self._dapr_client is not None:
-                logger.warning("DaprClient initialized but name is None. It will be ignored.")
+                logger.warning(
+                    "DaprClient initialized but name is None. It will be ignored."
+                )
             self._dapr_client = None
         else:
             self._dapr_client = DaprClient()
@@ -117,7 +120,9 @@ def _update_session_index(self, instance_id: str) -> None:
                 try:
                     session_data = json.loads(raw)
                     if not isinstance(session_data, dict):
-                        logger.warning(f"Session data not a dict, resetting: {type(session_data)}")
+                        logger.warning(
+                            f"Session data not a dict, resetting: {type(session_data)}"
+                        )
                         session_data = {}
                 except json.JSONDecodeError as e:
                     logger.error(f"Invalid session JSON for '{session_key}': {e}")
@@ -161,7 +166,9 @@ def _update_session_index(self, instance_id: str) -> None:
                         parsed = json.loads(raw)
                         if isinstance(parsed, dict):
                             index_data["sessions"] = parsed.get("sessions", [])
-                            index_data["last_updated"] = parsed.get("last_updated", index_data["last_updated"])
+                            index_data["last_updated"] = parsed.get(
+                                "last_updated", index_data["last_updated"]
+                            )
                     except json.JSONDecodeError:
                         logger.warning("Corrupted sessions index, resetting")
 
@@ -170,11 +177,9 @@ def _update_session_index(self, instance_id: str) -> None:
                 index_data["last_updated"] = datetime.now().isoformat()
                 self._save_state_with_metadata(sessions_index_key, index_data)
                 logger.debug(f"Registered session '{session_id}' in index")
-                
+
     # TODO: in future remove this in favor of just using client.save_state when we use objects and not dictionaries in storage.
-    def _save_state_with_metadata(
-        self, key: str, data: Any
-    ) -> None:
+    def _save_state_with_metadata(self, key: str, data: Any) -> None:
         """Save state with content type metadata."""
         # Serialize data to JSON string if it's not already
         if isinstance(data, dict):
@@ -185,7 +190,10 @@ def _save_state_with_metadata(
             data_to_save = json.dumps(data)
 
         self._dapr_client.save_state(
-            self.name, key, data_to_save, state_metadata={"contentType": "application/json"}
+            self.name,
+            key,
+            data_to_save,
+            state_metadata={"contentType": "application/json"},
         )
 
     def is_persistent(self) -> bool:
@@ -276,6 +284,7 @@ def _load_messages_from_store(self) -> List[Dict[str, Any]]:
             return data.get("messages", [])
         return []
 
+
 class DurableAgentMessage(MessageContent):
     id: str = Field(
         default_factory=lambda: str(uuid.uuid4()),

dapr_agents/workflow/agentic.py

@@ -60,7 +60,7 @@ class AgenticWorkflow(
 
     registry_store: Optional[str] = Field(
         default=None,
-        description="Agent registry store name for storing static agent information."
+        description="Agent registry store name for storing static agent information.",
     )
 
     # TODO: test this is respected by runtime.
@@ -109,7 +109,7 @@ def model_post_init(self, __context: Any) -> None:
 
         # Set storage key based on agent name
         self.memory_store._set_key(self.name)
-        
+
         logger.info(f"State store '{self.memory_store.name}' initialized.")
         self.initialize_state()
         if self.registry_store is None:
@@ -364,7 +364,9 @@ def register_agent(
                     )
                     # raise an exception to retry the entire operation
                     raise Exception(f"No etag found for key: {store_key}")
-                existing_data = self._deserialize_state(response.data) if response.data else {}
+                existing_data = (
+                    self._deserialize_state(response.data) if response.data else {}
+                )
                 if (agent_name, agent_metadata) in existing_data.items():
                     logger.debug(f"agent {agent_name} already registered.")
                     return None
@@ -423,4 +425,4 @@ def _deserialize_state(self, raw: Union[bytes, str, dict]) -> dict:
             except json.JSONDecodeError as exc:
                 raise ValueError(f"State is not valid JSON: {exc}") from exc
 
-        raise TypeError(f"Unsupported state type {type(raw)!r}")
+        raise TypeError(f"Unsupported state type {type(raw)!r}")

dapr_agents/workflow/mixins/state.py

@@ -55,7 +55,9 @@ def _reconcile_workflow_statuses(self) -> None:
                             updated_instances.append(instance_id)
 
                             # Save the updated instance back to Redis
-                            instance_key = self.memory_store._get_instance_key(instance_id)
+                            instance_key = self.memory_store._get_instance_key(
+                                instance_id
+                            )
                             self.memory_store._save_state_with_metadata(
                                 instance_key, instance_data
                             )
@@ -70,7 +72,9 @@ def _reconcile_workflow_statuses(self) -> None:
                             updated_instances.append(instance_id)
 
                             # Save the updated instance
-                            instance_key = self.memory_store._get_instance_key(instance_id)
+                            instance_key = self.memory_store._get_instance_key(
+                                instance_id
+                            )
                             self.memory_store._save_state_with_metadata(
                                 instance_key, instance_data
                             )
@@ -170,7 +174,9 @@ def initialize_state(self) -> None:
                 logger.debug(
                     "User provided a state as a Pydantic model. Converting to dict."
                 )
-                self.memory_store._current_state = self.memory_store._current_state.model_dump()
+                self.memory_store._current_state = (
+                    self.memory_store._current_state.model_dump()
+                )
 
             if not isinstance(self.memory_store._current_state, dict):
                 raise TypeError(
@@ -209,8 +215,7 @@ def load_state(self) -> dict:
 
             # For durable agents, always load from database to ensure it's the source of truth
             response = self._dapr_client.get_state(
-                self.memory_store.name,
-                self.memory_store._key
+                self.memory_store.name, self.memory_store._key
             )
             if response.data:
                 state_data = self._deserialize_state(response.data)
@@ -227,8 +232,7 @@ def load_state(self) -> dict:
             # Get all sessions for this agent
             sessions_index_key = self.memory_store._get_sessions_index_key()
             response = self._dapr_client.get_state(
-                self.memory_store.name,
-                sessions_index_key
+                self.memory_store.name, sessions_index_key
             )
 
             if response.data:
@@ -242,8 +246,7 @@ def load_state(self) -> dict:
                 for session_id in session_ids:
                     session_key = self.memory_store._get_session_key(session_id)
                     response = self._dapr_client.get_state(
-                        self.memory_store.name,
-                        session_key
+                        self.memory_store.name, session_key
                     )
 
                     if response.data:
@@ -256,8 +259,12 @@ def load_state(self) -> dict:
 
                         # Load each instance
                         for instance_id in instance_ids:
-                            instance_key = self.memory_store._get_instance_key(instance_id)
-                            response = self._dapr_client.get_state(self.memory_store.name, instance_key)
+                            instance_key = self.memory_store._get_instance_key(
+                                instance_id
+                            )
+                            response = self._dapr_client.get_state(
+                                self.memory_store.name, instance_key
+                            )
                             if response.data:
                                 instance_data = self._deserialize_state(response.data)
 
@@ -293,7 +300,9 @@ def load_state(self) -> dict:
             )
             return self.memory_store._current_state
         except Exception as e:
-            logger.error(f"Failed to load state for key '{self.memory_store._key}': {e}")
+            logger.error(
+                f"Failed to load state for key '{self.memory_store._key}': {e}"
+            )
             raise RuntimeError(f"Error loading workflow state: {e}") from e
 
     def get_local_state_file_path(self) -> str:
@@ -428,19 +437,27 @@ def save_state(
                         instance_json = instance_data
                     else:
                         instance_json = json.dumps(instance_data)
-                    self._dapr_client.save_state(self.memory_store.name, instance_key, instance_json)
+                    self._dapr_client.save_state(
+                        self.memory_store.name, instance_key, instance_json
+                    )
                     logger.debug(
                         f"Saved workflow instance {instance_id} to key '{instance_key}'"
                     )
 
             # Save other state data (like chat_history) to main key
             other_state = {
-                k: v for k, v in self.memory_store._current_state.items() if k != "instances"
+                k: v
+                for k, v in self.memory_store._current_state.items()
+                if k != "instances"
             }
             if other_state:
                 other_state_json = json.dumps(other_state)
-                self._dapr_client.save_state(self.memory_store.name, self.memory_store._key, other_state_json)
-                logger.debug(f"Saved non-instance state to key '{self.memory_store._key}'")
+                self._dapr_client.save_state(
+                    self.memory_store.name, self.memory_store._key, other_state_json
+                )
+                logger.debug(
+                    f"Saved non-instance state to key '{self.memory_store._key}'"
+                )
 
             if self.memory_store.local_directory is not None:
                 self.save_state_to_disk(state_data=state_to_save)
@@ -451,7 +468,9 @@ def save_state(
                     f"State reloaded after saving for key '{self.memory_store._key}'."
                 )
         except Exception as e:
-            logger.error(f"Failed to save state for key '{self.memory_store._key}': {e}")
+            logger.error(
+                f"Failed to save state for key '{self.memory_store._key}': {e}"
+            )
             raise
 
     def _deserialize_state(self, raw: Union[bytes, str, dict]) -> dict:
@@ -474,4 +493,4 @@ def _deserialize_state(self, raw: Union[bytes, str, dict]) -> dict:
             except json.JSONDecodeError as exc:
                 raise ValueError(f"State is not valid JSON: {exc}") from exc
 
-        raise TypeError(f"Unsupported state type {type(raw)!r}")
+        raise TypeError(f"Unsupported state type {type(raw)!r}")

dapr_agents/workflow/orchestrators/base.py

@@ -76,12 +76,12 @@ async def trigger_agent(self, name: str, instance_id: str, **kwargs) -> None:
         """Trigger a specific agent to perform an action."""
         pass
 
-    
     def _serialize_metadata(self, metadata: Any) -> Any:
         """
         Recursively convert Pydantic models (e.g., AgentTool), lists, dicts to JSON-serializable format.
         Handles mixed tools: [AgentTool(...), "string", ...] → [{"name": "..."}, "string", ...]
         """
+
         def convert(obj: Any) -> Any:
             if hasattr(obj, "model_dump"):
                 return obj.model_dump()
@@ -92,4 +92,5 @@ def convert(obj: Any) -> Any:
             if isinstance(obj, dict):
                 return {k: convert(v) for k, v in obj.items()}
             return obj
-        return convert(metadata)
+
+        return convert(metadata)