atlan-application-sdk 0.1.1rc30__tar.gz → 0.1.1rc32__tar.gz

{atlan_application_sdk-0.1.1rc30 → atlan_application_sdk-0.1.1rc32}/.cursor/BUGBOT.md

@@ -14,7 +14,7 @@
 - **Cognitive Load**: Can a new developer understand this change with less cognitive load?
 - **Magic Numbers/Strings**: All constants properly defined and named in @application_sdk/constants.py
 - **Spell Check**: No typos in code, comments, docstrings, or documentation
-- **Exception Handling Standards**: All exception handling must follow these principles. See detailed guidelines in [exception-handling.mdc](mdc:.cursor/rules/exception-handling.mdc).
+- **Exception Handling Standards**: All exception handling must follow these principles. See detailed guidelines in [exception-handling.mdc](@.cursor/rules/exception-handling.mdc).
 
 ### 🏗️ Architecture & Design
 
@@ -32,7 +32,7 @@
 
 ### 🧪 Testing
 
-- **Testing Standards**: Testing standards are defined in [testing.mdc](mdc:.cursor/rules/testing.mdc)
+- **Testing Standards**: Testing standards are defined in [testing.mdc](@.cursor/rules/testing.mdc)
 - **Test Coverage**: New code has corresponding tests (unit/integration/e2e as appropriate)
 - **Edge Cases**: Error conditions and boundary cases are tested
 - **Mock Strategy**: External dependencies properly mocked/isolated
@@ -43,7 +43,7 @@
 - **Input Validation**: All external inputs validated and sanitized
 - **Secrets Management**: No secrets in code; proper credential handling
 - **SQL Injection**: Parameterized queries used for all SQL operations
-- **Performance Standards**: All performance considerations must follow these principles. See detailed guidelines in [performance.mdc](mdc:.cursor/rules/performance.mdc).
+- **Performance Standards**: All performance considerations must follow these principles. See detailed guidelines in [performance.mdc](@.cursor/rules/performance.mdc).
 - **Memory Management**: Resources properly closed, large datasets processed in chunks
 - **DataFrame Optimization**: Appropriate dtypes, avoid unnecessary copies, use chunked processing
 - **SQL Query Efficiency**: Use LIMIT, specific columns, proper WHERE clauses, connection pooling
@@ -54,7 +54,7 @@
 
 ### 📊 Observability & Logging
 
-- **Logging Standards**: logging standards are defined in [logging.mdc](mdc:.cursor/rules/logging.mdc)
+- **Logging Standards**: logging standards are defined in [logging.mdc](@.cursor/rules/logging.mdc)
 - **Metrics**: Key operations include appropriate metrics
 - **Error Context**: Error logs include sufficient context for debugging
 - **Trace Information**: Critical paths include trace information

atlan_application_sdk-0.1.1rc32/.github/release_notes.md

@@ -0,0 +1,9 @@
+## v0.1.1rc32 (August 20, 2025)
+
+Full Changelog: https://github.com/atlanhq/application-sdk/compare/v0.1.1rc31...v0.1.1rc32
+
+### Bug Fixes
+
+- update app host (#664) (by @Onkar Ravgan in [24d23cb](https://github.com/atlanhq/application-sdk/commit/24d23cb))
+- file references in cursor rules (#662) (by @Nishchith Shetty in [2395ce3](https://github.com/atlanhq/application-sdk/commit/2395ce3))
+- Parquet file output path with None file names (#659) (by @Onkar Ravgan in [8841660](https://github.com/atlanhq/application-sdk/commit/8841660))

{atlan_application_sdk-0.1.1rc30 → atlan_application_sdk-0.1.1rc32}/CHANGELOG.md

@@ -1,6 +1,30 @@
 # Changelog
 
 
+## v0.1.1rc32 (August 20, 2025)
+
+Full Changelog: https://github.com/atlanhq/application-sdk/compare/v0.1.1rc31...v0.1.1rc32
+
+### Bug Fixes
+
+- update app host (#664) (by @Onkar Ravgan in [24d23cb](https://github.com/atlanhq/application-sdk/commit/24d23cb))
+- file references in cursor rules (#662) (by @Nishchith Shetty in [2395ce3](https://github.com/atlanhq/application-sdk/commit/2395ce3))
+- Parquet file output path with None file names (#659) (by @Onkar Ravgan in [8841660](https://github.com/atlanhq/application-sdk/commit/8841660))
+
+## v0.1.1rc31 (August 14, 2025)
+
+Full Changelog: https://github.com/atlanhq/application-sdk/compare/v0.1.1rc30...v0.1.1rc31
+
+### Features
+
+- support for app registration via events (#635) (by @Nishant Munjal in [330b585](https://github.com/atlanhq/application-sdk/commit/330b585))
+
+### Bug Fixes
+
+- error logs related to deployment secrets (#651) (by @Nishchith Shetty in [09f6e5c](https://github.com/atlanhq/application-sdk/commit/09f6e5c))
+
+
+
 ## v0.1.1rc30 (August 13, 2025)
 
 Full Changelog: https://github.com/atlanhq/application-sdk/compare/v0.1.1rc29...v0.1.1rc30

{atlan_application_sdk-0.1.1rc30 → atlan_application_sdk-0.1.1rc32}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: atlan-application-sdk
-Version: 0.1.1rc30
+Version: 0.1.1rc32
 Summary: Atlan Application SDK is a Python library for developing applications on the Atlan Platform
 Project-URL: Repository, https://github.com/atlanhq/application-sdk
 Project-URL: Documentation, https://github.com/atlanhq/application-sdk/README.md

{atlan_application_sdk-0.1.1rc30 → atlan_application_sdk-0.1.1rc32}/application_sdk/application/__init__.py

@@ -3,8 +3,8 @@ from typing import Any, Dict, List, Optional, Tuple, Type
 
 from application_sdk.activities import ActivitiesInterface
 from application_sdk.clients.utils import get_workflow_client
+from application_sdk.events.models import EventRegistration
 from application_sdk.observability.logger_adaptor import get_logger
-from application_sdk.outputs.eventstore import EventRegistration
 from application_sdk.server import ServerInterface
 from application_sdk.server.fastapi import APIServer, HttpWorkflowTrigger
 from application_sdk.server.fastapi.models import EventWorkflowTrigger

{atlan_application_sdk-0.1.1rc30 → atlan_application_sdk-0.1.1rc32}/application_sdk/clients/temporal.py

@@ -1,10 +1,12 @@
 import asyncio
 import uuid
 from concurrent.futures import ThreadPoolExecutor
+from datetime import timedelta
 from typing import Any, Dict, Optional, Sequence, Type
 
 from temporalio import activity, workflow
 from temporalio.client import Client, WorkflowExecutionStatus, WorkflowFailureError
+from temporalio.common import RetryPolicy
 from temporalio.types import CallableType, ClassType
 from temporalio.worker import (
     ActivityInboundInterceptor,
@@ -33,17 +35,17 @@ from application_sdk.constants import (
     WORKFLOW_PORT,
     WORKFLOW_TLS_ENABLED_KEY,
 )
-from application_sdk.inputs.secretstore import SecretStoreInput
-from application_sdk.inputs.statestore import StateType
-from application_sdk.observability.logger_adaptor import get_logger
-from application_sdk.outputs.eventstore import (
+from application_sdk.events.models import (
     ApplicationEventNames,
     Event,
     EventMetadata,
-    EventStore,
     EventTypes,
     WorkflowStates,
 )
+from application_sdk.inputs.secretstore import SecretStoreInput
+from application_sdk.inputs.statestore import StateType
+from application_sdk.observability.logger_adaptor import get_logger
+from application_sdk.outputs.eventstore import EventStore
 from application_sdk.outputs.secretstore import SecretStoreOutput
 from application_sdk.outputs.statestore import StateStoreOutput
 from application_sdk.workflows import WorkflowInterface
@@ -55,11 +57,30 @@ TEMPORAL_NOT_FOUND_FAILURE = (
 )
 
 
+# Activity for publishing events (runs outside sandbox)
+@activity.defn
+async def publish_event(event_data: dict) -> None:
+    """Activity to publish events outside the workflow sandbox.
+
+    Args:
+        event_data (dict): Event data to publish containing event_type, event_name,
+                          metadata, and data fields.
+    """
+    try:
+        event = Event(**event_data)
+        await EventStore.publish_event(event)
+        activity.logger.info(f"Published event: {event_data.get('event_name','')}")
+    except Exception as e:
+        activity.logger.error(f"Failed to publish event: {e}")
+        raise
+
+
 class EventActivityInboundInterceptor(ActivityInboundInterceptor):
     """Interceptor for tracking activity execution events.
 
     This interceptor captures the start and end of activity executions,
     creating events that can be used for monitoring and tracking.
+    Activities run outside the sandbox so they can directly call EventStore.
     """
 
     async def execute_activity(self, input: ExecuteActivityInput) -> Any:
@@ -71,31 +92,28 @@ class EventActivityInboundInterceptor(ActivityInboundInterceptor):
         Returns:
             Any: The result of the activity execution.
         """
-        event = Event(
+        # Extract activity information for tracking
+
+        start_event = Event(
             event_type=EventTypes.APPLICATION_EVENT.value,
             event_name=ApplicationEventNames.ACTIVITY_START.value,
             data={},
         )
-        EventStore.publish_event(event)
+        await EventStore.publish_event(start_event)
 
         output = None
         try:
             output = await super().execute_activity(input)
-        except Exception as e:
+        except Exception:
+            raise
+        finally:
             end_event = Event(
                 event_type=EventTypes.APPLICATION_EVENT.value,
                 event_name=ApplicationEventNames.ACTIVITY_END.value,
                 data={},
             )
-            EventStore.publish_event(end_event)
-            raise e
+            await EventStore.publish_event(end_event)
 
-        end_event = Event(
-            event_type=EventTypes.APPLICATION_EVENT.value,
-            event_name=ApplicationEventNames.ACTIVITY_END.value,
-            data={},
-        )
-        EventStore.publish_event(end_event)
         return output
 
 
@@ -104,6 +122,7 @@ class EventWorkflowInboundInterceptor(WorkflowInboundInterceptor):
 
     This interceptor captures the start and end of workflow executions,
     creating events that can be used for monitoring and tracking.
+    Uses activities to publish events to avoid sandbox restrictions.
     """
 
     async def execute_workflow(self, input: ExecuteWorkflowInput) -> Any:
@@ -115,47 +134,56 @@ class EventWorkflowInboundInterceptor(WorkflowInboundInterceptor):
         Returns:
             Any: The result of the workflow execution.
         """
-        with workflow.unsafe.sandbox_unrestricted():
-            EventStore.publish_event(
-                Event(
-                    metadata=EventMetadata(workflow_state=WorkflowStates.RUNNING.value),
-                    event_type=EventTypes.APPLICATION_EVENT.value,
-                    event_name=ApplicationEventNames.WORKFLOW_START.value,
-                    data={},
-                )
+
+        # Publish workflow start event via activity
+        try:
+            await workflow.execute_activity(
+                publish_event,
+                {
+                    "metadata": EventMetadata(
+                        workflow_state=WorkflowStates.RUNNING.value
+                    ),
+                    "event_type": EventTypes.APPLICATION_EVENT.value,
+                    "event_name": ApplicationEventNames.WORKFLOW_START.value,
+                    "data": {},
+                },
+                schedule_to_close_timeout=timedelta(seconds=30),
+                retry_policy=RetryPolicy(maximum_attempts=3),
             )
+        except Exception as e:
+            workflow.logger.warning(f"Failed to publish workflow start event: {e}")
+            # Don't fail the workflow if event publishing fails
 
         output = None
+        workflow_state = WorkflowStates.FAILED.value  # Default to failed
+
         try:
             output = await super().execute_workflow(input)
-        except Exception as e:
-            with workflow.unsafe.sandbox_unrestricted():
-                EventStore.publish_event(
-                    Event(
-                        metadata=EventMetadata(
-                            workflow_state=WorkflowStates.FAILED.value
-                        ),
-                        event_type=EventTypes.APPLICATION_EVENT.value,
-                        event_name=ApplicationEventNames.WORKFLOW_END.value,
-                        data={},
-                    ),
+            workflow_state = (
+                WorkflowStates.COMPLETED.value
+            )  # Update to completed on success
+        except Exception:
+            workflow_state = WorkflowStates.FAILED.value  # Keep as failed
+            raise
+        finally:
+            # Always publish workflow end event
+            try:
+                await workflow.execute_activity(
+                    publish_event,
+                    {
+                        "metadata": EventMetadata(workflow_state=workflow_state),
+                        "event_type": EventTypes.APPLICATION_EVENT.value,
+                        "event_name": ApplicationEventNames.WORKFLOW_END.value,
+                        "data": {},
+                    },
+                    schedule_to_close_timeout=timedelta(seconds=30),
+                    retry_policy=RetryPolicy(maximum_attempts=3),
+                )
+            except Exception as publish_error:
+                workflow.logger.warning(
+                    f"Failed to publish workflow end event: {publish_error}"
                 )
-            raise e
 
-        with workflow.unsafe.sandbox_unrestricted():
-            EventStore.publish_event(
-                Event(
-                    metadata=EventMetadata(
-                        workflow_state=WorkflowStates.COMPLETED.value
-                    ),
-                    event_type=EventTypes.APPLICATION_EVENT.value,
-                    event_name=ApplicationEventNames.WORKFLOW_END.value,
-                    data={
-                        "workflow_id": workflow.info().workflow_id,
-                        "workflow_run_id": workflow.info().run_id,
-                    },
-                ),
-            )
         return output
 
 
@@ -513,11 +541,14 @@ class TemporalWorkflowClient(WorkflowClient):
                 f"Started token refresh loop with dynamic interval (initial: {self._token_refresh_interval}s)"
             )
 
+        # Add the publish_event to the activities list
+        extended_activities = list(activities) + [publish_event]
+
         return Worker(
             self.client,
             task_queue=self.worker_task_queue,
             workflows=workflow_classes,
-            activities=activities,
+            activities=extended_activities,  # Use extended activities list
             workflow_runner=SandboxedWorkflowRunner(
                 restrictions=SandboxRestrictions.default.with_passthrough_modules(
                     *passthrough_modules

{atlan_application_sdk-0.1.1rc30 → atlan_application_sdk-0.1.1rc32}/application_sdk/constants.py

@@ -36,7 +36,7 @@ APPLICATION_NAME = os.getenv("ATLAN_APPLICATION_NAME", "default")
 #: Name of the deployment, used to distinguish between different deployments of the same application
 DEPLOYMENT_NAME = os.getenv("ATLAN_DEPLOYMENT_NAME", LOCAL_ENVIRONMENT)
 #: Host address for the application's HTTP server
-APP_HOST = str(os.getenv("ATLAN_APP_HTTP_HOST", "localhost"))
+APP_HOST = str(os.getenv("ATLAN_APP_HTTP_HOST", "0.0.0.0"))
 #: Port number for the application's HTTP server
 APP_PORT = int(os.getenv("ATLAN_APP_HTTP_PORT", "8000"))
 #: Tenant ID for multi-tenant applications
@@ -128,6 +128,11 @@ DEPLOYMENT_OBJECT_STORE_NAME = os.getenv("DEPLOYMENT_OBJECT_STORE_NAME", "object
 UPSTREAM_OBJECT_STORE_NAME = os.getenv("UPSTREAM_OBJECT_STORE_NAME", "objectstore")
 #: Name of the pubsub component in DAPR
 EVENT_STORE_NAME = os.getenv("EVENT_STORE_NAME", "eventstore")
+#: DAPR binding operation for creating resources
+DAPR_BINDING_OPERATION_CREATE = "create"
+#: Version of worker start events used in the application
+WORKER_START_EVENT_VERSION = "v1"
+
 #: Whether to enable Atlan storage upload
 ENABLE_ATLAN_UPLOAD = os.getenv("ENABLE_ATLAN_UPLOAD", "false").lower() == "true"
 # Dapr Client Configuration
@@ -135,6 +140,7 @@ ENABLE_ATLAN_UPLOAD = os.getenv("ENABLE_ATLAN_UPLOAD", "false").lower() == "true
 DAPR_MAX_GRPC_MESSAGE_LENGTH = int(
     os.getenv("DAPR_MAX_GRPC_MESSAGE_LENGTH", "104857600")
 )
+
 #: Name of the deployment secret store component in DAPR
 DEPLOYMENT_SECRET_STORE_NAME = os.getenv(
     "DEPLOYMENT_SECRET_STORE_NAME", "deployment-secret-store"

atlan_application_sdk-0.1.1rc32/application_sdk/events/__init__.py

@@ -0,0 +1,5 @@
+"""Events module for handling application events.
+
+This module provides classes and utilities for handling various types of events
+in the application, including workflow, activity, and worker events.
+"""

atlan_application_sdk-0.1.1rc32/application_sdk/events/models.py

@@ -0,0 +1,176 @@
+"""Base event classes and models.
+
+This module contains the base classes and models for all events in the application.
+"""
+
+from abc import ABC
+from enum import Enum
+from typing import Any, Dict, List, Optional
+
+from pydantic import BaseModel, Field
+
+from application_sdk.constants import APPLICATION_NAME, WORKER_START_EVENT_VERSION
+
+
+class EventTypes(Enum):
+    """Enumeration of event types."""
+
+    APPLICATION_EVENT = "application_events"
+
+
+class ApplicationEventNames(Enum):
+    """Enumeration of application event names."""
+
+    WORKFLOW_END = "workflow_end"
+    WORKFLOW_START = "workflow_start"
+    ACTIVITY_START = "activity_start"
+    ACTIVITY_END = "activity_end"
+    WORKER_START = "worker_start"
+    WORKER_END = "worker_end"
+    APPLICATION_START = "application_start"
+    APPLICATION_END = "application_end"
+
+
+class WorkflowStates(Enum):
+    """Enumeration of workflow states."""
+
+    UNKNOWN = "unknown"
+    RUNNING = "running"
+    COMPLETED = "completed"
+    FAILED = "failed"
+
+
+class EventMetadata(BaseModel):
+    """Metadata for events.
+
+    Attributes:
+        application_name: Name of the application the event belongs to.
+        created_timestamp: Timestamp when the event was created.
+        workflow_type: Type of the workflow.
+        workflow_id: ID of the workflow.
+        workflow_run_id: Run ID of the workflow.
+        workflow_state: State of the workflow.
+        activity_type: Type of the activity.
+        activity_id: ID of the activity.
+        attempt: Attempt number for the activity.
+        topic_name: Name of the topic for the event.
+    """
+
+    application_name: str = Field(init=True, default=APPLICATION_NAME)
+    created_timestamp: int = Field(init=True, default=0)
+
+    # Workflow information
+    workflow_type: str | None = Field(init=True, default=None)
+    workflow_id: str | None = Field(init=True, default=None)
+    workflow_run_id: str | None = Field(init=True, default=None)
+    workflow_state: str | None = Field(init=True, default=WorkflowStates.UNKNOWN.value)
+
+    # Activity information (Only when in an activity flow)
+    activity_type: str | None = Field(init=True, default=None)
+    activity_id: str | None = Field(init=True, default=None)
+    attempt: int | None = Field(init=True, default=None)
+
+    topic_name: str | None = Field(init=False, default=None)
+
+
+class EventFilter(BaseModel):
+    """Filter for events.
+
+    Attributes:
+        path: Path to filter on.
+        operator: Operator to use for filtering.
+        value: Value to filter by.
+    """
+
+    path: str
+    operator: str
+    value: str
+
+
+class Consumes(BaseModel):
+    """Model for event consumption configuration.
+
+    Attributes:
+        event_id: ID of the event.
+        event_type: Type of the event.
+        event_name: Name of the event.
+        version: Version of the event.
+        filters: List of filters to apply.
+    """
+
+    event_id: str = Field(alias="eventId")
+    event_type: str = Field(alias="eventType")
+    event_name: str = Field(alias="eventName")
+    version: str = Field()
+    filters: List[EventFilter] = Field(init=True, default=[])
+
+
+class EventRegistration(BaseModel):
+    """Model for event registration.
+
+    Attributes:
+        consumes: List of events to consume.
+        produces: List of events to produce.
+    """
+
+    consumes: List[Consumes] = Field(init=True, default=[])
+    produces: List[Dict[str, Any]] = Field(init=True, default=[])
+
+
+class Event(BaseModel, ABC):
+    """Base class for all events.
+
+    Attributes:
+        metadata: Metadata for the event.
+        event_type: Type of the event.
+        event_name: Name of the event.
+        data: Data payload of the event.
+    """
+
+    metadata: EventMetadata = Field(init=True, default_factory=EventMetadata)
+
+    event_type: str
+    event_name: str
+
+    data: Dict[str, Any]
+
+    def get_topic_name(self):
+        """Get the topic name for this event.
+
+        Returns:
+            str: The topic name.
+        """
+        return self.event_type
+
+    class Config:
+        extra = "allow"
+
+
+class WorkerStartEventData(BaseModel):
+    """Model for worker creation event data.
+
+    This model represents the data structure used when publishing worker creation events.
+    It contains information about the worker configuration and environment.
+
+    Attributes:
+        application_name: Name of the application the worker belongs to.
+        task_queue: Task queue name for the worker.
+        namespace: Temporal namespace for the worker.
+        host: Host address of the Temporal server.
+        port: Port number of the Temporal server.
+        connection_string: Connection string for the Temporal server.
+        max_concurrent_activities: Maximum number of concurrent activities.
+        workflow_count: Number of workflow classes registered.
+        activity_count: Number of activity functions registered.
+    """
+
+    version: str = WORKER_START_EVENT_VERSION
+    application_name: str
+    task_queue: str
+    namespace: str
+    host: str
+    port: str
+    connection_string: str
+    max_concurrent_activities: Optional[int]
+    workflow_count: int
+    activity_count: int

{atlan_application_sdk-0.1.1rc30 → atlan_application_sdk-0.1.1rc32}/application_sdk/inputs/parquet.py

@@ -51,7 +51,12 @@ class ParquetInput(Input):
         Returns:
             Optional[str]: Path to the downloaded local file.
         """
-        parquet_files = glob.glob(local_file_path)
+        # if the path is a directory, then check if the directory has any parquet files
+        parquet_files = []
+        if os.path.isdir(local_file_path):
+            parquet_files = glob.glob(os.path.join(local_file_path, "*.parquet"))
+        else:
+            parquet_files = glob.glob(local_file_path)
         if not parquet_files:
             if self.input_prefix:
                 logger.info(
@@ -162,10 +167,9 @@ class ParquetInput(Input):
                         await self.download_files(path)
                         yield daft.read_parquet(path)
             else:
-                path = f"{self.path}/*.parquet"
-                if self.input_prefix and path:
-                    await self.download_files(path)
-                yield daft.read_parquet(path)
+                if self.path and self.input_prefix:
+                    await self.download_files(self.path)
+                    yield daft.read_parquet(f"{self.path}/*.parquet")
 
         except Exception as error:
             logger.error(

{atlan_application_sdk-0.1.1rc30 → atlan_application_sdk-0.1.1rc32}/application_sdk/inputs/secretstore.py

@@ -7,6 +7,7 @@ from typing import Any, Dict
 
 from dapr.clients import DaprClient
 
+from application_sdk.common.dapr_utils import is_component_registered
 from application_sdk.constants import (
     DEPLOYMENT_NAME,
     DEPLOYMENT_SECRET_PATH,
@@ -22,7 +23,21 @@ logger = get_logger(__name__)
 class SecretStoreInput:
     @classmethod
     def get_deployment_secret(cls) -> Dict[str, Any]:
-        """Get deployment config with caching."""
+        """Get deployment config from the deployment secret store.
+
+        Validates that the deployment secret store component is registered
+        before attempting to fetch secrets to prevent errors.
+
+        Returns:
+            Dict[str, Any]: Deployment configuration data, or empty dict if
+                          component is unavailable or fetch fails.
+        """
+        if not is_component_registered(DEPLOYMENT_SECRET_STORE_NAME):
+            logger.warning(
+                f"Deployment secret store component '{DEPLOYMENT_SECRET_STORE_NAME}' is not registered"
+            )
+            return {}
+
         try:
             return cls.get_secret(DEPLOYMENT_SECRET_PATH, DEPLOYMENT_SECRET_STORE_NAME)
         except Exception as e:

{atlan_application_sdk-0.1.1rc30 → atlan_application_sdk-0.1.1rc32}/application_sdk/observability/observability.py

@@ -16,6 +16,7 @@ from dapr.clients import DaprClient
 from pydantic import BaseModel
 
 from application_sdk.constants import (
+    DAPR_BINDING_OPERATION_CREATE,
     DEPLOYMENT_OBJECT_STORE_NAME,
     ENABLE_OBSERVABILITY_DAPR_SINK,
     LOG_FILE_NAME,
@@ -449,7 +450,7 @@ class AtlanObservability(Generic[T], ABC):
                     with DaprClient() as client:
                         client.invoke_binding(
                             binding_name=DEPLOYMENT_OBJECT_STORE_NAME,
-                            operation="create",
+                            operation=DAPR_BINDING_OPERATION_CREATE,
                             data=file_content,
                             binding_metadata=metadata,
                         )