optimizely-opal.opal-tools-sdk 0.1.28.dev0__tar.gz → 0.1.31.dev0__tar.gz

{optimizely_opal_opal_tools_sdk-0.1.28.dev0 → optimizely_opal_opal_tools_sdk-0.1.31.dev0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: optimizely-opal.opal-tools-sdk
-Version: 0.1.28.dev0
+Version: 0.1.31.dev0
 Summary: SDK for creating Opal-compatible tools services
 Home-page: https://github.com/optimizely/opal-tools-sdk
 Author: Optimizely
@@ -19,9 +19,11 @@ Requires-Dist: fastapi>=0.100.0
 Requires-Dist: pydantic>=2.0.0
 Requires-Dist: httpx>=0.24.1
 Provides-Extra: dev
-Requires-Dist: datamodel-code-generator>=0.25.0; extra == "dev"
+Requires-Dist: datamodel-code-generator>=0.56.0; extra == "dev"
 Requires-Dist: pytest>=7.0.0; extra == "dev"
 Requires-Dist: pytest-asyncio>=0.21.0; extra == "dev"
+Requires-Dist: ruff>=0.4.0; extra == "dev"
+Requires-Dist: mypy>=1.0.0; extra == "dev"
 Dynamic: author
 Dynamic: home-page
 Dynamic: requires-python
@@ -144,6 +146,78 @@ async def get_email(parameters: EmailParameters, auth_data: Optional[AuthData] =
     return {"emails": ["Email 1", "Email 2"]}
 ```
 
+## Interactions
+
+Interactions are app-only handlers — actions callable from the UI but hidden from the LLM. Use them when a tool surface needs to expose a button, form submit, or other follow-up action that the model should not be able to call. They follow the MCP "app-only tools" pattern (`visibility: ["app"]`) and are not listed in the `/discovery` endpoint.
+
+**When to use `@interaction` vs `@tool`:**
+
+- Use `@tool` when the LLM should be able to call the function on its own.
+- Use `@interaction` when only the UI (action cards, islands) should call it — the model should never see it.
+
+### Declaring an interaction
+
+```python
+from typing import Optional
+from opal_tools_sdk import ToolsService, interaction, InteractionContext
+from pydantic import BaseModel, Field
+from fastapi import FastAPI
+
+app = FastAPI()
+tools_service = ToolsService(app)
+
+
+class TaskFormInput(BaseModel):
+    title: str = Field(description="Task title")
+    priority: str = Field(default="medium", description="Task priority")
+    assignee: Optional[str] = Field(default=None, description="Assignee email")
+
+
+@interaction(
+    name="submit_task_form",
+    description="Handle task form submission",
+)
+async def handle_task_submission(parameters: TaskFormInput, context: InteractionContext):
+    # parameters is validated against TaskFormInput
+    # context.auth_data carries credentials when auth is configured
+    return {"task_id": "task-123", "message": f"Task '{parameters.title}' created"}
+```
+
+The first parameter is introspected from the Pydantic model the same way `@tool` does it (typing the parameter as `dict` skips schema extraction). The second parameter is an `InteractionContext`.
+
+### Handler signature & `InteractionContext`
+
+`InteractionContext` carries the auth data resolved by TMS from the parent tool's `auth_requirements`:
+
+```python
+@dataclass
+class InteractionContext:
+    auth_data: AuthData | None = None
+```
+
+If the parent tool did not declare auth requirements (or no credentials are available), `context.auth_data` is `None`.
+
+### Generated endpoint
+
+The SDK exposes a single shared endpoint for all interactions:
+
+```
+POST /interactions/execute
+Content-Type: application/json
+
+{
+  "name": "submit_task_form",
+  "parameters": {"title": "Ship docs", "priority": "high"},
+  "auth": {"provider": "...", "credentials": {...}}
+}
+```
+
+The response is whatever the handler returns, serialized as JSON. Interactions are **not** listed in `/discovery`.
+
+### Name uniqueness
+
+Interaction names must be unique across both tools and interactions in the same service, since both can be exported as MCP tools. Registering an interaction with a name that conflicts with an existing tool or interaction raises `ValueError`.
+
 ## Island Components
 
 The SDK includes Island components for creating interactive UI responses that allow users to input data and trigger actions.

{optimizely_opal_opal_tools_sdk-0.1.28.dev0 → optimizely_opal_opal_tools_sdk-0.1.31.dev0}/README.md

@@ -116,6 +116,78 @@ async def get_email(parameters: EmailParameters, auth_data: Optional[AuthData] =
     return {"emails": ["Email 1", "Email 2"]}
 ```
 
+## Interactions
+
+Interactions are app-only handlers — actions callable from the UI but hidden from the LLM. Use them when a tool surface needs to expose a button, form submit, or other follow-up action that the model should not be able to call. They follow the MCP "app-only tools" pattern (`visibility: ["app"]`) and are not listed in the `/discovery` endpoint.
+
+**When to use `@interaction` vs `@tool`:**
+
+- Use `@tool` when the LLM should be able to call the function on its own.
+- Use `@interaction` when only the UI (action cards, islands) should call it — the model should never see it.
+
+### Declaring an interaction
+
+```python
+from typing import Optional
+from opal_tools_sdk import ToolsService, interaction, InteractionContext
+from pydantic import BaseModel, Field
+from fastapi import FastAPI
+
+app = FastAPI()
+tools_service = ToolsService(app)
+
+
+class TaskFormInput(BaseModel):
+    title: str = Field(description="Task title")
+    priority: str = Field(default="medium", description="Task priority")
+    assignee: Optional[str] = Field(default=None, description="Assignee email")
+
+
+@interaction(
+    name="submit_task_form",
+    description="Handle task form submission",
+)
+async def handle_task_submission(parameters: TaskFormInput, context: InteractionContext):
+    # parameters is validated against TaskFormInput
+    # context.auth_data carries credentials when auth is configured
+    return {"task_id": "task-123", "message": f"Task '{parameters.title}' created"}
+```
+
+The first parameter is introspected from the Pydantic model the same way `@tool` does it (typing the parameter as `dict` skips schema extraction). The second parameter is an `InteractionContext`.
+
+### Handler signature & `InteractionContext`
+
+`InteractionContext` carries the auth data resolved by TMS from the parent tool's `auth_requirements`:
+
+```python
+@dataclass
+class InteractionContext:
+    auth_data: AuthData | None = None
+```
+
+If the parent tool did not declare auth requirements (or no credentials are available), `context.auth_data` is `None`.
+
+### Generated endpoint
+
+The SDK exposes a single shared endpoint for all interactions:
+
+```
+POST /interactions/execute
+Content-Type: application/json
+
+{
+  "name": "submit_task_form",
+  "parameters": {"title": "Ship docs", "priority": "high"},
+  "auth": {"provider": "...", "credentials": {...}}
+}
+```
+
+The response is whatever the handler returns, serialized as JSON. Interactions are **not** listed in `/discovery`.
+
+### Name uniqueness
+
+Interaction names must be unique across both tools and interactions in the same service, since both can be exported as MCP tools. Registering an interaction with a name that conflicts with an existing tool or interaction raises `ValueError`.
+
 ## Island Components
 
 The SDK includes Island components for creating interactive UI responses that allow users to input data and trigger actions.

{optimizely_opal_opal_tools_sdk-0.1.28.dev0 → optimizely_opal_opal_tools_sdk-0.1.31.dev0}/opal_tools_sdk/__init__.py

@@ -1,9 +1,17 @@
-from .service import ToolsService
-from .decorators import tool, resource, interaction
 from .auth import requires_auth
+from .decorators import interaction, resource, tool
 from .logging import register_logger_factory
-from .models import AuthData, AuthRequirement, Credentials, Environment, InteractionContext, IslandConfig, IslandResponse
+from .models import (
+    AuthData,
+    AuthRequirement,
+    Credentials,
+    Environment,
+    InteractionContext,
+    IslandConfig,
+    IslandResponse,
+)
 from .proteus import UI
+from .service import ToolsService
 
 __version__ = "0.1.14-dev"
 __all__ = [

{optimizely_opal_opal_tools_sdk-0.1.28.dev0 → optimizely_opal_opal_tools_sdk-0.1.31.dev0}/opal_tools_sdk/_registry.py

@@ -1,3 +1,5 @@
 """Internal registry for ToolsService instances."""
 
-services = []
+from typing import Any
+
+services: list[Any] = []

{optimizely_opal_opal_tools_sdk-0.1.28.dev0 → optimizely_opal_opal_tools_sdk-0.1.31.dev0}/opal_tools_sdk/auth.py

@@ -1,7 +1,9 @@
-from typing import Callable, Dict, Any, Optional, List
+from collections.abc import Callable
 from functools import wraps
+
 from fastapi import Header, HTTPException
 
+
 def requires_auth(provider: str, scope_bundle: str, required: bool = True):
     """Decorator to indicate that a tool requires authentication.
 
@@ -13,9 +15,10 @@ def requires_auth(provider: str, scope_bundle: str, required: bool = True):
     Returns:
         Decorator function
     """
+
     def decorator(func: Callable):
         @wraps(func)
-        async def wrapper(*args, authorization: Optional[str] = Header(None), **kwargs):
+        async def wrapper(*args, authorization: str | None = Header(None), **kwargs):
             if required and not authorization:
                 raise HTTPException(status_code=401, detail="Authentication required")
 
@@ -24,18 +27,14 @@ def requires_auth(provider: str, scope_bundle: str, required: bool = True):
             return await func(*args, authorization=authorization, **kwargs)
 
         # Store auth requirements in function metadata
-        auth_req = {
-            "provider": provider,
-            "scope_bundle": scope_bundle,
-            "required": required
-        }
+        auth_req = {"provider": provider, "scope_bundle": scope_bundle, "required": required}
 
         # Initialize the list if it doesn't exist
         if not hasattr(wrapper, "__auth_requirements__"):
-            wrapper.__auth_requirements__ = []
+            wrapper.__auth_requirements__ = []  # type: ignore[attr-defined]
 
         # Add this auth requirement to the list
-        wrapper.__auth_requirements__.append(auth_req)
+        wrapper.__auth_requirements__.append(auth_req)  # type: ignore[attr-defined]
 
         return wrapper
 

{optimizely_opal_opal_tools_sdk-0.1.28.dev0 → optimizely_opal_opal_tools_sdk-0.1.31.dev0}/opal_tools_sdk/decorators.py

@@ -1,17 +1,20 @@
 import inspect
-import re
-import logging
-from typing import Callable, Any, List, Dict, Type, get_args, get_origin, get_type_hints, Optional, Union
-from fastapi import APIRouter, Depends, Header, HTTPException
-from pydantic import BaseModel
+from collections.abc import Callable
+from typing import (
+    Any,
+    Union,
+    get_args,
+    get_origin,
+    get_type_hints,
+)
 
-from .models import Parameter, ParameterType, AuthRequirement
 from .logging import get_logger
+from .models import AuthRequirement, Parameter, ParameterType
 
 logger = get_logger(__name__)
 
 
-def _resolve_json_schema(schema: dict, defs: dict, _seen: Optional[set] = None) -> dict:
+def _resolve_json_schema(schema: dict, defs: dict, _seen: set | None = None) -> dict:
     """Resolve $ref references and simplify Pydantic v2 JSON schema output.
 
     - Resolves ``$ref`` pointers by looking up ``$defs``
@@ -40,7 +43,8 @@ def _resolve_json_schema(schema: dict, defs: dict, _seen: Optional[set] = None)
     # Simplify anyOf (Pydantic Optional encoding)
     if "anyOf" in schema:
         non_null = [
-            s for s in schema["anyOf"]
+            s
+            for s in schema["anyOf"]
             if (s.get("type") != "null" and "$ref" not in s) or "$ref" in s
         ]
         if len(non_null) == 1:
@@ -85,11 +89,12 @@ def _resolve_json_schema(schema: dict, defs: dict, _seen: Optional[set] = None)
 
     return result
 
+
 def tool(
     name: str,
     description: str,
-    auth_requirements: Optional[List[Dict[str, Any]]] = None,
-    ui_resource: Optional[str] = None,
+    auth_requirements: list[dict[str, Any]] | None = None,
+    ui_resource: str | None = None,
 ):
     """Decorator to register a function as an Opal tool.
 
@@ -97,8 +102,10 @@ def tool(
         name: Name of the tool
         description: Description of the tool
         auth_requirements: Authentication requirements (optional)
-            Format: [{"provider": "oauth_provider", "scope_bundle": "permissions_scope", "required": True}, ...]
-            Example: [{"provider": "google", "scope_bundle": "calendar", "required": True}]
+            Format: [{"provider": "oauth_provider",
+            "scope_bundle": "permissions_scope", "required": True}, ...]
+            Example: [{"provider": "google",
+            "scope_bundle": "calendar", "required": True}]
         ui_resource: URI of associated UI resource for dynamic rendering (optional)
             Example: "ui://my-app/create-form"
 
@@ -113,6 +120,7 @@ def tool(
         If ui_resource is specified, the frontend can fetch the resource to render a dynamic UI
         for this tool without hardcoded integrations.
     """
+
     def decorator(func: Callable):
         # Get the ToolsService instance from the global registry
         from . import _registry
@@ -121,35 +129,39 @@ def tool(
         sig = inspect.signature(func)
         type_hints = get_type_hints(func)
 
-        parameters: List[Parameter] = []
+        parameters: list[Parameter] = []
         param_model = None
 
         # Look for a parameter that is a pydantic model (for parameters)
         for param_name, param in sig.parameters.items():
             if param_name in type_hints:
                 param_type = type_hints[param_name]
-                if hasattr(param_type, '__fields__') or hasattr(param_type, 'model_fields'):  # Pydantic v1 or v2
+                if hasattr(param_type, "__fields__") or hasattr(
+                    param_type, "model_fields"
+                ):  # Pydantic v1 or v2
                     param_model = param_type
                     break
 
         # If we found a pydantic model, extract parameters
         if param_model:
-            model_fields = getattr(param_model, 'model_fields', getattr(param_model, '__fields__', {}))
+            model_fields = getattr(
+                param_model, "model_fields", getattr(param_model, "__fields__", {})
+            )
             for field_name, field in model_fields.items():
                 # Get field metadata
-                field_info = field.field_info if hasattr(field, 'field_info') else field
+                field_info = field.field_info if hasattr(field, "field_info") else field
 
                 # Determine type
-                if hasattr(field, 'outer_type_'):
+                if hasattr(field, "outer_type_"):
                     field_type = field.outer_type_
-                elif hasattr(field, 'annotation'):
+                elif hasattr(field, "annotation"):
                     field_type = field.annotation
                 else:
                     field_type = str
 
                 # Check if the field is Optional (Union with None)
                 # Optional[X] is equivalent to Union[X, None]
-                type_args = getattr(field_type, '__args__', ())
+                type_args = getattr(field_type, "__args__", ())
                 is_optional = get_origin(field_type) is Union and type(None) in type_args
 
                 # Extract the actual type from Optional[T]
@@ -177,9 +189,9 @@ def tool(
                     items_schema = None
                     if type_args_inner:
                         item_type = type_args_inner[0]
-                        if hasattr(item_type, 'model_json_schema'):
+                        if hasattr(item_type, "model_json_schema"):
                             raw = item_type.model_json_schema()
-                            raw_defs = raw.pop('$defs', {})
+                            raw_defs = raw.pop("$defs", {})
                             items_schema = _resolve_json_schema(raw, raw_defs)
                         elif item_type is str:
                             items_schema = {"type": "string"}
@@ -193,10 +205,10 @@ def tool(
                         full_schema = {"type": "array", "items": items_schema}
                 elif field_type is dict or get_origin(field_type) is dict:
                     param_type = ParameterType.dictionary
-                elif hasattr(field_type, 'model_json_schema'):
+                elif hasattr(field_type, "model_json_schema"):
                     param_type = ParameterType.dictionary
                     raw = field_type.model_json_schema()
-                    raw_defs = raw.pop('$defs', {})
+                    raw_defs = raw.pop("$defs", {})
                     resolved = _resolve_json_schema(raw, raw_defs)
                     full_schema = resolved
 
@@ -208,10 +220,10 @@ def tool(
                 elif is_optional:
                     required = False
                 # Check for Pydantic v2 is_required() method
-                elif hasattr(field_info, 'is_required'):
+                elif hasattr(field_info, "is_required"):
                     required = field_info.is_required()
                 # Fall back to checking if default is ... (Pydantic v1/v2 compatibility)
-                elif hasattr(field_info, 'default'):
+                elif hasattr(field_info, "default"):
                     required = field_info.default is ...
                 else:
                     # If no default attribute at all, assume required
@@ -222,9 +234,9 @@ def tool(
 
                 # Get description
                 description_text = ""
-                if hasattr(field_info, 'description'):
+                if hasattr(field_info, "description"):
                     description_text = field_info.description
-                elif hasattr(field, 'description'):
+                elif hasattr(field, "description"):
                     description_text = field.description
 
                 # Build the complete schema with description included
@@ -232,16 +244,21 @@ def tool(
                     if "description" not in full_schema:
                         full_schema["description"] = description_text
 
-                parameters.append(Parameter(
-                    name=field_name,
-                    param_type=param_type,
-                    description=description_text,
-                    required=required,
-                    in_context=in_context,
-                    schema=full_schema,
-                ))
+                parameters.append(
+                    Parameter(
+                        name=field_name,
+                        param_type=param_type,
+                        description=description_text,
+                        required=required,
+                        in_context=in_context,
+                        schema=full_schema,
+                    )
+                )
 
-                logger.info(f"Registered parameter: {field_name} of type {param_type.value}, required: {required}")
+                logger.info(
+                    f"Registered parameter: {field_name} "
+                    f"of type {param_type.value}, required: {required}"
+                )
         else:
             logger.warning(f"Warning: No parameter model found for {name}")
 
@@ -252,16 +269,21 @@ def tool(
         if auth_requirements:
             auth_req_list = []
             for auth_req in auth_requirements:
-                auth_req_list.append(AuthRequirement(
-                    provider=auth_req.get("provider", ""),
-                    scope_bundle=auth_req.get("scope_bundle", ""),
-                    required=auth_req.get("required", True)
-                ))
+                auth_req_list.append(
+                    AuthRequirement(
+                        provider=auth_req.get("provider", ""),
+                        scope_bundle=auth_req.get("scope_bundle", ""),
+                        required=auth_req.get("required", True),
+                    )
+                )
 
         logger.info(f"Registering tool {name} with endpoint {endpoint}")
 
         if not _registry.services:
-            logger.warning("No services registered in registry! Make sure to create ToolsService before decorating functions.")
+            logger.warning(
+                "No services registered in registry! "
+                "Make sure to create ToolsService before decorating functions."
+            )
 
         for service in _registry.services:
             service.register_tool(
@@ -271,7 +293,7 @@ def tool(
                 parameters=parameters,
                 endpoint=endpoint,
                 auth_requirements=auth_req_list,
-                ui_resource=ui_resource
+                ui_resource=ui_resource,
             )
 
         return func
@@ -317,6 +339,7 @@ def interaction(
             task_id = await create_task(parameters.title, parameters.priority)
             return {"task_id": task_id}
     """
+
     def decorator(func: Callable):
         from . import _registry
 
@@ -326,29 +349,31 @@ def interaction(
         sig = inspect.signature(func)
         type_hints = get_type_hints(func)
 
-        parameters: List[Parameter] = []
+        parameters: list[Parameter] = []
         param_model = None
 
         for param_name, param in sig.parameters.items():
             if param_name in type_hints:
                 param_type = type_hints[param_name]
-                if hasattr(param_type, '__fields__') or hasattr(param_type, 'model_fields'):
+                if hasattr(param_type, "__fields__") or hasattr(param_type, "model_fields"):
                     param_model = param_type
                     break
 
         if param_model:
-            model_fields = getattr(param_model, 'model_fields', getattr(param_model, '__fields__', {}))
+            model_fields = getattr(
+                param_model, "model_fields", getattr(param_model, "__fields__", {})
+            )
             for field_name, field in model_fields.items():
-                field_info = field.field_info if hasattr(field, 'field_info') else field
+                field_info = field.field_info if hasattr(field, "field_info") else field
 
-                if hasattr(field, 'outer_type_'):
+                if hasattr(field, "outer_type_"):
                     field_type = field.outer_type_
-                elif hasattr(field, 'annotation'):
+                elif hasattr(field, "annotation"):
                     field_type = field.annotation
                 else:
                     field_type = str
 
-                type_args = getattr(field_type, '__args__', ())
+                type_args = getattr(field_type, "__args__", ())
                 is_optional = get_origin(field_type) is Union and type(None) in type_args
 
                 if is_optional and type_args:
@@ -374,28 +399,33 @@ def interaction(
                     required = field_info_extra["required"]
                 elif is_optional:
                     required = False
-                elif hasattr(field_info, 'is_required'):
+                elif hasattr(field_info, "is_required"):
                     required = field_info.is_required()
-                elif hasattr(field_info, 'default'):
+                elif hasattr(field_info, "default"):
                     required = field_info.default is ...
                 else:
                     required = True
 
                 description_text = ""
-                if hasattr(field_info, 'description'):
+                if hasattr(field_info, "description"):
                     description_text = field_info.description
-                elif hasattr(field, 'description'):
+                elif hasattr(field, "description"):
                     description_text = field.description
 
-                parameters.append(Parameter(
-                    name=field_name,
-                    param_type=param_type,
-                    description=description_text,
-                    required=required,
-                ))
+                parameters.append(
+                    Parameter(
+                        name=field_name,
+                        param_type=param_type,
+                        description=description_text,
+                        required=required,
+                    )
+                )
 
         if not _registry.services:
-            logger.warning("No services registered in registry! Make sure to create ToolsService before decorating functions.")
+            logger.warning(
+                "No services registered in registry! "
+                "Make sure to create ToolsService before decorating functions."
+            )
 
         for service in _registry.services:
             service.register_interaction(
@@ -413,9 +443,9 @@ def interaction(
 def resource(
     uri: str,
     name: str,
-    description: Optional[str] = None,
-    mime_type: Optional[str] = None,
-    title: Optional[str] = None,
+    description: str | None = None,
+    mime_type: str | None = None,
+    title: str | None = None,
 ):
     """Decorator to register a function as an MCP resource.
 
@@ -423,7 +453,8 @@ def resource(
         uri: The unique URI for this resource (e.g., "ui://my-app/create-form")
         name: Name of the resource
         description: Description of the resource (optional)
-        mime_type: MIME type of the resource content (optional, e.g., "application/vnd.opal.proteus+json")
+        mime_type: MIME type of the resource content
+            (optional, e.g., "application/vnd.opal.proteus+json")
         title: Human-readable title for the resource (optional)
 
     Returns:
@@ -465,6 +496,7 @@ def resource(
                     actions=[UI.Action(children="Save", appearance="primary")]
                 )
     """
+
     def decorator(func: Callable):
         # Get the ToolsService instance from the global registry
         from . import _registry
@@ -472,7 +504,10 @@ def resource(
         logger.info(f"Registering resource {name} with URI {uri}")
 
         if not _registry.services:
-            logger.warning("No services registered in registry! Make sure to create ToolsService before decorating functions.")
+            logger.warning(
+                "No services registered in registry! "
+                "Make sure to create ToolsService before decorating functions."
+            )
 
         for service in _registry.services:
             service.register_resource(

{optimizely_opal_opal_tools_sdk-0.1.28.dev0 → optimizely_opal_opal_tools_sdk-0.1.31.dev0}/opal_tools_sdk/logging.py

@@ -1,12 +1,14 @@
 import logging
 import sys
-from typing import Optional, Callable
+from collections.abc import Callable
+from typing import TypeAlias
 
 # Type alias for a logger factory function
-type LoggerFactory = Callable[[Optional[str]], logging.Logger]
+LoggerFactory: TypeAlias = Callable[[str | None], logging.Logger]
 
 # Internal variable to hold a custom logger factory
-_custom_logger_factory: Optional[LoggerFactory] = None
+_custom_logger_factory: LoggerFactory | None = None
+
 
 def register_logger_factory(factory: LoggerFactory):
     """
@@ -16,9 +18,11 @@ def register_logger_factory(factory: LoggerFactory):
     global _custom_logger_factory
     _custom_logger_factory = factory
 
-def get_logger(name: str = None) -> logging.Logger:
-    """
-    Returns a logger configured to output to the console, or uses a registered custom logger factory.
+
+def get_logger(name: str | None = None) -> logging.Logger:
+    """Return a logger configured for console output.
+
+    Uses a registered custom logger factory if available.
     If no name is provided, uses the root logger.
     """
     if _custom_logger_factory is not None:
@@ -27,8 +31,7 @@ def get_logger(name: str = None) -> logging.Logger:
     if not logger.handlers:
         handler = logging.StreamHandler(sys.stdout)
         formatter = logging.Formatter(
-            fmt='%(asctime)s %(levelname)s [%(name)s] %(message)s',
-            datefmt='%Y-%m-%d %H:%M:%S'
+            fmt="%(asctime)s %(levelname)s [%(name)s] %(message)s", datefmt="%Y-%m-%d %H:%M:%S"
         )
         handler.setFormatter(formatter)
         logger.addHandler(handler)