diff --git a/dapr/actor/__init__.py b/dapr/actor/__init__.py index 5c94a8f1..4323caae 100644 --- a/dapr/actor/__init__.py +++ b/dapr/actor/__init__.py @@ -22,12 +22,12 @@ __all__ = [ - "ActorInterface", - "ActorProxy", - "ActorProxyFactory", - "ActorId", - "Actor", - "ActorRuntime", - "Remindable", - "actormethod", + 'ActorInterface', + 'ActorProxy', + 'ActorProxyFactory', + 'ActorId', + 'Actor', + 'ActorRuntime', + 'Remindable', + 'actormethod', ] diff --git a/dapr/actor/client/proxy.py b/dapr/actor/client/proxy.py index 6585ce5c..e7baa90c 100644 --- a/dapr/actor/client/proxy.py +++ b/dapr/actor/client/proxy.py @@ -24,7 +24,7 @@ from dapr.conf import settings # Actor factory Callable type hint. -ACTOR_FACTORY_CALLBACK = Callable[[ActorInterface, str, str], "ActorProxy"] +ACTOR_FACTORY_CALLBACK = Callable[[ActorInterface, str, str], 'ActorProxy'] class ActorFactoryBase(ABC): @@ -34,7 +34,7 @@ def create( actor_type: str, actor_id: ActorId, actor_interface: Optional[Type[ActorInterface]] = None, - ) -> "ActorProxy": + ) -> 'ActorProxy': ... @@ -60,7 +60,7 @@ def create( actor_type: str, actor_id: ActorId, actor_interface: Optional[Type[ActorInterface]] = None, - ) -> "ActorProxy": + ) -> 'ActorProxy': return ActorProxy( self._dapr_client, actor_type, actor_id, actor_interface, self._message_serializer ) @@ -68,7 +68,7 @@ def create( class CallableProxy: def __init__( - self, proxy: "ActorProxy", attr_call_type: Dict[str, Any], message_serializer: Serializer + self, proxy: 'ActorProxy', attr_call_type: Dict[str, Any], message_serializer: Serializer ): self._proxy = proxy self._attr_call_type = attr_call_type @@ -76,7 +76,7 @@ def __init__( async def __call__(self, *args, **kwargs) -> Any: if len(args) > 1: - raise ValueError("does not support multiple arguments") + raise ValueError('does not support multiple arguments') bytes_data = None if len(args) > 0: @@ -85,9 +85,9 @@ async def __call__(self, *args, **kwargs) -> Any: else: bytes_data = self._message_serializer.serialize(args[0]) - rtnval = await self._proxy.invoke_method(self._attr_call_type["actor_method"], bytes_data) + rtnval = await self._proxy.invoke_method(self._attr_call_type['actor_method'], bytes_data) - return self._message_serializer.deserialize(rtnval, self._attr_call_type["return_types"]) + return self._message_serializer.deserialize(rtnval, self._attr_call_type['return_types']) class ActorProxy: @@ -134,7 +134,7 @@ def create( actor_id: ActorId, actor_interface: Optional[Type[ActorInterface]] = None, actor_proxy_factory: Optional[ActorFactoryBase] = None, - ) -> "ActorProxy": + ) -> 'ActorProxy': """Creates ActorProxy client to call actor. Args: @@ -168,7 +168,7 @@ async def invoke_method(self, method: str, raw_body: Optional[bytes] = None) -> """ if raw_body is not None and not isinstance(raw_body, bytes): - raise ValueError(f"raw_body {type(raw_body)} is not bytes type") + raise ValueError(f'raw_body {type(raw_body)} is not bytes type') return await self._dapr_client.invoke_method( self._actor_type, str(self._actor_id), method, raw_body @@ -189,14 +189,14 @@ def __getattr__(self, name: str) -> CallableProxy: AttributeError: method is not defined in Actor interface. """ if not self._actor_interface: - raise ValueError("actor_interface is not set. use invoke method.") + raise ValueError('actor_interface is not set. use invoke method.') if name not in self._dispatchable_attr: get_dispatchable_attrs_from_interface(self._actor_interface, self._dispatchable_attr) attr_call_type = self._dispatchable_attr.get(name) if attr_call_type is None: - raise AttributeError(f"{self._actor_interface.__class__} has no attribute {name}") + raise AttributeError(f'{self._actor_interface.__class__} has no attribute {name}') if name not in self._callable_proxies: self._callable_proxies[name] = CallableProxy( diff --git a/dapr/actor/id.py b/dapr/actor/id.py index b4855f9d..677a1f36 100644 --- a/dapr/actor/id.py +++ b/dapr/actor/id.py @@ -31,7 +31,7 @@ class ActorId: def __init__(self, actor_id: str): if not isinstance(actor_id, str): - raise TypeError(f"Argument actor_id must be of type str, not {type(actor_id)}") + raise TypeError(f'Argument actor_id must be of type str, not {type(actor_id)}') self._id = actor_id @classmethod diff --git a/dapr/actor/runtime/_reminder_data.py b/dapr/actor/runtime/_reminder_data.py index fb6f7bbd..dec698ac 100644 --- a/dapr/actor/runtime/_reminder_data.py +++ b/dapr/actor/runtime/_reminder_data.py @@ -57,7 +57,7 @@ def __init__( self._ttl = ttl if not isinstance(state, bytes): - raise ValueError(f"only bytes are allowed for state: {type(state)}") + raise ValueError(f'only bytes are allowed for state: {type(state)}') self._state = state @@ -92,27 +92,27 @@ def as_dict(self) -> Dict[str, Any]: if self._state is not None: encoded_state = base64.b64encode(self._state) reminderDict: Dict[str, Any] = { - "reminderName": self._reminder_name, - "dueTime": self._due_time, - "period": self._period, - "data": encoded_state.decode("utf-8"), + 'reminderName': self._reminder_name, + 'dueTime': self._due_time, + 'period': self._period, + 'data': encoded_state.decode('utf-8'), } if self._ttl is not None: - reminderDict.update({"ttl": self._ttl}) + reminderDict.update({'ttl': self._ttl}) return reminderDict @classmethod - def from_dict(cls, reminder_name: str, obj: Dict[str, Any]) -> "ActorReminderData": + def from_dict(cls, reminder_name: str, obj: Dict[str, Any]) -> 'ActorReminderData': """Creates :class:`ActorReminderData` object from dict object.""" - b64encoded_state = obj.get("data") + b64encoded_state = obj.get('data') state_bytes = None if b64encoded_state is not None and len(b64encoded_state) > 0: state_bytes = base64.b64decode(b64encoded_state) - if "ttl" in obj: + if 'ttl' in obj: return ActorReminderData( - reminder_name, state_bytes, obj["dueTime"], obj["period"], obj["ttl"] + reminder_name, state_bytes, obj['dueTime'], obj['period'], obj['ttl'] ) else: - return ActorReminderData(reminder_name, state_bytes, obj["dueTime"], obj["period"]) + return ActorReminderData(reminder_name, state_bytes, obj['dueTime'], obj['period']) diff --git a/dapr/actor/runtime/_state_provider.py b/dapr/actor/runtime/_state_provider.py index c5a745b3..7fc78ce7 100644 --- a/dapr/actor/runtime/_state_provider.py +++ b/dapr/actor/runtime/_state_provider.py @@ -23,9 +23,9 @@ # Mapping StateChangeKind to Dapr State Operation _MAP_CHANGE_KIND_TO_OPERATION = { - StateChangeKind.remove: b"delete", - StateChangeKind.add: b"upsert", - StateChangeKind.update: b"upsert", + StateChangeKind.remove: b'delete', + StateChangeKind.add: b'upsert', + StateChangeKind.update: b'upsert', } @@ -79,24 +79,24 @@ async def save_state( """ json_output = io.BytesIO() - json_output.write(b"[") + json_output.write(b'[') first_state = True for state in state_changes: if not first_state: - json_output.write(b",") - operation = _MAP_CHANGE_KIND_TO_OPERATION.get(state.change_kind) or b"" + json_output.write(b',') + operation = _MAP_CHANGE_KIND_TO_OPERATION.get(state.change_kind) or b'' json_output.write(b'{"operation":"') json_output.write(operation) json_output.write(b'","request":{"key":"') - json_output.write(state.state_name.encode("utf-8")) + json_output.write(state.state_name.encode('utf-8')) json_output.write(b'"') if state.value is not None: serialized = self._state_serializer.serialize(state.value) json_output.write(b',"value":') json_output.write(serialized) - json_output.write(b"}}") + json_output.write(b'}}') first_state = False - json_output.write(b"]") + json_output.write(b']') data = json_output.getvalue() json_output.close() await self._state_client.save_state_transactionally(actor_type, actor_id, data) diff --git a/dapr/actor/runtime/_timer_data.py b/dapr/actor/runtime/_timer_data.py index c274e2d9..99a9c04e 100644 --- a/dapr/actor/runtime/_timer_data.py +++ b/dapr/actor/runtime/_timer_data.py @@ -97,13 +97,13 @@ def as_dict(self) -> Dict[str, Any]: """ timerDict: Dict[str, Any] = { - "callback": self._callback, - "data": self._state, - "dueTime": self._due_time, - "period": self._period, + 'callback': self._callback, + 'data': self._state, + 'dueTime': self._due_time, + 'period': self._period, } if self._ttl: - timerDict.update({"ttl": self._ttl}) + timerDict.update({'ttl': self._ttl}) return timerDict diff --git a/dapr/actor/runtime/_type_information.py b/dapr/actor/runtime/_type_information.py index bbb8ec03..72566eb1 100644 --- a/dapr/actor/runtime/_type_information.py +++ b/dapr/actor/runtime/_type_information.py @@ -31,8 +31,8 @@ class ActorTypeInformation: def __init__( self, name: str, - implementation_class: Type["Actor"], - actor_bases: List[Type["ActorInterface"]], + implementation_class: Type['Actor'], + actor_bases: List[Type['ActorInterface']], ): self._name = name self._impl_type = implementation_class @@ -44,12 +44,12 @@ def type_name(self) -> str: return self._name @property - def implementation_type(self) -> Type["Actor"]: + def implementation_type(self) -> Type['Actor']: """Returns Actor implementation type.""" return self._impl_type @property - def actor_interfaces(self) -> List[Type["ActorInterface"]]: + def actor_interfaces(self) -> List[Type['ActorInterface']]: """Returns the list of :class:`ActorInterface` of this type.""" return self._actor_bases @@ -58,7 +58,7 @@ def is_remindable(self) -> bool: return Remindable in self._impl_type.__bases__ @classmethod - def create(cls, actor_class: Type["Actor"]) -> "ActorTypeInformation": + def create(cls, actor_class: Type['Actor']) -> 'ActorTypeInformation': """Creates :class:`ActorTypeInformation` for actor_class. Args: @@ -69,10 +69,10 @@ def create(cls, actor_class: Type["Actor"]) -> "ActorTypeInformation": and actor base class deriving :class:`ActorInterface` """ if not is_dapr_actor(actor_class): - raise ValueError(f"{actor_class.__name__} is not actor") + raise ValueError(f'{actor_class.__name__} is not actor') actors = get_actor_interfaces(actor_class) if len(actors) == 0: - raise ValueError(f"{actor_class.__name__} does not implement ActorInterface") + raise ValueError(f'{actor_class.__name__} does not implement ActorInterface') return ActorTypeInformation(actor_class.__name__, actor_class, actors) diff --git a/dapr/actor/runtime/_type_utils.py b/dapr/actor/runtime/_type_utils.py index 46d97c31..37f9c173 100644 --- a/dapr/actor/runtime/_type_utils.py +++ b/dapr/actor/runtime/_type_utils.py @@ -23,13 +23,13 @@ def get_class_method_args(func: Any) -> List[str]: args = func.__code__.co_varnames[: func.__code__.co_argcount] # Exclude self, cls arguments - if args[0] == "self" or args[0] == "cls": + if args[0] == 'self' or args[0] == 'cls': args = args[1:] return list(args) def get_method_arg_types(func: Any) -> List[Type]: - annotations = getattr(func, "__annotations__") + annotations = getattr(func, '__annotations__') args = get_class_method_args(func) arg_types = [] for arg_name in args: @@ -39,26 +39,26 @@ def get_method_arg_types(func: Any) -> List[Type]: def get_method_return_types(func: Any) -> Type: - annotations = getattr(func, "__annotations__") - if len(annotations) == 0 or not annotations["return"]: + annotations = getattr(func, '__annotations__') + if len(annotations) == 0 or not annotations['return']: return object - return annotations["return"] + return annotations['return'] def get_dispatchable_attrs_from_interface( actor_interface: Type[ActorInterface], dispatch_map: Dict[str, Any] ) -> None: for attr, v in actor_interface.__dict__.items(): - if attr.startswith("_") or not callable(v): + if attr.startswith('_') or not callable(v): continue - actor_method_name = getattr(v, "__actormethod__") if hasattr(v, "__actormethod__") else attr + actor_method_name = getattr(v, '__actormethod__') if hasattr(v, '__actormethod__') else attr dispatch_map[actor_method_name] = { - "actor_method": actor_method_name, - "method_name": attr, - "arg_names": get_class_method_args(v), - "arg_types": get_method_arg_types(v), - "return_types": get_method_return_types(v), + 'actor_method': actor_method_name, + 'method_name': attr, + 'arg_names': get_class_method_args(v), + 'arg_types': get_method_arg_types(v), + 'return_types': get_method_return_types(v), } @@ -77,7 +77,7 @@ def get_dispatchable_attrs(actor_class: Type[Actor]) -> Dict[str, Any]: # Find all user actor interfaces derived from ActorInterface actor_interfaces = get_actor_interfaces(actor_class) if len(actor_interfaces) == 0: - raise ValueError(f"{actor_class.__name__} has not inherited from ActorInterface") + raise ValueError(f'{actor_class.__name__} has not inherited from ActorInterface') # Find all dispatchable attributes dispatch_map: Dict[str, Any] = {} diff --git a/dapr/actor/runtime/actor.py b/dapr/actor/runtime/actor.py index 0e8eb7fc..9f8d6ff8 100644 --- a/dapr/actor/runtime/actor.py +++ b/dapr/actor/runtime/actor.py @@ -64,7 +64,7 @@ def runtime_ctx(self) -> ActorRuntimeContext: return self._runtime_ctx def __get_new_timer_name(self): - return f"{self.id}_Timer_{uuid.uuid4()}" + return f'{self.id}_Timer_{uuid.uuid4()}' async def register_timer( self, diff --git a/dapr/actor/runtime/config.py b/dapr/actor/runtime/config.py index fef7060f..8d42ebda 100644 --- a/dapr/actor/runtime/config.py +++ b/dapr/actor/runtime/config.py @@ -34,8 +34,8 @@ def __init__(self, enabled: bool = False, maxStackDepth: int = 32): def as_dict(self) -> Dict[str, Any]: """Returns ActorReentrancyConfig as a dict.""" return { - "enabled": self._enabled, - "maxStackDepth": self._maxStackDepth, + 'enabled': self._enabled, + 'maxStackDepth': self._maxStackDepth, } @@ -85,25 +85,25 @@ def as_dict(self) -> Dict[str, Any]: """Returns ActorTypeConfig as a dict.""" configDict: Dict[str, Any] = dict() - configDict["entities"] = [self._actor_type] + configDict['entities'] = [self._actor_type] if self._actor_idle_timeout is not None: - configDict.update({"actorIdleTimeout": self._actor_idle_timeout}) + configDict.update({'actorIdleTimeout': self._actor_idle_timeout}) if self._actor_scan_interval is not None: - configDict.update({"actorScanInterval": self._actor_scan_interval}) + configDict.update({'actorScanInterval': self._actor_scan_interval}) if self._drain_ongoing_call_timeout is not None: - configDict.update({"drainOngoingCallTimeout": self._drain_ongoing_call_timeout}) + configDict.update({'drainOngoingCallTimeout': self._drain_ongoing_call_timeout}) if self._drain_rebalanced_actors is not None: - configDict.update({"drainRebalancedActors": self._drain_rebalanced_actors}) + configDict.update({'drainRebalancedActors': self._drain_rebalanced_actors}) if self._reentrancy: - configDict.update({"reentrancy": self._reentrancy.as_dict()}) + configDict.update({'reentrancy': self._reentrancy.as_dict()}) if self._reminders_storage_partitions: - configDict.update({"remindersStoragePartitions": self._reminders_storage_partitions}) + configDict.update({'remindersStoragePartitions': self._reminders_storage_partitions}) return configDict @@ -173,23 +173,23 @@ def as_dict(self) -> Dict[str, Any]: entities: Set[str] = self._entities configDict: Dict[str, Any] = { - "actorIdleTimeout": self._actor_idle_timeout, - "actorScanInterval": self._actor_scan_interval, - "drainOngoingCallTimeout": self._drain_ongoing_call_timeout, - "drainRebalancedActors": self._drain_rebalanced_actors, + 'actorIdleTimeout': self._actor_idle_timeout, + 'actorScanInterval': self._actor_scan_interval, + 'drainOngoingCallTimeout': self._drain_ongoing_call_timeout, + 'drainRebalancedActors': self._drain_rebalanced_actors, } if self._reentrancy: - configDict.update({"reentrancy": self._reentrancy.as_dict()}) + configDict.update({'reentrancy': self._reentrancy.as_dict()}) if self._reminders_storage_partitions: - configDict.update({"remindersStoragePartitions": self._reminders_storage_partitions}) + configDict.update({'remindersStoragePartitions': self._reminders_storage_partitions}) - configDict["entitiesConfig"] = [] + configDict['entitiesConfig'] = [] for entityConfig in self._entitiesConfig: - configDict["entitiesConfig"].append(entityConfig.as_dict()) + configDict['entitiesConfig'].append(entityConfig.as_dict()) entities.add(entityConfig._actor_type) - configDict["entities"] = list(entities) + configDict['entities'] = list(entities) return configDict diff --git a/dapr/actor/runtime/context.py b/dapr/actor/runtime/context.py index 571cdeb3..ec66ba36 100644 --- a/dapr/actor/runtime/context.py +++ b/dapr/actor/runtime/context.py @@ -44,11 +44,11 @@ class ActorRuntimeContext: def __init__( self, - actor_type_info: "ActorTypeInformation", + actor_type_info: 'ActorTypeInformation', message_serializer: Serializer, state_serializer: Serializer, actor_client: DaprActorClientBase, - actor_factory: Optional[Callable[["ActorRuntimeContext", ActorId], "Actor"]] = None, + actor_factory: Optional[Callable[['ActorRuntimeContext', ActorId], 'Actor']] = None, ): """Creates :class:`ActorRuntimeContext` object. @@ -72,7 +72,7 @@ def __init__( self._provider: StateProvider = StateProvider(self._dapr_client, state_serializer) @property - def actor_type_info(self) -> "ActorTypeInformation": + def actor_type_info(self) -> 'ActorTypeInformation': """Return :class:`ActorTypeInformation` in this context.""" return self._actor_type_info @@ -96,7 +96,7 @@ def dapr_client(self) -> DaprActorClientBase: """Return dapr client.""" return self._dapr_client - def create_actor(self, actor_id: ActorId) -> "Actor": + def create_actor(self, actor_id: ActorId) -> 'Actor': """Create the object of :class:`Actor` for :class:`ActorId`. Args: @@ -107,7 +107,7 @@ def create_actor(self, actor_id: ActorId) -> "Actor": """ return self._actor_factory(self, actor_id) - def _default_actor_factory(self, ctx: "ActorRuntimeContext", actor_id: ActorId) -> "Actor": + def _default_actor_factory(self, ctx: 'ActorRuntimeContext', actor_id: ActorId) -> 'Actor': """Creates new Actor with actor_id. Args: diff --git a/dapr/actor/runtime/manager.py b/dapr/actor/runtime/manager.py index 8e9ea429..a6d1a792 100644 --- a/dapr/actor/runtime/manager.py +++ b/dapr/actor/runtime/manager.py @@ -27,8 +27,8 @@ from dapr.actor.runtime._reminder_data import ActorReminderData from dapr.actor.runtime.reentrancy_context import reentrancy_ctx -TIMER_METHOD_NAME = "fire_timer" -REMINDER_METHOD_NAME = "receive_reminder" +TIMER_METHOD_NAME = 'fire_timer' +REMINDER_METHOD_NAME = 'receive_reminder' class ActorManager: @@ -57,7 +57,7 @@ async def deactivate_actor(self, actor_id: ActorId): async with self._active_actors_lock: deactivated_actor = self._active_actors.pop(actor_id.id, None) if not deactivated_actor: - raise ValueError(f"{actor_id} is not activated") + raise ValueError(f'{actor_id} is not activated') await deactivated_actor._on_deactivate_internal() async def fire_reminder( @@ -65,7 +65,7 @@ async def fire_reminder( ) -> None: if not self._runtime_ctx.actor_type_info.is_remindable(): raise ValueError( - f"{self._runtime_ctx.actor_type_info.type_name} does not implment Remindable." + f'{self._runtime_ctx.actor_type_info.type_name} does not implment Remindable.' ) request_obj = self._message_serializer.deserialize(request_body, object) if isinstance(request_obj, dict): @@ -90,7 +90,7 @@ async def fire_timer(self, actor_id: ActorId, timer_name: str, request_body: byt timer = self._message_serializer.deserialize(request_body, object) async def invoke_timer(actor: Actor) -> Optional[bytes]: - await actor._fire_timer_internal(timer["callback"], timer["data"]) + await actor._fire_timer_internal(timer['callback'], timer['data']) return None await self._dispatch_internal(actor_id, self._timer_method_context, invoke_timer) @@ -129,7 +129,7 @@ async def _dispatch_internal( async with self._active_actors_lock: actor = self._active_actors.get(actor_id.id, None) if not actor: - raise ValueError(f"{actor_id} is not activated") + raise ValueError(f'{actor_id} is not activated') try: if reentrancy_ctx.get(None) is not None: diff --git a/dapr/actor/runtime/method_dispatcher.py b/dapr/actor/runtime/method_dispatcher.py index aeff21b4..8d9b6511 100644 --- a/dapr/actor/runtime/method_dispatcher.py +++ b/dapr/actor/runtime/method_dispatcher.py @@ -25,20 +25,20 @@ def __init__(self, type_info: ActorTypeInformation): async def dispatch(self, actor: Actor, name: str, *args, **kwargs) -> Any: self._check_name_exist(name) - return await getattr(actor, self._dispatch_mapping[name]["method_name"])(*args, **kwargs) + return await getattr(actor, self._dispatch_mapping[name]['method_name'])(*args, **kwargs) def get_arg_names(self, name: str) -> List[str]: self._check_name_exist(name) - return self._dispatch_mapping[name]["arg_names"] + return self._dispatch_mapping[name]['arg_names'] def get_arg_types(self, name: str) -> List[Any]: self._check_name_exist(name) - return self._dispatch_mapping[name]["arg_types"] + return self._dispatch_mapping[name]['arg_types'] def get_return_type(self, name: str) -> Dict[str, Any]: self._check_name_exist(name) - return self._dispatch_mapping[name]["return_types"] + return self._dispatch_mapping[name]['return_types'] def _check_name_exist(self, name: str): if name not in self._dispatch_mapping: - raise AttributeError(f"type object {self.__class__.__name__} has no method {name}") + raise AttributeError(f'type object {self.__class__.__name__} has no method {name}') diff --git a/dapr/actor/runtime/reentrancy_context.py b/dapr/actor/runtime/reentrancy_context.py index 59f19d02..0fc9927d 100644 --- a/dapr/actor/runtime/reentrancy_context.py +++ b/dapr/actor/runtime/reentrancy_context.py @@ -16,4 +16,4 @@ from typing import Optional from contextvars import ContextVar -reentrancy_ctx: ContextVar[Optional[str]] = ContextVar("reentrancy_ctx", default=None) +reentrancy_ctx: ContextVar[Optional[str]] = ContextVar('reentrancy_ctx', default=None) diff --git a/dapr/actor/runtime/runtime.py b/dapr/actor/runtime/runtime.py index c08d6788..7a2bf7eb 100644 --- a/dapr/actor/runtime/runtime.py +++ b/dapr/actor/runtime/runtime.py @@ -85,7 +85,7 @@ async def deactivate(cls, actor_type_name: str, actor_id: str) -> None: """ manager = await cls._get_actor_manager(actor_type_name) if not manager: - raise ValueError(f"{actor_type_name} is not registered.") + raise ValueError(f'{actor_type_name} is not registered.') await manager.deactivate_actor(ActorId(actor_id)) @classmethod @@ -116,7 +116,7 @@ async def dispatch( reentrancy_ctx.set(reentrancy_id) manager = await cls._get_actor_manager(actor_type_name) if not manager: - raise ValueError(f"{actor_type_name} is not registered.") + raise ValueError(f'{actor_type_name} is not registered.') return await manager.dispatch(ActorId(actor_id), actor_method_name, request_body) @classmethod @@ -137,7 +137,7 @@ async def fire_reminder( manager = await cls._get_actor_manager(actor_type_name) if not manager: - raise ValueError(f"{actor_type_name} is not registered.") + raise ValueError(f'{actor_type_name} is not registered.') await manager.fire_reminder(ActorId(actor_id), name, state) @classmethod @@ -155,7 +155,7 @@ async def fire_timer(cls, actor_type_name: str, actor_id: str, name: str, state: """ manager = await cls._get_actor_manager(actor_type_name) if not manager: - raise ValueError(f"{actor_type_name} is not registered.") + raise ValueError(f'{actor_type_name} is not registered.') await manager.fire_timer(ActorId(actor_id), name, state) @classmethod diff --git a/dapr/actor/runtime/state_change.py b/dapr/actor/runtime/state_change.py index de658085..42381eae 100644 --- a/dapr/actor/runtime/state_change.py +++ b/dapr/actor/runtime/state_change.py @@ -16,7 +16,7 @@ from enum import Enum from typing import TypeVar, Generic -T = TypeVar("T") +T = TypeVar('T') class StateChangeKind(Enum): diff --git a/dapr/actor/runtime/state_manager.py b/dapr/actor/runtime/state_manager.py index cf476800..52313f77 100644 --- a/dapr/actor/runtime/state_manager.py +++ b/dapr/actor/runtime/state_manager.py @@ -24,8 +24,8 @@ if TYPE_CHECKING: from dapr.actor.runtime.actor import Actor -T = TypeVar("T") -CONTEXT: ContextVar[Optional[Dict[str, Any]]] = ContextVar("state_tracker_context") +T = TypeVar('T') +CONTEXT: ContextVar[Optional[Dict[str, Any]]] = ContextVar('state_tracker_context') class StateMetadata(Generic[T]): @@ -51,17 +51,17 @@ def change_kind(self, new_kind: StateChangeKind) -> None: class ActorStateManager(Generic[T]): - def __init__(self, actor: "Actor"): + def __init__(self, actor: 'Actor'): self._actor = actor if not actor.runtime_ctx: - raise AttributeError("runtime context was not set") + raise AttributeError('runtime context was not set') self._type_name = actor.runtime_ctx.actor_type_info.type_name self._default_state_change_tracker: Dict[str, StateMetadata] = {} async def add_state(self, state_name: str, value: T) -> None: if not await self.try_add_state(state_name, value): - raise ValueError(f"The actor state name {state_name} already exist.") + raise ValueError(f'The actor state name {state_name} already exist.') async def try_add_state(self, state_name: str, value: T) -> bool: state_change_tracker = self._get_contextual_state_tracker() @@ -86,7 +86,7 @@ async def get_state(self, state_name: str) -> Optional[T]: if has_value: return val else: - raise KeyError(f"Actor State with name {state_name} was not found.") + raise KeyError(f'Actor State with name {state_name} was not found.') async def try_get_state(self, state_name: str) -> Tuple[bool, Optional[T]]: state_change_tracker = self._get_contextual_state_tracker() @@ -126,7 +126,7 @@ async def set_state(self, state_name: str, value: T) -> None: async def remove_state(self, state_name: str) -> None: if not await self.try_remove_state(state_name): - raise KeyError(f"Actor State with name {state_name} was not found.") + raise KeyError(f'Actor State with name {state_name} was not found.') async def try_remove_state(self, state_name: str) -> bool: state_change_tracker = self._get_contextual_state_tracker() @@ -174,7 +174,7 @@ async def add_or_update_state( self, state_name: str, value: T, update_value_factory: Callable[[str, T], T] ) -> T: if not callable(update_value_factory): - raise AttributeError("update_value_factory is not callable") + raise AttributeError('update_value_factory is not callable') state_change_tracker = self._get_contextual_state_tracker() if state_name in state_change_tracker: @@ -254,13 +254,13 @@ def is_state_marked_for_remove(self, state_name: str) -> bool: def _get_contextual_state_tracker(self) -> Dict[str, StateMetadata]: context = CONTEXT.get(None) if context is not None and reentrancy_ctx.get(None) is not None: - return context["tracker"] + return context['tracker'] else: return self._default_state_change_tracker def set_state_context(self, contextID: Optional[str]): if contextID is not None: - CONTEXT.set({"id": contextID, "tracker": {}}) + CONTEXT.set({'id': contextID, 'tracker': {}}) else: CONTEXT.set(None) return diff --git a/dapr/aio/clients/__init__.py b/dapr/aio/clients/__init__.py index 866119ff..ae77258e 100644 --- a/dapr/aio/clients/__init__.py +++ b/dapr/aio/clients/__init__.py @@ -24,11 +24,11 @@ from google.protobuf.message import Message as GrpcMessage __all__ = [ - "DaprClient", - "DaprActorClientBase", - "DaprActorHttpClient", - "DaprInternalError", - "ERROR_CODE_UNKNOWN", + 'DaprClient', + 'DaprActorClientBase', + 'DaprActorHttpClient', + 'DaprInternalError', + 'ERROR_CODE_UNKNOWN', ] from grpc.aio import ( # type: ignore @@ -80,17 +80,17 @@ def __init__( invocation_protocol = settings.DAPR_API_METHOD_INVOCATION_PROTOCOL.upper() - if invocation_protocol == "HTTP": + if invocation_protocol == 'HTTP': if http_timeout_seconds is None: http_timeout_seconds = settings.DAPR_HTTP_TIMEOUT_SECONDS self.invocation_client = DaprInvocationHttpClient( headers_callback=headers_callback, timeout=http_timeout_seconds ) - elif invocation_protocol == "GRPC": + elif invocation_protocol == 'GRPC': pass else: raise DaprInternalError( - f"Unknown value for DAPR_API_METHOD_INVOCATION_PROTOCOL: {invocation_protocol}" + f'Unknown value for DAPR_API_METHOD_INVOCATION_PROTOCOL: {invocation_protocol}' ) async def invoke_method( diff --git a/dapr/aio/clients/grpc/_asynchelpers.py b/dapr/aio/clients/grpc/_asynchelpers.py index 73e837f3..32bfe39f 100644 --- a/dapr/aio/clients/grpc/_asynchelpers.py +++ b/dapr/aio/clients/grpc/_asynchelpers.py @@ -21,7 +21,7 @@ class _ClientCallDetailsAsync( namedtuple( - "_ClientCallDetails", ["method", "timeout", "metadata", "credentials", "wait_for_ready"] + '_ClientCallDetails', ['method', 'timeout', 'metadata', 'credentials', 'wait_for_ready'] ), ClientCallDetails, ): diff --git a/dapr/aio/clients/grpc/client.py b/dapr/aio/clients/grpc/client.py index 41101985..2fbd781a 100644 --- a/dapr/aio/clients/grpc/client.py +++ b/dapr/aio/clients/grpc/client.py @@ -128,27 +128,27 @@ def __init__( max_grpc_messsage_length (int, optional): The maximum grpc send and receive message length in bytes. """ - useragent = f"dapr-sdk-python/{__version__}" + useragent = f'dapr-sdk-python/{__version__}' if not max_grpc_message_length: options = [ - ("grpc.primary_user_agent", useragent), + ('grpc.primary_user_agent', useragent), ] else: options = [ - ("grpc.max_send_message_length", max_grpc_message_length), - ("grpc.max_receive_message_length", max_grpc_message_length), - ("grpc.primary_user_agent", useragent), + ('grpc.max_send_message_length', max_grpc_message_length), + ('grpc.max_receive_message_length', max_grpc_message_length), + ('grpc.primary_user_agent', useragent), ] if not address: address = settings.DAPR_GRPC_ENDPOINT or ( - f"{settings.DAPR_RUNTIME_HOST}:" f"{settings.DAPR_GRPC_PORT}" + f'{settings.DAPR_RUNTIME_HOST}:' f'{settings.DAPR_GRPC_PORT}' ) try: self._uri = GrpcEndpoint(address) except ValueError as error: - raise DaprInternalError(f"{error}") from error + raise DaprInternalError(f'{error}') from error if self._uri.tls: self._channel = grpc.aio.secure_channel( @@ -160,7 +160,7 @@ def __init__( if settings.DAPR_API_TOKEN: api_token_interceptor = DaprClientInterceptorAsync( [ - ("dapr-api-token", settings.DAPR_API_TOKEN), + ('dapr-api-token', settings.DAPR_API_TOKEN), ] ) self._channel = grpc.aio.insecure_channel( # type: ignore @@ -178,7 +178,7 @@ def get_credentials(self): async def close(self): """Closes Dapr runtime gRPC channel.""" - if hasattr(self, "_channel") and self._channel: + if hasattr(self, '_channel') and self._channel: await self._channel.close() async def __aenter__(self) -> Self: # type: ignore @@ -200,7 +200,7 @@ async def invoke_method( self, app_id: str, method_name: str, - data: Union[bytes, str, GrpcMessage] = "", + data: Union[bytes, str, GrpcMessage] = '', content_type: Optional[str] = None, metadata: Optional[MetadataTuple] = None, http_verb: Optional[str] = None, @@ -281,14 +281,14 @@ async def invoke_method( :class:`InvokeMethodResponse` object returned from callee """ warn( - "invoke_method with protocol gRPC is deprecated. Use gRPC proxying instead.", + 'invoke_method with protocol gRPC is deprecated. Use gRPC proxying instead.', DeprecationWarning, stacklevel=2, ) if metadata is not None: warn( - "metadata argument is deprecated. Dapr already intercepts API token headers " - "and this is not needed.", + 'metadata argument is deprecated. Dapr already intercepts API token headers ' + 'and this is not needed.', DeprecationWarning, stacklevel=2, ) @@ -298,7 +298,7 @@ async def invoke_method( if http_verb: http_ext = self._get_http_extension(http_verb, http_querystring) - content_type = "" + content_type = '' if req_data.content_type: content_type = req_data.content_type req = api_v1.InvokeServiceRequest( @@ -322,7 +322,7 @@ async def invoke_binding( self, binding_name: str, operation: str, - data: Union[bytes, str] = "", + data: Union[bytes, str] = '', binding_metadata: Dict[str, str] = {}, metadata: Optional[MetadataTuple] = None, ) -> BindingResponse: @@ -358,8 +358,8 @@ async def invoke_binding( """ if metadata is not None: warn( - "metadata argument is deprecated. Dapr already intercepts API token " - "headers and this is not needed.", + 'metadata argument is deprecated. Dapr already intercepts API token ' + 'headers and this is not needed.', DeprecationWarning, stacklevel=2, ) @@ -419,23 +419,23 @@ async def publish_event( """ if metadata is not None: warn( - "metadata argument is deprecated. Dapr already intercepts API token headers " - "and this is not needed.", + 'metadata argument is deprecated. Dapr already intercepts API token headers ' + 'and this is not needed.', DeprecationWarning, stacklevel=2, ) if not isinstance(data, bytes) and not isinstance(data, str): - raise ValueError(f"invalid type for data {type(data)}") + raise ValueError(f'invalid type for data {type(data)}') req_data: bytes if isinstance(data, bytes): req_data = data else: if isinstance(data, str): - req_data = data.encode("utf-8") + req_data = data.encode('utf-8') - content_type = "" + content_type = '' if data_content_type: content_type = data_content_type req = api_v1.PublishEventRequest( @@ -483,14 +483,14 @@ async def get_state( """ if metadata is not None: warn( - "metadata argument is deprecated. Dapr already intercepts API token headers " - "and this is not needed.", + 'metadata argument is deprecated. Dapr already intercepts API token headers ' + 'and this is not needed.', DeprecationWarning, stacklevel=2, ) if not store_name or len(store_name) == 0 or len(store_name.strip()) == 0: - raise ValueError("State store name cannot be empty") + raise ValueError('State store name cannot be empty') req = api_v1.GetStateRequest(store_name=store_name, key=key, metadata=state_metadata) call = self._stub.GetState(req, metadata=metadata) response = await call @@ -531,14 +531,14 @@ async def get_bulk_state( """ if metadata is not None: warn( - "metadata argument is deprecated. Dapr already intercepts API token headers " - "and this is not needed.", + 'metadata argument is deprecated. Dapr already intercepts API token headers ' + 'and this is not needed.', DeprecationWarning, stacklevel=2, ) if not store_name or len(store_name) == 0 or len(store_name.strip()) == 0: - raise ValueError("State store name cannot be empty") + raise ValueError('State store name cannot be empty') req = api_v1.GetBulkStateRequest( store_name=store_name, keys=keys, parallelism=parallelism, metadata=states_metadata ) @@ -593,13 +593,13 @@ async def query_state( pagination token and results of the query """ warn( - "The State Store Query API is an Alpha version and is subject to change.", + 'The State Store Query API is an Alpha version and is subject to change.', UserWarning, stacklevel=2, ) if not store_name or len(store_name) == 0 or len(store_name.strip()) == 0: - raise ValueError("State store name cannot be empty") + raise ValueError('State store name cannot be empty') req = api_v1.QueryStateRequest(store_name=store_name, query=query, metadata=states_metadata) call = self._stub.QueryStateAlpha1(req) response = await call @@ -663,19 +663,19 @@ async def save_state( """ if metadata is not None: warn( - "metadata argument is deprecated. Dapr already intercepts API token headers " - "and this is not needed.", + 'metadata argument is deprecated. Dapr already intercepts API token headers ' + 'and this is not needed.', DeprecationWarning, stacklevel=2, ) if not isinstance(value, (bytes, str)): - raise ValueError(f"invalid type for data {type(value)}") + raise ValueError(f'invalid type for data {type(value)}') req_value = value if not store_name or len(store_name) == 0 or len(store_name.strip()) == 0: - raise ValueError("State store name cannot be empty") + raise ValueError('State store name cannot be empty') if options is None: state_options = None @@ -725,17 +725,17 @@ async def save_bulk_state( """ if metadata is not None: warn( - "metadata argument is deprecated. Dapr already intercepts API token headers " - "and this is not needed.", + 'metadata argument is deprecated. Dapr already intercepts API token headers ' + 'and this is not needed.', DeprecationWarning, stacklevel=2, ) if not states or len(states) == 0: - raise ValueError("States to be saved cannot be empty") + raise ValueError('States to be saved cannot be empty') if not store_name or len(store_name) == 0 or len(store_name.strip()) == 0: - raise ValueError("State store name cannot be empty") + raise ValueError('State store name cannot be empty') req_states = [ common_v1.StateItem( @@ -792,14 +792,14 @@ async def execute_state_transaction( """ if metadata is not None: warn( - "metadata argument is deprecated. Dapr already intercepts API token headers " - "and this is not needed.", + 'metadata argument is deprecated. Dapr already intercepts API token headers ' + 'and this is not needed.', DeprecationWarning, stacklevel=2, ) if not store_name or len(store_name) == 0 or len(store_name.strip()) == 0: - raise ValueError("State store name cannot be empty") + raise ValueError('State store name cannot be empty') req_ops = [ api_v1.TransactionalStateOperation( operationType=o.operation_type.value, @@ -858,14 +858,14 @@ async def delete_state( """ if metadata is not None: warn( - "metadata argument is deprecated. Dapr already intercepts API token headers " - "and this is not needed.", + 'metadata argument is deprecated. Dapr already intercepts API token headers ' + 'and this is not needed.', DeprecationWarning, stacklevel=2, ) if not store_name or len(store_name) == 0 or len(store_name.strip()) == 0: - raise ValueError("State store name cannot be empty") + raise ValueError('State store name cannot be empty') if options is None: state_options = None @@ -923,8 +923,8 @@ async def get_secret( """ if metadata is not None: warn( - "metadata argument is deprecated. Dapr already intercepts API token headers " - "and this is not needed.", + 'metadata argument is deprecated. Dapr already intercepts API token headers ' + 'and this is not needed.', DeprecationWarning, stacklevel=2, ) @@ -971,8 +971,8 @@ async def get_bulk_secret( """ if metadata is not None: warn( - "metadata argument is deprecated. Dapr already intercepts API token headers " - "and this is not needed.", + 'metadata argument is deprecated. Dapr already intercepts API token headers ' + 'and this is not needed.', DeprecationWarning, stacklevel=2, ) @@ -1016,7 +1016,7 @@ async def get_configuration( and value obtained from the config store """ if not store_name or len(store_name) == 0 or len(store_name.strip()) == 0: - raise ValueError("Config store name cannot be empty to get the configuration") + raise ValueError('Config store name cannot be empty to get the configuration') req = api_v1.GetConfigurationRequest( store_name=store_name, keys=keys, metadata=config_metadata @@ -1054,7 +1054,7 @@ async def subscribe_configuration( id (str): subscription id, which can be used to unsubscribe later """ if not store_name or len(store_name) == 0 or len(store_name.strip()) == 0: - raise ValueError("Config store name cannot be empty to get the configuration") + raise ValueError('Config store name cannot be empty to get the configuration') configWatcher = ConfigurationWatcher() id = configWatcher.watch_configuration( @@ -1113,7 +1113,7 @@ async def try_lock( """ # Warnings and input validation warn( - "The Distributed Lock API is an Alpha version and is subject to change.", + 'The Distributed Lock API is an Alpha version and is subject to change.', UserWarning, stacklevel=2, ) @@ -1121,7 +1121,7 @@ async def try_lock( store_name=store_name, resource_id=resource_id, lock_owner=lock_owner ) if not expiry_in_seconds or expiry_in_seconds < 1: - raise ValueError("expiry_in_seconds must be a positive number") + raise ValueError('expiry_in_seconds must be a positive number') # Actual tryLock invocation req = api_v1.TryLockRequest( store_name=store_name, @@ -1157,7 +1157,7 @@ async def unlock(self, store_name: str, resource_id: str, lock_owner: str) -> Un """ # Warnings and input validation warn( - "The Distributed Lock API is an Alpha version and is subject to change.", + 'The Distributed Lock API is an Alpha version and is subject to change.', UserWarning, stacklevel=2, ) @@ -1206,7 +1206,7 @@ async def start_workflow( """ # Warnings and input validation warn( - "The Workflow API is a Beta version and is subject to change.", + 'The Workflow API is a Beta version and is subject to change.', UserWarning, stacklevel=2, ) @@ -1223,11 +1223,11 @@ async def start_workflow( encoded_data = input else: try: - encoded_data = json.dumps(input).encode("utf-8") if input is not None else bytes([]) + encoded_data = json.dumps(input).encode('utf-8') if input is not None else bytes([]) except TypeError: - raise DaprInternalError("start_workflow: input data must be JSON serializable") + raise DaprInternalError('start_workflow: input data must be JSON serializable') except ValueError as e: - raise DaprInternalError(f"start_workflow JSON serialization error: {e}") + raise DaprInternalError(f'start_workflow JSON serialization error: {e}') # Actual start workflow invocation req = api_v1.StartWorkflowRequest( @@ -1258,7 +1258,7 @@ async def get_workflow(self, instance_id: str, workflow_component: str) -> GetWo """ # Warnings and input validation warn( - "The Workflow API is a Beta version and is subject to change.", + 'The Workflow API is a Beta version and is subject to change.', UserWarning, stacklevel=2, ) @@ -1300,7 +1300,7 @@ async def terminate_workflow(self, instance_id: str, workflow_component: str) -> """ # Warnings and input validation warn( - "The Workflow API is a Beta version and is subject to change.", + 'The Workflow API is a Beta version and is subject to change.', UserWarning, stacklevel=2, ) @@ -1345,7 +1345,7 @@ async def raise_workflow_event( """ # Warnings and input validation warn( - "The Workflow API is a Beta version and is subject to change.", + 'The Workflow API is a Beta version and is subject to change.', UserWarning, stacklevel=2, ) @@ -1358,18 +1358,18 @@ async def raise_workflow_event( if event_data is not None: try: encoded_data = ( - json.dumps(event_data).encode("utf-8") + json.dumps(event_data).encode('utf-8') if event_data is not None else bytes([]) ) except TypeError: raise DaprInternalError( - "raise_workflow_event:\ - event_data must be JSON serializable" + 'raise_workflow_event:\ + event_data must be JSON serializable' ) except ValueError as e: - raise DaprInternalError(f"raise_workflow_event JSON serialization error: {e}") - encoded_data = json.dumps(event_data).encode("utf-8") + raise DaprInternalError(f'raise_workflow_event JSON serialization error: {e}') + encoded_data = json.dumps(event_data).encode('utf-8') else: encoded_data = bytes([]) # Actual workflow raise event invocation @@ -1401,7 +1401,7 @@ async def pause_workflow(self, instance_id: str, workflow_component: str) -> Dap """ # Warnings and input validation warn( - "The Workflow API is a Beta version and is subject to change.", + 'The Workflow API is a Beta version and is subject to change.', UserWarning, stacklevel=2, ) @@ -1432,7 +1432,7 @@ async def resume_workflow(self, instance_id: str, workflow_component: str) -> Da """ # Warnings and input validation warn( - "The Workflow API is a Beta version and is subject to change.", + 'The Workflow API is a Beta version and is subject to change.', UserWarning, stacklevel=2, ) @@ -1463,7 +1463,7 @@ async def purge_workflow(self, instance_id: str, workflow_component: str) -> Dap """ # Warnings and input validation warn( - "The Workflow API is a Beta version and is subject to change.", + 'The Workflow API is a Beta version and is subject to change.', UserWarning, stacklevel=2, ) diff --git a/dapr/clients/__init__.py b/dapr/clients/__init__.py index 65878e2c..1cdfdebb 100644 --- a/dapr/clients/__init__.py +++ b/dapr/clients/__init__.py @@ -25,11 +25,11 @@ from google.protobuf.message import Message as GrpcMessage __all__ = [ - "DaprClient", - "DaprActorClientBase", - "DaprActorHttpClient", - "DaprInternalError", - "ERROR_CODE_UNKNOWN", + 'DaprClient', + 'DaprActorClientBase', + 'DaprActorHttpClient', + 'DaprInternalError', + 'ERROR_CODE_UNKNOWN', ] from grpc import ( # type: ignore @@ -81,24 +81,24 @@ def __init__( invocation_protocol = settings.DAPR_API_METHOD_INVOCATION_PROTOCOL.upper() - if invocation_protocol == "HTTP": + if invocation_protocol == 'HTTP': if http_timeout_seconds is None: http_timeout_seconds = settings.DAPR_HTTP_TIMEOUT_SECONDS self.invocation_client = DaprInvocationHttpClient( headers_callback=headers_callback, timeout=http_timeout_seconds, address=address ) - elif invocation_protocol == "GRPC": + elif invocation_protocol == 'GRPC': pass else: raise DaprInternalError( - f"Unknown value for DAPR_API_METHOD_INVOCATION_PROTOCOL: {invocation_protocol}" + f'Unknown value for DAPR_API_METHOD_INVOCATION_PROTOCOL: {invocation_protocol}' ) def invoke_method( self, app_id: str, method_name: str, - data: Union[bytes, str, GrpcMessage] = "", + data: Union[bytes, str, GrpcMessage] = '', content_type: Optional[str] = None, metadata: Optional[MetadataTuple] = None, http_verb: Optional[str] = None, @@ -171,7 +171,7 @@ async def invoke_method_async( """ if self.invocation_client: warn( - "Async invocation is deprecated. Please use `dapr.aio.clients.DaprClient`.", + 'Async invocation is deprecated. Please use `dapr.aio.clients.DaprClient`.', DeprecationWarning, stacklevel=2, ) @@ -187,5 +187,5 @@ async def invoke_method_async( ) else: raise NotImplementedError( - "Please use `dapr.aio.clients.DaprClient` for async invocation" + 'Please use `dapr.aio.clients.DaprClient` for async invocation' ) diff --git a/dapr/clients/base.py b/dapr/clients/base.py index 908063f0..dccb9624 100644 --- a/dapr/clients/base.py +++ b/dapr/clients/base.py @@ -17,8 +17,8 @@ from typing import Optional -DEFAULT_ENCODING = "utf-8" -DEFAULT_JSON_CONTENT_TYPE = f"application/json; charset={DEFAULT_ENCODING}" +DEFAULT_ENCODING = 'utf-8' +DEFAULT_JSON_CONTENT_TYPE = f'application/json; charset={DEFAULT_ENCODING}' class DaprActorClientBase(ABC): diff --git a/dapr/clients/exceptions.py b/dapr/clients/exceptions.py index fafa8484..47241c8a 100644 --- a/dapr/clients/exceptions.py +++ b/dapr/clients/exceptions.py @@ -15,8 +15,8 @@ from typing import Optional -ERROR_CODE_UNKNOWN = "UNKNOWN" -ERROR_CODE_DOES_NOT_EXIST = "ERR_DOES_NOT_EXIST" +ERROR_CODE_UNKNOWN = 'UNKNOWN' +ERROR_CODE_DOES_NOT_EXIST = 'ERR_DOES_NOT_EXIST' class DaprInternalError(Exception): @@ -34,7 +34,7 @@ def __init__( def as_dict(self): return { - "message": self._message, - "errorCode": self._error_code, - "raw_response_bytes": self._raw_response_bytes, + 'message': self._message, + 'errorCode': self._error_code, + 'raw_response_bytes': self._raw_response_bytes, } diff --git a/dapr/clients/grpc/_helpers.py b/dapr/clients/grpc/_helpers.py index f9299648..2f9f6006 100644 --- a/dapr/clients/grpc/_helpers.py +++ b/dapr/clients/grpc/_helpers.py @@ -52,9 +52,9 @@ def unpack(data: GrpcAny, message: GrpcMessage) -> None: matched with the response data type """ if not isinstance(message, GrpcMessage): - raise ValueError("output message is not protocol buffer message object") + raise ValueError('output message is not protocol buffer message object') if not data.Is(message.DESCRIPTOR): - raise ValueError(f"invalid type. serialized message type: {data.type_url}") + raise ValueError(f'invalid type. serialized message type: {data.type_url}') data.Unpack(message) @@ -63,9 +63,9 @@ def to_bytes(data: Union[str, bytes]) -> bytes: if isinstance(data, bytes): return data elif isinstance(data, str): - return data.encode("utf-8") + return data.encode('utf-8') else: - raise f"invalid data type {type(data)}" + raise f'invalid data type {type(data)}' def to_str(data: Union[str, bytes]) -> str: @@ -73,15 +73,15 @@ def to_str(data: Union[str, bytes]) -> str: if isinstance(data, str): return data elif isinstance(data, bytes): - return data.decode("utf-8") + return data.decode('utf-8') else: - raise f"invalid data type {type(data)}" + raise f'invalid data type {type(data)}' class _ClientCallDetails( namedtuple( - "_ClientCallDetails", - ["method", "timeout", "metadata", "credentials", "wait_for_ready", "compression"], + '_ClientCallDetails', + ['method', 'timeout', 'metadata', 'credentials', 'wait_for_ready', 'compression'], ), ClientCallDetails, ): @@ -171,23 +171,23 @@ def intercept_unary_unary(self, continuation, client_call_details, request): def validateNotNone(**kwargs: Optional[str]): for field_name, value in kwargs.items(): if value is None: - raise ValueError(f"{field_name} name cannot be None") + raise ValueError(f'{field_name} name cannot be None') def validateNotBlankString(**kwargs: Optional[str]): for field_name, value in kwargs.items(): if not value or not value.strip(): - raise ValueError(f"{field_name} name cannot be empty or blank") + raise ValueError(f'{field_name} name cannot be empty or blank') class WorkflowRuntimeStatus(Enum): - UNKNOWN = "Unknown" - RUNNING = "Running" - COMPLETED = "Completed" - FAILED = "Failed" - TERMINATED = "Terminated" - PENDING = "Pending" - SUSPENDED = "Suspended" + UNKNOWN = 'Unknown' + RUNNING = 'Running' + COMPLETED = 'Completed' + FAILED = 'Failed' + TERMINATED = 'Terminated' + PENDING = 'Pending' + SUSPENDED = 'Suspended' # Will return the enum entry if it is present, otherwise returns "unknown" diff --git a/dapr/clients/grpc/_request.py b/dapr/clients/grpc/_request.py index dd146ff2..4ddc0118 100644 --- a/dapr/clients/grpc/_request.py +++ b/dapr/clients/grpc/_request.py @@ -51,7 +51,7 @@ def metadata(self) -> MetadataDict: def metadata(self, val) -> None: """Sets metadata.""" if not isinstance(val, tuple): - raise ValueError("val is not tuple") + raise ValueError('val is not tuple') self._metadata = val def get_metadata(self, as_dict: bool = False) -> Union[MetadataDict, MetadataTuple]: @@ -84,7 +84,7 @@ class InvokeMethodRequest(DaprRequest): only for bytes array data. """ - HTTP_METHODS = ["GET", "HEAD", "POST", "PUT", "DELETE", "CONNECT", "OPTIONS", "TRACE"] + HTTP_METHODS = ['GET', 'HEAD', 'POST', 'PUT', 'DELETE', 'CONNECT', 'OPTIONS', 'TRACE'] def __init__( self, @@ -124,7 +124,7 @@ def http_verb(self) -> Optional[str]: def http_verb(self, val: Optional[str]) -> None: """Sets HTTP method to Dapr invocation request.""" if val not in self.HTTP_METHODS: - raise ValueError(f"{val} is the invalid HTTP verb.") + raise ValueError(f'{val} is the invalid HTTP verb.') self._http_verb = val @property @@ -134,7 +134,7 @@ def http_querystring(self) -> Dict[str, str]: def is_http(self) -> bool: """Return true if this request is http compatible.""" - return hasattr(self, "_http_verb") and not (not self._http_verb) + return hasattr(self, '_http_verb') and not (not self._http_verb) @property def proto(self) -> GrpcAny: @@ -143,7 +143,7 @@ def proto(self) -> GrpcAny: def is_proto(self) -> bool: """Returns true if data is protocol-buffer serialized.""" - return hasattr(self, "_data") and self._data.type_url != "" + return hasattr(self, '_data') and self._data.type_url != '' def pack(self, val: Union[GrpcAny, GrpcMessage]) -> None: """Serializes protocol buffer message. @@ -160,7 +160,7 @@ def pack(self, val: Union[GrpcAny, GrpcMessage]) -> None: self._data = GrpcAny() self._data.Pack(val) else: - raise ValueError("invalid data type") + raise ValueError('invalid data type') def unpack(self, message: GrpcMessage) -> None: """Deserializes the serialized protocol buffer message. @@ -179,7 +179,7 @@ def unpack(self, message: GrpcMessage) -> None: def data(self) -> bytes: """Gets request data as bytes.""" if self.is_proto(): - raise ValueError("data is protocol buffer message object.") + raise ValueError('data is protocol buffer message object.') return self._data.value @data.setter @@ -196,7 +196,7 @@ def set_data(self, val: Union[str, bytes, GrpcAny, GrpcMessage, None]) -> None: elif isinstance(val, (GrpcAny, GrpcMessage)): self.pack(val) else: - raise ValueError(f"invalid data type {type(val)}") + raise ValueError(f'invalid data type {type(val)}') def text(self) -> str: """Gets the request data as str.""" @@ -261,8 +261,8 @@ def binding_metadata(self): class TransactionOperationType(Enum): """Represents the type of operation for a Dapr Transaction State Api Call""" - upsert = "upsert" - delete = "delete" + upsert = 'upsert' + delete = 'delete' class TransactionalStateOperation: @@ -295,7 +295,7 @@ def __init__( ValueError: data is not bytes or str. """ if not isinstance(data, (bytes, str)): - raise ValueError(f"invalid type for data {type(data)}") + raise ValueError(f'invalid type for data {type(data)}') self._key = key self._data = data # type: ignore diff --git a/dapr/clients/grpc/_response.py b/dapr/clients/grpc/_response.py index 79b169ce..d96547e8 100644 --- a/dapr/clients/grpc/_response.py +++ b/dapr/clients/grpc/_response.py @@ -153,7 +153,7 @@ def proto(self) -> GrpcAny: def is_proto(self) -> bool: """Returns True if the response data is the serialized protocol buffer message.""" - return hasattr(self, "_data") and self._data.type_url != "" + return hasattr(self, '_data') and self._data.type_url != '' @property def data(self) -> bytes: @@ -164,7 +164,7 @@ def data(self) -> bytes: ValueError: the response data is the serialized protocol buffer message """ if self.is_proto(): - raise ValueError("data is protocol buffer message object.") + raise ValueError('data is protocol buffer message object.') return self._data.value @data.setter @@ -181,7 +181,7 @@ def set_data(self, val: Union[str, bytes, GrpcAny, GrpcMessage, None]) -> None: elif isinstance(val, (GrpcAny, GrpcMessage)): self.pack(val) else: - raise ValueError(f"invalid data type {type(val)}") + raise ValueError(f'invalid data type {type(val)}') def text(self) -> str: """Gets content as str if the response data content is not serialized @@ -226,7 +226,7 @@ def pack(self, val: Union[GrpcAny, GrpcMessage]) -> None: self._data = GrpcAny() self._data.Pack(val) else: - raise ValueError("invalid data type") + raise ValueError('invalid data type') @property def status_code(self) -> Optional[int]: @@ -250,7 +250,7 @@ def unpack(self, message: GrpcMessage) -> None: matched with the response data type """ - if self.content_type is not None and self.content_type.lower() == "application/x-protobuf": + if self.content_type is not None and self.content_type.lower() == 'application/x-protobuf': message.ParseFromString(self.data) return @@ -373,7 +373,7 @@ class StateResponse(DaprResponse): headers (Tuple, optional): the headers from Dapr gRPC response """ - def __init__(self, data: Union[bytes, str], etag: str = "", headers: MetadataTuple = ()): + def __init__(self, data: Union[bytes, str], etag: str = '', headers: MetadataTuple = ()): """Initializes StateResponse from :obj:`runtime_v1.GetStateResponse`. Args: @@ -423,7 +423,7 @@ class BulkStateItem: error (str): error when state was retrieved """ - def __init__(self, key: str, data: Union[bytes, str], etag: str = "", error: str = ""): + def __init__(self, key: str, data: Union[bytes, str], etag: str = '', error: str = ''): """Initializes BulkStateItem item from :obj:`runtime_v1.BulkStateItem`. Args: @@ -501,7 +501,7 @@ class QueryResponseItem: error (str): error when state was retrieved """ - def __init__(self, key: str, value: bytes, etag: str = "", error: str = ""): + def __init__(self, key: str, value: bytes, etag: str = '', error: str = ''): """Initializes QueryResponseItem item from :obj:`runtime_v1.QueryStateItem`. Args: @@ -558,7 +558,7 @@ class QueryResponse(DaprResponse): def __init__( self, results: Sequence[QueryResponseItem], - token: str = "", + token: str = '', metadata: Dict[str, str] = dict(), headers: MetadataTuple = (), ): @@ -664,7 +664,7 @@ def items(self) -> Mapping[Text, ConfigurationItem]: class ConfigurationWatcher: def __init__(self): self.event: threading.Event = threading.Event() - self.id: str = "" + self.id: str = '' def watch_configuration( self, @@ -684,7 +684,7 @@ def watch_configuration( self.store_name = store_name check = self.event.wait(timeout=5) if not check: - print(f"Unable to get configuration id for keys {self.keys}") + print(f'Unable to get configuration id for keys {self.keys}') return None return self.id @@ -705,7 +705,7 @@ def _read_subscribe_config( if len(response.items) > 0: handler(response.id, ConfigurationResponse(response.items)) except Exception: - print(f"{self.store_name} configuration watcher for keys " f"{self.keys} stopped.") + print(f'{self.store_name} configuration watcher for keys ' f'{self.keys} stopped.') pass @@ -738,7 +738,7 @@ def __init__( """ super(TopicEventResponse, self).__init__(headers) values = [e.name for e in TopicEventResponseStatus] - errormsg = f"`status` must be one of {values} or a TopicEventResponseStatus" + errormsg = f'`status` must be one of {values} or a TopicEventResponseStatus' if isinstance(status, str): try: @@ -871,7 +871,7 @@ async def __aexit__(self, *exc) -> None: ) # else: there is no point unlocking a lock we did not acquire. - async def __aenter__(self) -> "TryLockResponse": + async def __aenter__(self) -> 'TryLockResponse': """Returns self as the context manager object.""" return self diff --git a/dapr/clients/grpc/_state.py b/dapr/clients/grpc/_state.py index 0bd2fd72..3dc266b2 100644 --- a/dapr/clients/grpc/_state.py +++ b/dapr/clients/grpc/_state.py @@ -73,7 +73,7 @@ def __init__( ValueError: value is not bytes or str """ if not isinstance(value, (bytes, str)): - raise ValueError(f"invalid type for data {type(value)}") + raise ValueError(f'invalid type for data {type(value)}') self._key = key self._value = value diff --git a/dapr/clients/grpc/client.py b/dapr/clients/grpc/client.py index 4420a4e9..7179d975 100644 --- a/dapr/clients/grpc/client.py +++ b/dapr/clients/grpc/client.py @@ -127,27 +127,27 @@ def __init__( max_grpc_messsage_length (int, optional): The maximum grpc send and receive message length in bytes. """ - useragent = f"dapr-sdk-python/{__version__}" + useragent = f'dapr-sdk-python/{__version__}' if not max_grpc_message_length: options = [ - ("grpc.primary_user_agent", useragent), + ('grpc.primary_user_agent', useragent), ] else: options = [ - ("grpc.max_send_message_length", max_grpc_message_length), # type: ignore - ("grpc.max_receive_message_length", max_grpc_message_length), # type: ignore - ("grpc.primary_user_agent", useragent), + ('grpc.max_send_message_length', max_grpc_message_length), # type: ignore + ('grpc.max_receive_message_length', max_grpc_message_length), # type: ignore + ('grpc.primary_user_agent', useragent), ] if not address: address = settings.DAPR_GRPC_ENDPOINT or ( - f"{settings.DAPR_RUNTIME_HOST}:" f"{settings.DAPR_GRPC_PORT}" + f'{settings.DAPR_RUNTIME_HOST}:' f'{settings.DAPR_GRPC_PORT}' ) try: self._uri = GrpcEndpoint(address) except ValueError as error: - raise DaprInternalError(f"{error}") from error + raise DaprInternalError(f'{error}') from error if self._uri.tls: self._channel = grpc.secure_channel( # type: ignore @@ -164,7 +164,7 @@ def __init__( if settings.DAPR_API_TOKEN: api_token_interceptor = DaprClientInterceptor( [ - ("dapr-api-token", settings.DAPR_API_TOKEN), + ('dapr-api-token', settings.DAPR_API_TOKEN), ] ) self._channel = grpc.intercept_channel( # type: ignore @@ -184,7 +184,7 @@ def get_credentials(self): def close(self): """Closes Dapr runtime gRPC channel.""" - if hasattr(self, "_channel") and self._channel: + if hasattr(self, '_channel') and self._channel: self._channel.close() def __del__(self): @@ -209,7 +209,7 @@ def invoke_method( self, app_id: str, method_name: str, - data: Union[bytes, str, GrpcMessage] = "", + data: Union[bytes, str, GrpcMessage] = '', content_type: Optional[str] = None, metadata: Optional[MetadataTuple] = None, http_verb: Optional[str] = None, @@ -290,14 +290,14 @@ def invoke_method( :class:`InvokeMethodResponse` object returned from callee """ warn( - "invoke_method with protocol gRPC is deprecated. Use gRPC proxying instead.", + 'invoke_method with protocol gRPC is deprecated. Use gRPC proxying instead.', DeprecationWarning, stacklevel=2, ) if metadata is not None: warn( - "metadata argument is deprecated. Dapr already intercepts API token headers " - "and this is not needed.", + 'metadata argument is deprecated. Dapr already intercepts API token headers ' + 'and this is not needed.', DeprecationWarning, stacklevel=2, ) @@ -307,7 +307,7 @@ def invoke_method( if http_verb: http_ext = self._get_http_extension(http_verb, http_querystring) - content_type = "" + content_type = '' if req_data.content_type: content_type = req_data.content_type req = api_v1.InvokeServiceRequest( @@ -330,7 +330,7 @@ def invoke_binding( self, binding_name: str, operation: str, - data: Union[bytes, str] = "", + data: Union[bytes, str] = '', binding_metadata: Dict[str, str] = {}, metadata: Optional[MetadataTuple] = None, ) -> BindingResponse: @@ -366,8 +366,8 @@ def invoke_binding( """ if metadata is not None: warn( - "metadata argument is deprecated. Dapr already intercepts API token headers " - "and this is not needed.", + 'metadata argument is deprecated. Dapr already intercepts API token headers ' + 'and this is not needed.', DeprecationWarning, stacklevel=2, ) @@ -424,23 +424,23 @@ def publish_event( """ if metadata is not None: warn( - "metadata argument is deprecated. Dapr already intercepts API token headers " - "and this is not needed.", + 'metadata argument is deprecated. Dapr already intercepts API token headers ' + 'and this is not needed.', DeprecationWarning, stacklevel=2, ) if not isinstance(data, bytes) and not isinstance(data, str): - raise ValueError(f"invalid type for data {type(data)}") + raise ValueError(f'invalid type for data {type(data)}') req_data: bytes if isinstance(data, bytes): req_data = data else: if isinstance(data, str): - req_data = data.encode("utf-8") + req_data = data.encode('utf-8') - content_type = "" + content_type = '' if data_content_type: content_type = data_content_type req = api_v1.PublishEventRequest( @@ -487,14 +487,14 @@ def get_state( """ if metadata is not None: warn( - "metadata argument is deprecated. Dapr already intercepts API token headers " - "and this is not needed.", + 'metadata argument is deprecated. Dapr already intercepts API token headers ' + 'and this is not needed.', DeprecationWarning, stacklevel=2, ) if not store_name or len(store_name) == 0 or len(store_name.strip()) == 0: - raise ValueError("State store name cannot be empty") + raise ValueError('State store name cannot be empty') req = api_v1.GetStateRequest(store_name=store_name, key=key, metadata=state_metadata) response, call = self._stub.GetState.with_call(req, metadata=metadata) return StateResponse( @@ -534,14 +534,14 @@ def get_bulk_state( """ if metadata is not None: warn( - "metadata argument is deprecated. Dapr already intercepts API token headers " - "and this is not needed.", + 'metadata argument is deprecated. Dapr already intercepts API token headers ' + 'and this is not needed.', DeprecationWarning, stacklevel=2, ) if not store_name or len(store_name) == 0 or len(store_name.strip()) == 0: - raise ValueError("State store name cannot be empty") + raise ValueError('State store name cannot be empty') req = api_v1.GetBulkStateRequest( store_name=store_name, keys=keys, parallelism=parallelism, metadata=states_metadata ) @@ -595,13 +595,13 @@ def query_state( pagination token and results of the query """ warn( - "The State Store Query API is an Alpha version and is subject to change.", + 'The State Store Query API is an Alpha version and is subject to change.', UserWarning, stacklevel=2, ) if not store_name or len(store_name) == 0 or len(store_name.strip()) == 0: - raise ValueError("State store name cannot be empty") + raise ValueError('State store name cannot be empty') req = api_v1.QueryStateRequest(store_name=store_name, query=query, metadata=states_metadata) response, call = self._stub.QueryStateAlpha1.with_call(req) @@ -664,19 +664,19 @@ def save_state( """ if metadata is not None: warn( - "metadata argument is deprecated. Dapr already intercepts API token headers " - "and this is not needed.", + 'metadata argument is deprecated. Dapr already intercepts API token headers ' + 'and this is not needed.', DeprecationWarning, stacklevel=2, ) if not isinstance(value, (bytes, str)): - raise ValueError(f"invalid type for data {type(value)}") + raise ValueError(f'invalid type for data {type(value)}') req_value = value if not store_name or len(store_name) == 0 or len(store_name.strip()) == 0: - raise ValueError("State store name cannot be empty") + raise ValueError('State store name cannot be empty') if options is None: state_options = None @@ -725,17 +725,17 @@ def save_bulk_state( """ if metadata is not None: warn( - "metadata argument is deprecated. Dapr already intercepts API token headers " - "and this is not needed.", + 'metadata argument is deprecated. Dapr already intercepts API token headers ' + 'and this is not needed.', DeprecationWarning, stacklevel=2, ) if not states or len(states) == 0: - raise ValueError("States to be saved cannot be empty") + raise ValueError('States to be saved cannot be empty') if not store_name or len(store_name) == 0 or len(store_name.strip()) == 0: - raise ValueError("State store name cannot be empty") + raise ValueError('State store name cannot be empty') req_states = [ common_v1.StateItem( @@ -791,14 +791,14 @@ def execute_state_transaction( """ if metadata is not None: warn( - "metadata argument is deprecated. Dapr already intercepts API token headers " - "and this is not needed.", + 'metadata argument is deprecated. Dapr already intercepts API token headers ' + 'and this is not needed.', DeprecationWarning, stacklevel=2, ) if not store_name or len(store_name) == 0 or len(store_name.strip()) == 0: - raise ValueError("State store name cannot be empty") + raise ValueError('State store name cannot be empty') req_ops = [ api_v1.TransactionalStateOperation( operationType=o.operation_type.value, @@ -856,14 +856,14 @@ def delete_state( """ if metadata is not None: warn( - "metadata argument is deprecated. Dapr already intercepts API token " - "headers and this is not needed.", + 'metadata argument is deprecated. Dapr already intercepts API token ' + 'headers and this is not needed.', DeprecationWarning, stacklevel=2, ) if not store_name or len(store_name) == 0 or len(store_name.strip()) == 0: - raise ValueError("State store name cannot be empty") + raise ValueError('State store name cannot be empty') if options is None: state_options = None @@ -920,8 +920,8 @@ def get_secret( """ if metadata is not None: warn( - "metadata argument is deprecated. Dapr already intercepts API token " - "headers and this is not needed.", + 'metadata argument is deprecated. Dapr already intercepts API token ' + 'headers and this is not needed.', DeprecationWarning, stacklevel=2, ) @@ -967,8 +967,8 @@ def get_bulk_secret( """ if metadata is not None: warn( - "metadata argument is deprecated. Dapr already intercepts API token " - "headers and this is not needed.", + 'metadata argument is deprecated. Dapr already intercepts API token ' + 'headers and this is not needed.', DeprecationWarning, stacklevel=2, ) @@ -1011,7 +1011,7 @@ def get_configuration( and value obtained from the config store """ if not store_name or len(store_name) == 0 or len(store_name.strip()) == 0: - raise ValueError("Config store name cannot be empty to get the configuration") + raise ValueError('Config store name cannot be empty to get the configuration') req = api_v1.GetConfigurationRequest( store_name=store_name, keys=keys, metadata=config_metadata ) @@ -1048,7 +1048,7 @@ def subscribe_configuration( """ if not store_name or len(store_name) == 0 or len(store_name.strip()) == 0: - raise ValueError("Config store name cannot be empty to get the configuration") + raise ValueError('Config store name cannot be empty to get the configuration') configWatcher = ConfigurationWatcher() id = configWatcher.watch_configuration( @@ -1107,7 +1107,7 @@ def try_lock( """ # Warnings and input validation warn( - "The Distributed Lock API is an Alpha version and is subject to change.", + 'The Distributed Lock API is an Alpha version and is subject to change.', UserWarning, stacklevel=2, ) @@ -1115,7 +1115,7 @@ def try_lock( store_name=store_name, resource_id=resource_id, lock_owner=lock_owner ) if not expiry_in_seconds or expiry_in_seconds < 1: - raise ValueError("expiry_in_seconds must be a positive number") + raise ValueError('expiry_in_seconds must be a positive number') # Actual tryLock invocation req = api_v1.TryLockRequest( store_name=store_name, @@ -1150,7 +1150,7 @@ def unlock(self, store_name: str, resource_id: str, lock_owner: str) -> UnlockRe """ # Warnings and input validation warn( - "The Distributed Lock API is an Alpha version and is subject to change.", + 'The Distributed Lock API is an Alpha version and is subject to change.', UserWarning, stacklevel=2, ) @@ -1198,7 +1198,7 @@ def start_workflow( """ # Warnings and input validation warn( - "The Workflow API is a Beta version and is subject to change.", + 'The Workflow API is a Beta version and is subject to change.', UserWarning, stacklevel=2, ) @@ -1211,11 +1211,11 @@ def start_workflow( encoded_data = input else: try: - encoded_data = json.dumps(input).encode("utf-8") if input is not None else bytes([]) + encoded_data = json.dumps(input).encode('utf-8') if input is not None else bytes([]) except TypeError: - raise DaprInternalError("start_workflow: input data must be JSON serializable") + raise DaprInternalError('start_workflow: input data must be JSON serializable') except ValueError as e: - raise DaprInternalError(f"start_workflow JSON serialization error: {e}") + raise DaprInternalError(f'start_workflow JSON serialization error: {e}') # Actual start workflow invocation req = api_v1.StartWorkflowRequest( @@ -1246,7 +1246,7 @@ def get_workflow(self, instance_id: str, workflow_component: str) -> GetWorkflow """ # Warnings and input validation warn( - "The Workflow API is a Beta version and is subject to change.", + 'The Workflow API is a Beta version and is subject to change.', UserWarning, stacklevel=2, ) @@ -1288,7 +1288,7 @@ def terminate_workflow(self, instance_id: str, workflow_component: str) -> DaprR """ # Warnings and input validation warn( - "The Workflow API is a Beta version and is subject to change.", + 'The Workflow API is a Beta version and is subject to change.', UserWarning, stacklevel=2, ) @@ -1332,7 +1332,7 @@ def raise_workflow_event( """ # Warnings and input validation warn( - "The Workflow API is a Beta version and is subject to change.", + 'The Workflow API is a Beta version and is subject to change.', UserWarning, stacklevel=2, ) @@ -1346,18 +1346,18 @@ def raise_workflow_event( if event_data is not None: try: encoded_data = ( - json.dumps(event_data).encode("utf-8") + json.dumps(event_data).encode('utf-8') if event_data is not None else bytes([]) ) except TypeError: raise DaprInternalError( - "raise_workflow_event:\ - event_data must be JSON serializable" + 'raise_workflow_event:\ + event_data must be JSON serializable' ) except ValueError as e: - raise DaprInternalError(f"raise_workflow_event JSON serialization error: {e}") - encoded_data = json.dumps(event_data).encode("utf-8") + raise DaprInternalError(f'raise_workflow_event JSON serialization error: {e}') + encoded_data = json.dumps(event_data).encode('utf-8') else: encoded_data = bytes([]) @@ -1390,7 +1390,7 @@ def pause_workflow(self, instance_id: str, workflow_component: str) -> DaprRespo """ # Warnings and input validation warn( - "The Workflow API is a Beta version and is subject to change.", + 'The Workflow API is a Beta version and is subject to change.', UserWarning, stacklevel=2, ) @@ -1421,7 +1421,7 @@ def resume_workflow(self, instance_id: str, workflow_component: str) -> DaprResp """ # Warnings and input validation warn( - "The Workflow API is a Beta version and is subject to change.", + 'The Workflow API is a Beta version and is subject to change.', UserWarning, stacklevel=2, ) @@ -1452,7 +1452,7 @@ def purge_workflow(self, instance_id: str, workflow_component: str) -> DaprRespo """ # Warnings and input validation warn( - "The Workflow API is a Beta version and is subject to change.", + 'The Workflow API is a Beta version and is subject to change.', UserWarning, stacklevel=2, ) diff --git a/dapr/clients/http/client.py b/dapr/clients/http/client.py index 601c060a..4ac5271e 100644 --- a/dapr/clients/http/client.py +++ b/dapr/clients/http/client.py @@ -25,10 +25,10 @@ from dapr.clients.exceptions import DaprInternalError, ERROR_CODE_DOES_NOT_EXIST, ERROR_CODE_UNKNOWN from dapr.version import __version__ -CONTENT_TYPE_HEADER = "content-type" -DAPR_API_TOKEN_HEADER = "dapr-api-token" -USER_AGENT_HEADER = "User-Agent" -DAPR_USER_AGENT = f"dapr-sdk-python/{__version__}" +CONTENT_TYPE_HEADER = 'content-type' +DAPR_API_TOKEN_HEADER = 'dapr-api-token' +USER_AGENT_HEADER = 'User-Agent' +DAPR_USER_AGENT = f'dapr-sdk-python/{__version__}' class DaprHttpClient: @@ -36,7 +36,7 @@ class DaprHttpClient: def __init__( self, - message_serializer: "Serializer", + message_serializer: 'Serializer', timeout: Optional[int] = 60, headers_callback: Optional[Callable[[], Dict[str, str]]] = None, address: Optional[str] = None, @@ -55,11 +55,11 @@ def __init__( def get_api_url(self) -> str: if self._address: - return "{}/{}".format(self._address, settings.DAPR_API_VERSION) + return '{}/{}'.format(self._address, settings.DAPR_API_VERSION) if settings.DAPR_HTTP_ENDPOINT: - return "{}/{}".format(settings.DAPR_HTTP_ENDPOINT, settings.DAPR_API_VERSION) + return '{}/{}'.format(settings.DAPR_HTTP_ENDPOINT, settings.DAPR_API_VERSION) else: - return "http://{}:{}/{}".format( + return 'http://{}:{}/{}'.format( settings.DAPR_RUNTIME_HOST, settings.DAPR_HTTP_PORT, settings.DAPR_API_VERSION ) @@ -109,21 +109,21 @@ async def convert_to_error(self, response: aiohttp.ClientResponse) -> DaprIntern try: error_body = await response.read() if (error_body is None or len(error_body) == 0) and response.status == 404: - return DaprInternalError("Not Found", ERROR_CODE_DOES_NOT_EXIST) + return DaprInternalError('Not Found', ERROR_CODE_DOES_NOT_EXIST) error_info = self._serializer.deserialize(error_body) except Exception: return DaprInternalError( - f"Unknown Dapr Error. HTTP status code: {response.status}", + f'Unknown Dapr Error. HTTP status code: {response.status}', raw_response_bytes=error_body, ) if error_info and isinstance(error_info, dict): - message = error_info.get("message") - error_code = error_info.get("errorCode") or ERROR_CODE_UNKNOWN + message = error_info.get('message') + error_code = error_info.get('errorCode') or ERROR_CODE_UNKNOWN return DaprInternalError(message, error_code, raw_response_bytes=error_body) return DaprInternalError( - f"Unknown Dapr Error. HTTP status code: {response.status}", + f'Unknown Dapr Error. HTTP status code: {response.status}', raw_response_bytes=error_body, ) diff --git a/dapr/clients/http/dapr_actor_http_client.py b/dapr/clients/http/dapr_actor_http_client.py index ab38a16c..0a462587 100644 --- a/dapr/clients/http/dapr_actor_http_client.py +++ b/dapr/clients/http/dapr_actor_http_client.py @@ -21,7 +21,7 @@ from dapr.clients.http.client import DaprHttpClient from dapr.clients.base import DaprActorClientBase -DAPR_REENTRANCY_ID_HEADER = "Dapr-Reentrancy-Id" +DAPR_REENTRANCY_ID_HEADER = 'Dapr-Reentrancy-Id' class DaprActorHttpClient(DaprActorClientBase): @@ -29,7 +29,7 @@ class DaprActorHttpClient(DaprActorClientBase): def __init__( self, - message_serializer: "Serializer", + message_serializer: 'Serializer', timeout: int = 60, headers_callback: Optional[Callable[[], Dict[str, str]]] = None, ): @@ -56,7 +56,7 @@ async def invoke_method( Returns: bytes: the response from the actor. """ - url = f"{self._get_base_url(actor_type, actor_id)}/method/{method}" + url = f'{self._get_base_url(actor_type, actor_id)}/method/{method}' # import to avoid circular dependency from dapr.actor.runtime.reentrancy_context import reentrancy_ctx @@ -66,7 +66,7 @@ async def invoke_method( {DAPR_REENTRANCY_ID_HEADER: reentrancy_id} if reentrancy_id else {} ) - body, _ = await self._client.send_bytes(method="POST", url=url, data=data, headers=headers) + body, _ = await self._client.send_bytes(method='POST', url=url, data=data, headers=headers) return body @@ -78,8 +78,8 @@ async def save_state_transactionally(self, actor_type: str, actor_id: str, data: actor_id (str): Id of Actor type. data (bytes): Json-serialized the transactional state operations. """ - url = f"{self._get_base_url(actor_type, actor_id)}/state" - await self._client.send_bytes(method="PUT", url=url, data=data) + url = f'{self._get_base_url(actor_type, actor_id)}/state' + await self._client.send_bytes(method='PUT', url=url, data=data) async def get_state(self, actor_type: str, actor_id: str, name: str) -> bytes: """Get state value for name key. @@ -92,8 +92,8 @@ async def get_state(self, actor_type: str, actor_id: str, name: str) -> bytes: Returns: bytes: the value of the state. """ - url = f"{self._get_base_url(actor_type, actor_id)}/state/{name}" - body, _ = await self._client.send_bytes(method="GET", url=url, data=None) + url = f'{self._get_base_url(actor_type, actor_id)}/state/{name}' + body, _ = await self._client.send_bytes(method='GET', url=url, data=None) return body async def register_reminder( @@ -107,8 +107,8 @@ async def register_reminder( name (str): The name of reminder data (bytes): Reminder request json body. """ - url = f"{self._get_base_url(actor_type, actor_id)}/reminders/{name}" - await self._client.send_bytes(method="PUT", url=url, data=data) + url = f'{self._get_base_url(actor_type, actor_id)}/reminders/{name}' + await self._client.send_bytes(method='PUT', url=url, data=data) async def unregister_reminder(self, actor_type: str, actor_id: str, name: str) -> None: """Unregister actor reminder. @@ -118,8 +118,8 @@ async def unregister_reminder(self, actor_type: str, actor_id: str, name: str) - actor_id (str): Id of Actor type. name (str): the name of reminder. """ - url = f"{self._get_base_url(actor_type, actor_id)}/reminders/{name}" - await self._client.send_bytes(method="DELETE", url=url, data=None) + url = f'{self._get_base_url(actor_type, actor_id)}/reminders/{name}' + await self._client.send_bytes(method='DELETE', url=url, data=None) async def register_timer(self, actor_type: str, actor_id: str, name: str, data: bytes) -> None: """Register actor timer. @@ -130,8 +130,8 @@ async def register_timer(self, actor_type: str, actor_id: str, name: str, data: name (str): The name of reminder. data (bytes): Timer request json body. """ - url = f"{self._get_base_url(actor_type, actor_id)}/timers/{name}" - await self._client.send_bytes(method="PUT", url=url, data=data) + url = f'{self._get_base_url(actor_type, actor_id)}/timers/{name}' + await self._client.send_bytes(method='PUT', url=url, data=data) async def unregister_timer(self, actor_type: str, actor_id: str, name: str) -> None: """Unregister actor timer. @@ -141,8 +141,8 @@ async def unregister_timer(self, actor_type: str, actor_id: str, name: str) -> N actor_id (str): Id of Actor type. name (str): The name of timer """ - url = f"{self._get_base_url(actor_type, actor_id)}/timers/{name}" - await self._client.send_bytes(method="DELETE", url=url, data=None) + url = f'{self._get_base_url(actor_type, actor_id)}/timers/{name}' + await self._client.send_bytes(method='DELETE', url=url, data=None) def _get_base_url(self, actor_type: str, actor_id: str) -> str: - return "{}/actors/{}/{}".format(self._client.get_api_url(), actor_type, actor_id) + return '{}/actors/{}/{}'.format(self._client.get_api_url(), actor_type, actor_id) diff --git a/dapr/clients/http/dapr_invocation_http_client.py b/dapr/clients/http/dapr_invocation_http_client.py index 1cfae62d..462f0d1a 100644 --- a/dapr/clients/http/dapr_invocation_http_client.py +++ b/dapr/clients/http/dapr_invocation_http_client.py @@ -24,8 +24,8 @@ from dapr.serializers import DefaultJSONSerializer from dapr.version import __version__ -USER_AGENT_HEADER = "User-Agent" -DAPR_USER_AGENT = f"dapr-python-sdk/{__version__}" +USER_AGENT_HEADER = 'User-Agent' +DAPR_USER_AGENT = f'dapr-python-sdk/{__version__}' class DaprInvocationHttpClient: @@ -72,7 +72,7 @@ async def invoke_method_async( InvokeMethodResponse: the response from the method invocation. """ - verb = "GET" + verb = 'GET' if http_verb is not None: verb = http_verb @@ -91,12 +91,12 @@ async def invoke_method_async( headers[USER_AGENT_HEADER] = DAPR_USER_AGENT - url = f"{self._client.get_api_url()}/invoke/{app_id}/method/{method_name}" + url = f'{self._client.get_api_url()}/invoke/{app_id}/method/{method_name}' if isinstance(data, GrpcMessage): body = data.SerializeToString() elif isinstance(data, str): - body = data.encode("utf-8") + body = data.encode('utf-8') else: body = data diff --git a/dapr/conf/global_settings.py b/dapr/conf/global_settings.py index 0f134237..5fe5647f 100644 --- a/dapr/conf/global_settings.py +++ b/dapr/conf/global_settings.py @@ -21,11 +21,11 @@ DAPR_API_TOKEN = None DAPR_HTTP_ENDPOINT = None DAPR_GRPC_ENDPOINT = None -DAPR_RUNTIME_HOST = "127.0.0.1" +DAPR_RUNTIME_HOST = '127.0.0.1' DAPR_HTTP_PORT = 3500 DAPR_GRPC_PORT = 50001 -DAPR_API_VERSION = "v1.0" +DAPR_API_VERSION = 'v1.0' -DAPR_API_METHOD_INVOCATION_PROTOCOL = "http" +DAPR_API_METHOD_INVOCATION_PROTOCOL = 'http' DAPR_HTTP_TIMEOUT_SECONDS = 60 diff --git a/dapr/conf/helpers.py b/dapr/conf/helpers.py index ff17839d..8740bde8 100644 --- a/dapr/conf/helpers.py +++ b/dapr/conf/helpers.py @@ -3,11 +3,11 @@ class URIParseConfig: - DEFAULT_SCHEME = "dns" - DEFAULT_HOSTNAME = "localhost" + DEFAULT_SCHEME = 'dns' + DEFAULT_HOSTNAME = 'localhost' DEFAULT_PORT = 443 - DEFAULT_AUTHORITY = "" - ACCEPTED_SCHEMES = ["dns", "unix", "unix-abstract", "vsock", "http", "https", "grpc", "grpcs"] + DEFAULT_AUTHORITY = '' + ACCEPTED_SCHEMES = ['dns', 'unix', 'unix-abstract', 'vsock', 'http', 'https', 'grpc', 'grpcs'] class GrpcEndpoint: @@ -38,9 +38,9 @@ def _set_scheme(self): self._scheme = URIParseConfig.DEFAULT_SCHEME return - if self._parsed_url.scheme in ["http", "https"]: + if self._parsed_url.scheme in ['http', 'https']: self._scheme = URIParseConfig.DEFAULT_SCHEME - warn("http and https schemes are deprecated, use grpc or grpcs instead") + warn('http and https schemes are deprecated, use grpc or grpcs instead') return if self._parsed_url.scheme not in URIParseConfig.ACCEPTED_SCHEMES: @@ -57,9 +57,9 @@ def _set_hostname(self): self._hostname = URIParseConfig.DEFAULT_HOSTNAME return - if self._parsed_url.hostname.count(":") == 7: + if self._parsed_url.hostname.count(':') == 7: # IPv6 address - self._hostname = f"[{self._parsed_url.hostname}]" + self._hostname = f'[{self._parsed_url.hostname}]' return self._hostname = self._parsed_url.hostname @@ -69,7 +69,7 @@ def hostname(self) -> str: return self._hostname def _set_port(self): - if self._parsed_url.scheme in ["unix", "unix-abstract"]: + if self._parsed_url.scheme in ['unix', 'unix-abstract']: self._port = 0 return @@ -82,7 +82,7 @@ def _set_port(self): @property def port(self) -> str: if self._port == 0: - return "" + return '' return str(self._port) @@ -91,27 +91,27 @@ def port_as_int(self) -> int: return self._port def _set_endpoint(self): - port = "" if not self._port else f":{self.port}" + port = '' if not self._port else f':{self.port}' - if self._scheme == "unix": - separator = "://" if self._url.startswith("unix://") else ":" - self._endpoint = f"{self._scheme}{separator}{self._hostname}" + if self._scheme == 'unix': + separator = '://' if self._url.startswith('unix://') else ':' + self._endpoint = f'{self._scheme}{separator}{self._hostname}' return - if self._scheme == "vsock": - self._endpoint = f"{self._scheme}:{self._hostname}:{self.port}" + if self._scheme == 'vsock': + self._endpoint = f'{self._scheme}:{self._hostname}:{self.port}' return - if self._scheme == "unix-abstract": - self._endpoint = f"{self._scheme}:{self._hostname}{port}" + if self._scheme == 'unix-abstract': + self._endpoint = f'{self._scheme}:{self._hostname}{port}' return - if self._scheme == "dns": - authority = f"//{self._authority}/" if self._authority else "" - self._endpoint = f"{self._scheme}:{authority}{self._hostname}{port}" + if self._scheme == 'dns': + authority = f'//{self._authority}/' if self._authority else '' + self._endpoint = f'{self._scheme}:{authority}{self._hostname}{port}' return - self._endpoint = f"{self._scheme}:{self._hostname}{port}" + self._endpoint = f'{self._scheme}:{self._hostname}{port}' @property def endpoint(self) -> str: @@ -119,25 +119,25 @@ def endpoint(self) -> str: # Prepares the uri string in a specific format for parsing by the urlparse function def _preprocess_uri(self, url: str) -> str: - url_list = url.split(":") - if len(url_list) == 3 and "://" not in url: + url_list = url.split(':') + if len(url_list) == 3 and '://' not in url: # A URI like dns:mydomain:5000 or vsock:mycid:5000 was used - url = url.replace(":", "://", 1) + url = url.replace(':', '://', 1) elif ( len(url_list) >= 2 - and "://" not in url + and '://' not in url and url_list[0] in URIParseConfig.ACCEPTED_SCHEMES ): # A URI like dns:mydomain or dns:[2001:db8:1f70::999:de8:7648:6e8]:mydomain was used # Possibly a URI like dns:[2001:db8:1f70::999:de8:7648:6e8]:mydomain was used - url = url.replace(":", "://", 1) + url = url.replace(':', '://', 1) else: - url_list = url.split("://") + url_list = url.split('://') if len(url_list) == 1: # If a scheme was not explicitly specified in the URL # we need to add a default scheme, # because of how urlparse works - url = f"{URIParseConfig.DEFAULT_SCHEME}://{url}" + url = f'{URIParseConfig.DEFAULT_SCHEME}://{url}' else: # If a scheme was explicitly specified in the URL # we need to make sure it is a valid scheme @@ -147,20 +147,20 @@ def _preprocess_uri(self, url: str) -> str: # We should do a special check if the scheme is dns, and it uses # an authority in the format of dns:[//authority/]host[:port] - if scheme.lower() == "dns": + if scheme.lower() == 'dns': # A URI like dns://authority/mydomain was used - url_list = url.split("/") + url_list = url.split('/') if len(url_list) < 4: raise ValueError(f"invalid dns authority '{url_list[2]}' in URL '{url}'") self._authority = url_list[2] - url = f"dns://{url_list[3]}" + url = f'dns://{url_list[3]}' return url def _set_tls(self): query_dict = parse_qs(self._parsed_url.query) - tls_str = query_dict.get("tls", [""])[0] - tls = tls_str.lower() == "true" - if self._parsed_url.scheme == "https": + tls_str = query_dict.get('tls', [''])[0] + tls = tls_str.lower() == 'true' + if self._parsed_url.scheme == 'https': tls = True self._tls = tls @@ -172,18 +172,18 @@ def tls(self) -> bool: def _validate_path_and_query(self) -> None: if self._parsed_url.path: raise ValueError( - f"paths are not supported for gRPC endpoints:" f" '{self._parsed_url.path}'" + f'paths are not supported for gRPC endpoints:' f" '{self._parsed_url.path}'" ) if self._parsed_url.query: query_dict = parse_qs(self._parsed_url.query) - if "tls" in query_dict and self._parsed_url.scheme in ["http", "https"]: + if 'tls' in query_dict and self._parsed_url.scheme in ['http', 'https']: raise ValueError( - f"the tls query parameter is not supported for http(s) endpoints: " + f'the tls query parameter is not supported for http(s) endpoints: ' f"'{self._parsed_url.query}'" ) - query_dict.pop("tls", None) + query_dict.pop('tls', None) if query_dict: raise ValueError( - f"query parameters are not supported for gRPC endpoints:" + f'query parameters are not supported for gRPC endpoints:' f" '{self._parsed_url.query}'" ) diff --git a/dapr/serializers/__init__.py b/dapr/serializers/__init__.py index 46a53bc1..ac72d1c2 100644 --- a/dapr/serializers/__init__.py +++ b/dapr/serializers/__init__.py @@ -16,4 +16,4 @@ from dapr.serializers.base import Serializer from dapr.serializers.json import DefaultJSONSerializer -__all__ = ["Serializer", "DefaultJSONSerializer"] +__all__ = ['Serializer', 'DefaultJSONSerializer'] diff --git a/dapr/serializers/json.py b/dapr/serializers/json.py index 22f1921b..4e966518 100644 --- a/dapr/serializers/json.py +++ b/dapr/serializers/json.py @@ -44,15 +44,15 @@ def serialize( if callable(custom_hook): dict_obj = custom_hook(obj) elif isinstance(obj, bytes): - dict_obj = base64.b64encode(obj).decode("utf-8") + dict_obj = base64.b64encode(obj).decode('utf-8') elif isinstance(obj, ActorRuntimeConfig): dict_obj = obj.as_dict() serialized = json.dumps( - dict_obj, cls=DaprJSONEncoder, separators=(",", ":"), ensure_ascii=self.ensure_ascii + dict_obj, cls=DaprJSONEncoder, separators=(',', ':'), ensure_ascii=self.ensure_ascii ) - return serialized.encode("utf-8") + return serialized.encode('utf-8') def deserialize( self, @@ -61,7 +61,7 @@ def deserialize( custom_hook: Optional[Callable[[bytes], object]] = None, ) -> Any: if not isinstance(data, (str, bytes)): - raise ValueError("data must be str or bytes types") + raise ValueError('data must be str or bytes types') obj = json.loads(data, cls=DaprJSONDecoder) @@ -75,22 +75,22 @@ def default(self, obj): r = obj.isoformat() if obj.microsecond: r = r[:23] + r[26:] - if r.endswith("+00:00"): - r = r[:-6] + "Z" + if r.endswith('+00:00'): + r = r[:-6] + 'Z' return r elif isinstance(obj, datetime.date): return obj.isoformat() elif isinstance(obj, datetime.timedelta): return convert_to_dapr_duration(obj) elif isinstance(obj, bytes): - return base64.b64encode(obj).decode("utf-8") + return base64.b64encode(obj).decode('utf-8') else: return json.JSONEncoder.default(self, obj) class DaprJSONDecoder(json.JSONDecoder): # TODO: improve regex - datetime_regex = re.compile(r"(\d{4}[-/]\d{2}[-/]\d{2})") + datetime_regex = re.compile(r'(\d{4}[-/]\d{2}[-/]\d{2})') def __init__(self, *args, **kwargs): json.JSONDecoder.__init__(self, *args, **kwargs) diff --git a/dapr/serializers/util.py b/dapr/serializers/util.py index ed101f4c..522ad03d 100644 --- a/dapr/serializers/util.py +++ b/dapr/serializers/util.py @@ -18,7 +18,7 @@ # Regex to parse Go Duration datatype, e.g. 4h15m50s123ms345μs DAPR_DURATION_PARSER = re.compile( - r"((?P\d+)h)?((?P\d+)m)?((?P\d+)s)?((?P\d+)ms)?((?P\d+)(μs|us))?$" + r'((?P\d+)h)?((?P\d+)m)?((?P\d+)s)?((?P\d+)ms)?((?P\d+)(μs|us))?$' ) # noqa: E501 @@ -39,15 +39,15 @@ def convert_from_dapr_duration(duration: str) -> timedelta: days = 0.0 hours = 0.0 - if matched.group("hours") is not None: - days, hours = divmod(float(matched.group("hours")), 24) - mins = 0.0 if not matched.group("mins") else float(matched.group("mins")) - seconds = 0.0 if not matched.group("seconds") else float(matched.group("seconds")) + if matched.group('hours') is not None: + days, hours = divmod(float(matched.group('hours')), 24) + mins = 0.0 if not matched.group('mins') else float(matched.group('mins')) + seconds = 0.0 if not matched.group('seconds') else float(matched.group('seconds')) milliseconds = ( - 0.0 if not matched.group("milliseconds") else float(matched.group("milliseconds")) + 0.0 if not matched.group('milliseconds') else float(matched.group('milliseconds')) ) microseconds = ( - 0.0 if not matched.group("microseconds") else float(matched.group("microseconds")) + 0.0 if not matched.group('microseconds') else float(matched.group('microseconds')) ) return timedelta( @@ -74,4 +74,4 @@ def convert_to_dapr_duration(td: timedelta) -> str: milliseconds, microseconds = divmod(td.microseconds, 1000.0) hours, mins = divmod(total_minutes, 60.0) - return f"{hours:.0f}h{mins:.0f}m{seconds:.0f}s{milliseconds:.0f}ms{microseconds:.0f}μs" + return f'{hours:.0f}h{mins:.0f}m{seconds:.0f}s{milliseconds:.0f}ms{microseconds:.0f}μs' diff --git a/dapr/version/__init__.py b/dapr/version/__init__.py index 5d04bf3f..3eb16081 100644 --- a/dapr/version/__init__.py +++ b/dapr/version/__init__.py @@ -1,3 +1,3 @@ from dapr.version.version import __version__ -__all__ = ["__version__"] +__all__ = ['__version__'] diff --git a/dapr/version/version.py b/dapr/version/version.py index 3bd3df76..2fea8188 100644 --- a/dapr/version/version.py +++ b/dapr/version/version.py @@ -13,4 +13,4 @@ limitations under the License. """ -__version__ = "1.11.0rc1.dev" +__version__ = '1.11.0rc1.dev' diff --git a/docs/conf.py b/docs/conf.py index 221beb96..50b67a0a 100644 --- a/docs/conf.py +++ b/docs/conf.py @@ -13,14 +13,14 @@ import os import sys -sys.path.insert(0, os.path.abspath("../dapr")) +sys.path.insert(0, os.path.abspath('../dapr')) # -- Project information ----------------------------------------------------- -project = "dapr-python-sdk" -copyright = "2020, dapr" -author = "dapr" +project = 'dapr-python-sdk' +copyright = '2020, dapr' +author = 'dapr' # -- General configuration --------------------------------------------------- @@ -29,10 +29,10 @@ # extensions coming with Sphinx (named 'sphinx.ext.*') or your custom # ones. extensions = [ - "sphinx.ext.autodoc", - "sphinx.ext.intersphinx", - "sphinx.ext.ifconfig", - "sphinx.ext.napoleon", + 'sphinx.ext.autodoc', + 'sphinx.ext.intersphinx', + 'sphinx.ext.ifconfig', + 'sphinx.ext.napoleon', ] # Napoleon settings @@ -47,14 +47,14 @@ napoleon_use_ivar = False napoleon_use_param = True napoleon_use_rtype = True -autodoc_mock_imports = ["dapr"] +autodoc_mock_imports = ['dapr'] # Add any paths that contain templates here, relative to this directory. -templates_path = ["_templates"] +templates_path = ['_templates'] # List of patterns, relative to source directory, that match files and # directories to ignore when looking for source files. # This pattern also affects html_static_path and html_extra_path. -exclude_patterns = ["_build", "Thumbs.db", ".DS_Store"] +exclude_patterns = ['_build', 'Thumbs.db', '.DS_Store'] # -- Options for HTML output ------------------------------------------------- @@ -62,9 +62,9 @@ # The theme to use for HTML and HTML Help pages. See the documentation for # a list of builtin themes. # -html_theme = "classic" +html_theme = 'classic' # Add any paths that contain custom static files (such as style sheets) here, # relative to this directory. They are copied after the builtin static files, # so a file named "default.css" will overwrite the builtin "default.css". -html_static_path = ["_static"] +html_static_path = ['_static'] diff --git a/examples/configuration/configuration.py b/examples/configuration/configuration.py index 653ef590..c6e613fa 100644 --- a/examples/configuration/configuration.py +++ b/examples/configuration/configuration.py @@ -13,18 +13,18 @@ def handler(id: str, resp: ConfigurationResponse): for key in resp.items: print( - f"Subscribe key={key} value={resp.items[key].value} " - f"version={resp.items[key].version} " - f"metadata={resp.items[key].metadata}", + f'Subscribe key={key} value={resp.items[key].value} ' + f'version={resp.items[key].version} ' + f'metadata={resp.items[key].metadata}', flush=True, ) async def executeConfiguration(): with DaprClient() as d: - storeName = "configurationstore" + storeName = 'configurationstore' - keys = ["orderId1", "orderId2"] + keys = ['orderId1', 'orderId2'] # Wait for sidecar to be up within 20 seconds. d.wait(20) @@ -35,10 +35,10 @@ async def executeConfiguration(): configuration = d.get_configuration(store_name=storeName, keys=keys, config_metadata={}) for key in configuration.items: print( - f"Got key={key} " - f"value={configuration.items[key].value} " - f"version={configuration.items[key].version} " - f"metadata={configuration.items[key].metadata}", + f'Got key={key} ' + f'value={configuration.items[key].value} ' + f'version={configuration.items[key].version} ' + f'metadata={configuration.items[key].metadata}', flush=True, ) @@ -46,12 +46,12 @@ async def executeConfiguration(): id = d.subscribe_configuration( store_name=storeName, keys=keys, handler=handler, config_metadata={} ) - print("Subscription ID is", id, flush=True) + print('Subscription ID is', id, flush=True) sleep(10) # Unsubscribe from configuration isSuccess = d.unsubscribe_configuration(store_name=storeName, id=id) - print(f"Unsubscribed successfully? {isSuccess}", flush=True) + print(f'Unsubscribed successfully? {isSuccess}', flush=True) asyncio.run(executeConfiguration()) diff --git a/examples/demo_actor/demo_actor/demo_actor.py b/examples/demo_actor/demo_actor/demo_actor.py index e0efd07f..0d65d57d 100644 --- a/examples/demo_actor/demo_actor/demo_actor.py +++ b/examples/demo_actor/demo_actor/demo_actor.py @@ -33,28 +33,28 @@ def __init__(self, ctx, actor_id): async def _on_activate(self) -> None: """An callback which will be called whenever actor is activated.""" - print(f"Activate {self.__class__.__name__} actor!", flush=True) + print(f'Activate {self.__class__.__name__} actor!', flush=True) async def _on_deactivate(self) -> None: """An callback which will be called whenever actor is deactivated.""" - print(f"Deactivate {self.__class__.__name__} actor!", flush=True) + print(f'Deactivate {self.__class__.__name__} actor!', flush=True) async def get_my_data(self) -> object: """An actor method which gets mydata state value.""" - has_value, val = await self._state_manager.try_get_state("mydata") - print(f"has_value: {has_value}", flush=True) + has_value, val = await self._state_manager.try_get_state('mydata') + print(f'has_value: {has_value}', flush=True) return val async def set_my_data(self, data) -> None: """An actor method which set mydata state value.""" - print(f"set_my_data: {data}", flush=True) - data["ts"] = datetime.datetime.now(datetime.timezone.utc) - await self._state_manager.set_state("mydata", data) + print(f'set_my_data: {data}', flush=True) + data['ts'] = datetime.datetime.now(datetime.timezone.utc) + await self._state_manager.set_state('mydata', data) await self._state_manager.save_state() async def clear_my_data(self) -> None: - print("clear_my_data", flush=True) - await self._state_manager.remove_state("mydata") + print('clear_my_data', flush=True) + await self._state_manager.remove_state('mydata') await self._state_manager.save_state() async def set_reminder(self, enabled) -> None: @@ -63,12 +63,12 @@ async def set_reminder(self, enabled) -> None: Args: enabled (bool): the flag to enable and disable demo_reminder. """ - print(f"set reminder to {enabled}", flush=True) + print(f'set reminder to {enabled}', flush=True) if enabled: # Register 'demo_reminder' reminder and call receive_reminder method await self.register_reminder( - "demo_reminder", # reminder name - b"reminder_state", # user_state (bytes) + 'demo_reminder', # reminder name + b'reminder_state', # user_state (bytes) # The amount of time to delay before firing the reminder datetime.timedelta(seconds=5), datetime.timedelta(seconds=5), # The time interval between firing of reminders @@ -76,8 +76,8 @@ async def set_reminder(self, enabled) -> None: ) else: # Unregister 'demo_reminder' - await self.unregister_reminder("demo_reminder") - print("set reminder is done", flush=True) + await self.unregister_reminder('demo_reminder') + print('set reminder is done', flush=True) async def set_timer(self, enabled) -> None: """Enables and disables a timer. @@ -85,13 +85,13 @@ async def set_timer(self, enabled) -> None: Args: enabled (bool): the flag to enable and disable demo_timer. """ - print(f"set_timer to {enabled}", flush=True) + print(f'set_timer to {enabled}', flush=True) if enabled: # Register 'demo_timer' timer and call timer_callback method await self.register_timer( - "demo_timer", # timer name + 'demo_timer', # timer name self.timer_callback, # Callback method - "timer_state", # Parameter to pass to the callback method + 'timer_state', # Parameter to pass to the callback method # Amount of time to delay before the callback is invoked datetime.timedelta(seconds=5), datetime.timedelta(seconds=5), # Time interval between invocations @@ -99,8 +99,8 @@ async def set_timer(self, enabled) -> None: ) else: # Unregister 'demo_timer' - await self.unregister_timer("demo_timer") - print("set_timer is done", flush=True) + await self.unregister_timer('demo_timer') + print('set_timer is done', flush=True) async def timer_callback(self, state) -> None: """A callback which will be called whenever timer is triggered. @@ -108,7 +108,7 @@ async def timer_callback(self, state) -> None: Args: state (object): an object which is defined when timer is registered. """ - print(f"time_callback is called - {state}", flush=True) + print(f'time_callback is called - {state}', flush=True) async def receive_reminder( self, @@ -119,7 +119,7 @@ async def receive_reminder( ttl: Optional[datetime.timedelta] = None, ) -> None: """A callback which will be called when reminder is triggered.""" - print(f"receive_reminder is called - {name} reminder - {str(state)}", flush=True) + print(f'receive_reminder is called - {name} reminder - {str(state)}', flush=True) async def get_reentrancy_status(self) -> bool: """For Testing Only: An actor method which gets reentrancy status.""" diff --git a/examples/demo_actor/demo_actor/demo_actor_client.py b/examples/demo_actor/demo_actor/demo_actor_client.py index 3faba7c3..67912aeb 100644 --- a/examples/demo_actor/demo_actor/demo_actor_client.py +++ b/examples/demo_actor/demo_actor/demo_actor_client.py @@ -18,31 +18,31 @@ async def main(): # Create proxy client - proxy = ActorProxy.create("DemoActor", ActorId("1"), DemoActorInterface) + proxy = ActorProxy.create('DemoActor', ActorId('1'), DemoActorInterface) # ----------------------------------------------- # Actor invocation demo # ----------------------------------------------- # non-remoting actor invocation - print("call actor method via proxy.invoke_method()", flush=True) - rtn_bytes = await proxy.invoke_method("GetMyData") + print('call actor method via proxy.invoke_method()', flush=True) + rtn_bytes = await proxy.invoke_method('GetMyData') print(rtn_bytes, flush=True) # RPC style using python duck-typing - print("call actor method using rpc style", flush=True) + print('call actor method using rpc style', flush=True) rtn_obj = await proxy.GetMyData() print(rtn_obj, flush=True) # Check actor is reentrant - is_reentrant = await proxy.invoke_method("GetReentrancyStatus") - print(f"Actor reentrancy enabled: {str(is_reentrant)}", flush=True) + is_reentrant = await proxy.invoke_method('GetReentrancyStatus') + print(f'Actor reentrancy enabled: {str(is_reentrant)}', flush=True) # ----------------------------------------------- # Actor state management demo # ----------------------------------------------- # Invoke SetMyData actor method to save the state - print("call SetMyData actor method to save the state", flush=True) - await proxy.SetMyData({"data": "new_data"}) + print('call SetMyData actor method to save the state', flush=True) + await proxy.SetMyData({'data': 'new_data'}) # Invoke GetMyData actor method to get the state - print("call GetMyData actor method to get the state", flush=True) + print('call GetMyData actor method to get the state', flush=True) rtn_obj = await proxy.GetMyData() print(rtn_obj, flush=True) @@ -50,28 +50,28 @@ async def main(): # Actor reminder demo # ----------------------------------------------- # Invoke SetReminder actor method to set actor reminder - print("Register reminder", flush=True) + print('Register reminder', flush=True) await proxy.SetReminder(True) # ----------------------------------------------- # Actor timer demo # ----------------------------------------------- # Invoke SetTimer to set actor timer - print("Register timer", flush=True) + print('Register timer', flush=True) await proxy.SetTimer(True) # Wait for 30 seconds to see reminder and timer is triggered - print("waiting for 30 seconds", flush=True) + print('waiting for 30 seconds', flush=True) await asyncio.sleep(30) # Stop reminder and timer - print("stop reminder", flush=True) + print('stop reminder', flush=True) await proxy.SetReminder(False) - print("stop timer", flush=True) + print('stop timer', flush=True) await proxy.SetTimer(False) # Clear actor state - print("clear actor state", flush=True) + print('clear actor state', flush=True) await proxy.ClearMyData() diff --git a/examples/demo_actor/demo_actor/demo_actor_flask.py b/examples/demo_actor/demo_actor/demo_actor_flask.py index 00703485..5715d23d 100644 --- a/examples/demo_actor/demo_actor/demo_actor_flask.py +++ b/examples/demo_actor/demo_actor/demo_actor_flask.py @@ -18,7 +18,7 @@ from dapr.actor.runtime.runtime import ActorRuntime from demo_actor import DemoActor -app = Flask(f"{DemoActor.__name__}Service") +app = Flask(f'{DemoActor.__name__}Service') # This is an optional advanced configuration which enables reentrancy only for the # specified actor type. By default reentrancy is not enabled for all actor types. @@ -35,10 +35,10 @@ # This route is optional. -@app.route("/") +@app.route('/') def index(): - return jsonify({"status": "ok"}), 200 + return jsonify({'status': 'ok'}), 200 -if __name__ == "__main__": +if __name__ == '__main__': app.run(port=settings.HTTP_APP_PORT) diff --git a/examples/demo_actor/demo_actor/demo_actor_interface.py b/examples/demo_actor/demo_actor/demo_actor_interface.py index c7dcc2b0..be43c2ed 100644 --- a/examples/demo_actor/demo_actor/demo_actor_interface.py +++ b/examples/demo_actor/demo_actor/demo_actor_interface.py @@ -17,31 +17,31 @@ class DemoActorInterface(ActorInterface): @abstractmethod - @actormethod(name="GetMyData") + @actormethod(name='GetMyData') async def get_my_data(self) -> object: ... @abstractmethod - @actormethod(name="SetMyData") + @actormethod(name='SetMyData') async def set_my_data(self, data: object) -> None: ... @abstractmethod - @actormethod(name="ClearMyData") + @actormethod(name='ClearMyData') async def clear_my_data(self) -> None: ... @abstractmethod - @actormethod(name="SetReminder") + @actormethod(name='SetReminder') async def set_reminder(self, enabled: bool) -> None: ... @abstractmethod - @actormethod(name="SetTimer") + @actormethod(name='SetTimer') async def set_timer(self, enabled: bool) -> None: ... @abstractmethod - @actormethod(name="GetReentrancyStatus") + @actormethod(name='GetReentrancyStatus') async def get_reentrancy_status(self) -> bool: ... diff --git a/examples/demo_actor/demo_actor/demo_actor_service.py b/examples/demo_actor/demo_actor/demo_actor_service.py index 2fdecf6d..c53d06e2 100644 --- a/examples/demo_actor/demo_actor/demo_actor_service.py +++ b/examples/demo_actor/demo_actor/demo_actor_service.py @@ -17,7 +17,7 @@ from demo_actor import DemoActor -app = FastAPI(title=f"{DemoActor.__name__}Service") +app = FastAPI(title=f'{DemoActor.__name__}Service') # This is an optional advanced configuration which enables reentrancy only for the # specified actor type. By default reentrancy is not enabled for all actor types. @@ -31,7 +31,7 @@ actor = DaprActor(app) -@app.on_event("startup") +@app.on_event('startup') async def startup_event(): # Register DemoActor await actor.register_actor(DemoActor) diff --git a/examples/demo_workflow/app.py b/examples/demo_workflow/app.py index ef0d6a55..d2869c86 100644 --- a/examples/demo_workflow/app.py +++ b/examples/demo_workflow/app.py @@ -27,17 +27,17 @@ counter = 0 retry_count = 0 child_orchestrator_count = 0 -child_orchestrator_string = "" +child_orchestrator_string = '' child_act_retry_count = 0 -instance_id = "exampleInstanceID" -workflow_component = "dapr" -workflow_name = "hello_world_wf" -input_data = "Hi Counter!" +instance_id = 'exampleInstanceID' +workflow_component = 'dapr' +workflow_name = 'hello_world_wf' +input_data = 'Hi Counter!' workflow_options = dict() -workflow_options["task_queue"] = "testQueue" -event_name = "event1" -event_data = "eventData" -non_existent_id_error = "no such instance exists" +workflow_options['task_queue'] = 'testQueue' +event_name = 'event1' +event_data = 'eventData' +non_existent_id_error = 'no such instance exists' retry_policy = RetryPolicy( first_retry_interval=timedelta(seconds=1), @@ -49,12 +49,12 @@ def hello_world_wf(ctx: DaprWorkflowContext, wf_input): - print(f"{wf_input}") + print(f'{wf_input}') yield ctx.call_activity(hello_act, input=1) yield ctx.call_activity(hello_act, input=10) yield ctx.call_activity(hello_retryable_act, retry_policy=retry_policy) yield ctx.call_child_workflow(workflow=child_wf, retry_policy=retry_policy) - yield ctx.wait_for_external_event("event1") + yield ctx.wait_for_external_event('event1') yield ctx.call_activity(hello_act, input=100) yield ctx.call_activity(hello_act, input=1000) @@ -62,16 +62,16 @@ def hello_world_wf(ctx: DaprWorkflowContext, wf_input): def hello_act(ctx: WorkflowActivityContext, wf_input): global counter counter += wf_input - print(f"New counter value is: {counter}!", flush=True) + print(f'New counter value is: {counter}!', flush=True) def hello_retryable_act(ctx: WorkflowActivityContext): global retry_count if (retry_count % 2) == 0: - print(f"Retry count value is: {retry_count}!", flush=True) + print(f'Retry count value is: {retry_count}!', flush=True) retry_count += 1 - raise ValueError("Retryable Error") - print(f"Retry count value is: {retry_count}! This print statement verifies retry", flush=True) + raise ValueError('Retryable Error') + print(f'Retry count value is: {retry_count}! This print statement verifies retry', flush=True) retry_count += 1 @@ -79,23 +79,23 @@ def child_wf(ctx: DaprWorkflowContext): global child_orchestrator_string, child_orchestrator_count if not ctx.is_replaying: child_orchestrator_count += 1 - print(f"Appending {child_orchestrator_count} to child_orchestrator_string!", flush=True) + print(f'Appending {child_orchestrator_count} to child_orchestrator_string!', flush=True) child_orchestrator_string += str(child_orchestrator_count) yield ctx.call_activity( act_for_child_wf, input=child_orchestrator_count, retry_policy=retry_policy ) if child_orchestrator_count < 3: - raise ValueError("Retryable Error") + raise ValueError('Retryable Error') def act_for_child_wf(ctx: WorkflowActivityContext, inp): global child_orchestrator_string, child_act_retry_count inp_char = chr(96 + inp) - print(f"Appending {inp_char} to child_orchestrator_string!", flush=True) + print(f'Appending {inp_char} to child_orchestrator_string!', flush=True) child_orchestrator_string += inp_char if child_act_retry_count % 2 == 0: child_act_retry_count += 1 - raise ValueError("Retryable Error") + raise ValueError('Retryable Error') child_act_retry_count += 1 @@ -111,7 +111,7 @@ def main(): sleep(2) - print("==========Start Counter Increase as per Input:==========") + print('==========Start Counter Increase as per Input:==========') start_resp = d.start_workflow( instance_id=instance_id, workflow_component=workflow_component, @@ -119,27 +119,27 @@ def main(): input=input_data, workflow_options=workflow_options, ) - print(f"start_resp {start_resp.instance_id}") + print(f'start_resp {start_resp.instance_id}') # Sleep for a while to let the workflow run sleep(12) assert counter == 11 assert retry_count == 2 - assert child_orchestrator_string == "1aa2bb3cc" + assert child_orchestrator_string == '1aa2bb3cc' # Pause Test d.pause_workflow(instance_id=instance_id, workflow_component=workflow_component) get_response = d.get_workflow( instance_id=instance_id, workflow_component=workflow_component ) - print(f"Get response from {workflow_name} after pause call: {get_response.runtime_status}") + print(f'Get response from {workflow_name} after pause call: {get_response.runtime_status}') # Resume Test d.resume_workflow(instance_id=instance_id, workflow_component=workflow_component) get_response = d.get_workflow( instance_id=instance_id, workflow_component=workflow_component ) - print(f"Get response from {workflow_name} after resume call: {get_response.runtime_status}") + print(f'Get response from {workflow_name} after resume call: {get_response.runtime_status}') sleep(1) # Raise event @@ -157,7 +157,7 @@ def main(): d.get_workflow(instance_id=instance_id, workflow_component=workflow_component) except DaprInternalError as err: if non_existent_id_error in err._message: - print("Instance Successfully Purged") + print('Instance Successfully Purged') # Kick off another workflow for termination purposes # This will also test using the same instance ID on a new workflow after @@ -169,7 +169,7 @@ def main(): input=input_data, workflow_options=workflow_options, ) - print(f"start_resp {start_resp.instance_id}") + print(f'start_resp {start_resp.instance_id}') # Terminate Test d.terminate_workflow(instance_id=instance_id, workflow_component=workflow_component) @@ -178,8 +178,8 @@ def main(): instance_id=instance_id, workflow_component=workflow_component ) print( - f"Get response from {workflow_name} " - f"after terminate call: {get_response.runtime_status}" + f'Get response from {workflow_name} ' + f'after terminate call: {get_response.runtime_status}' ) # Purge Test @@ -188,10 +188,10 @@ def main(): d.get_workflow(instance_id=instance_id, workflow_component=workflow_component) except DaprInternalError as err: if non_existent_id_error in err._message: - print("Instance Successfully Purged") + print('Instance Successfully Purged') workflow_runtime.shutdown() -if __name__ == "__main__": +if __name__ == '__main__': main() diff --git a/examples/distributed_lock/lock.py b/examples/distributed_lock/lock.py index 932d41e1..d18d955f 100644 --- a/examples/distributed_lock/lock.py +++ b/examples/distributed_lock/lock.py @@ -17,28 +17,28 @@ def main(): # Lock parameters - store_name = "lockstore" # as defined in components/lockstore.yaml - resource_id = "example-lock-resource" - client_id = "example-client-id" + store_name = 'lockstore' # as defined in components/lockstore.yaml + resource_id = 'example-lock-resource' + client_id = 'example-client-id' expiry_in_seconds = 60 with DaprClient() as dapr: - print("Will try to acquire a lock from lock store named [%s]" % store_name) - print("The lock is for a resource named [%s]" % resource_id) - print("The client identifier is [%s]" % client_id) - print("The lock will will expire in %s seconds." % expiry_in_seconds) + print('Will try to acquire a lock from lock store named [%s]' % store_name) + print('The lock is for a resource named [%s]' % resource_id) + print('The client identifier is [%s]' % client_id) + print('The lock will will expire in %s seconds.' % expiry_in_seconds) with dapr.try_lock(store_name, resource_id, client_id, expiry_in_seconds) as lock_result: - assert lock_result.success, "Failed to acquire the lock. Aborting." - print("Lock acquired successfully!!!") + assert lock_result.success, 'Failed to acquire the lock. Aborting.' + print('Lock acquired successfully!!!') # At this point the lock was released - by magic of the `with` clause ;) unlock_result = dapr.unlock(store_name, resource_id, client_id) - print("We already released the lock so unlocking will not work.") - print("We tried to unlock it anyway and got back [%s]" % unlock_result.status) + print('We already released the lock so unlocking will not work.') + print('We tried to unlock it anyway and got back [%s]' % unlock_result.status) -if __name__ == "__main__": +if __name__ == '__main__': # Suppress "The Distributed Lock API is an Alpha" warnings - warnings.simplefilter("ignore") + warnings.simplefilter('ignore') main() diff --git a/examples/grpc_proxying/helloworld_service_pb2.py b/examples/grpc_proxying/helloworld_service_pb2.py index 7a8d1675..e0504965 100644 --- a/examples/grpc_proxying/helloworld_service_pb2.py +++ b/examples/grpc_proxying/helloworld_service_pb2.py @@ -17,31 +17,31 @@ ) -_HELLOREQUEST = DESCRIPTOR.message_types_by_name["HelloRequest"] -_HELLOREPLY = DESCRIPTOR.message_types_by_name["HelloReply"] +_HELLOREQUEST = DESCRIPTOR.message_types_by_name['HelloRequest'] +_HELLOREPLY = DESCRIPTOR.message_types_by_name['HelloReply'] HelloRequest = _reflection.GeneratedProtocolMessageType( - "HelloRequest", + 'HelloRequest', (_message.Message,), { - "DESCRIPTOR": _HELLOREQUEST, - "__module__": "helloworld_service_pb2", + 'DESCRIPTOR': _HELLOREQUEST, + '__module__': 'helloworld_service_pb2', # @@protoc_insertion_point(class_scope:HelloRequest) }, ) _sym_db.RegisterMessage(HelloRequest) HelloReply = _reflection.GeneratedProtocolMessageType( - "HelloReply", + 'HelloReply', (_message.Message,), { - "DESCRIPTOR": _HELLOREPLY, - "__module__": "helloworld_service_pb2", + 'DESCRIPTOR': _HELLOREPLY, + '__module__': 'helloworld_service_pb2', # @@protoc_insertion_point(class_scope:HelloReply) }, ) _sym_db.RegisterMessage(HelloReply) -_HELLOWORLDSERVICE = DESCRIPTOR.services_by_name["HelloWorldService"] +_HELLOWORLDSERVICE = DESCRIPTOR.services_by_name['HelloWorldService'] if _descriptor._USE_C_DESCRIPTORS == False: DESCRIPTOR._options = None _HELLOREQUEST._serialized_start = 28 diff --git a/examples/grpc_proxying/helloworld_service_pb2_grpc.py b/examples/grpc_proxying/helloworld_service_pb2_grpc.py index 841124b3..b5403111 100644 --- a/examples/grpc_proxying/helloworld_service_pb2_grpc.py +++ b/examples/grpc_proxying/helloworld_service_pb2_grpc.py @@ -15,7 +15,7 @@ def __init__(self, channel): channel: A grpc.Channel. """ self.SayHello = channel.unary_unary( - "/HelloWorldService/SayHello", + '/HelloWorldService/SayHello', request_serializer=helloworld__service__pb2.HelloRequest.SerializeToString, response_deserializer=helloworld__service__pb2.HelloReply.FromString, ) @@ -27,19 +27,19 @@ class HelloWorldServiceServicer(object): def SayHello(self, request, context): """Sends a greeting""" context.set_code(grpc.StatusCode.UNIMPLEMENTED) - context.set_details("Method not implemented!") - raise NotImplementedError("Method not implemented!") + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') def add_HelloWorldServiceServicer_to_server(servicer, server): rpc_method_handlers = { - "SayHello": grpc.unary_unary_rpc_method_handler( + 'SayHello': grpc.unary_unary_rpc_method_handler( servicer.SayHello, request_deserializer=helloworld__service__pb2.HelloRequest.FromString, response_serializer=helloworld__service__pb2.HelloReply.SerializeToString, ), } - generic_handler = grpc.method_handlers_generic_handler("HelloWorldService", rpc_method_handlers) + generic_handler = grpc.method_handlers_generic_handler('HelloWorldService', rpc_method_handlers) server.add_generic_rpc_handlers((generic_handler,)) @@ -63,7 +63,7 @@ def SayHello( return grpc.experimental.unary_unary( request, target, - "/HelloWorldService/SayHello", + '/HelloWorldService/SayHello', helloworld__service__pb2.HelloRequest.SerializeToString, helloworld__service__pb2.HelloReply.FromString, options, diff --git a/examples/grpc_proxying/invoke-caller.py b/examples/grpc_proxying/invoke-caller.py index aec579d4..a0729844 100644 --- a/examples/grpc_proxying/invoke-caller.py +++ b/examples/grpc_proxying/invoke-caller.py @@ -8,14 +8,14 @@ async def run() -> None: - async with grpc.aio.insecure_channel("127.0.0.1:50007") as channel: - metadata = (("dapr-app-id", "invoke-receiver"),) + async with grpc.aio.insecure_channel('127.0.0.1:50007') as channel: + metadata = (('dapr-app-id', 'invoke-receiver'),) stub = helloworld_service_pb2_grpc.HelloWorldServiceStub(channel) - response = await stub.SayHello(request=HelloRequest(name="you"), metadata=metadata) - print("Greeter client received: " + response.message) + response = await stub.SayHello(request=HelloRequest(name='you'), metadata=metadata) + print('Greeter client received: ' + response.message) -if __name__ == "__main__": - print("I am in main") +if __name__ == '__main__': + print('I am in main') logging.basicConfig() asyncio.run(run()) diff --git a/examples/grpc_proxying/invoke-receiver.py b/examples/grpc_proxying/invoke-receiver.py index 65301be2..ec36b036 100644 --- a/examples/grpc_proxying/invoke-receiver.py +++ b/examples/grpc_proxying/invoke-receiver.py @@ -10,13 +10,13 @@ class HelloWorldService(helloworld_service_pb2_grpc.HelloWorldService): def SayHello(self, request: HelloRequest, context: grpc.aio.ServicerContext) -> HelloReply: logging.info(request) - return HelloReply(message="Hello, %s!" % request.name) + return HelloReply(message='Hello, %s!' % request.name) app = App() -if __name__ == "__main__": - print("starting the HelloWorld Service") +if __name__ == '__main__': + print('starting the HelloWorld Service') logging.basicConfig(level=logging.INFO) app.add_external_service( helloworld_service_pb2_grpc.add_HelloWorldServiceServicer_to_server, HelloWorldService() diff --git a/examples/invoke-binding/invoke-input-binding.py b/examples/invoke-binding/invoke-input-binding.py index dd8162cb..f8701169 100644 --- a/examples/invoke-binding/invoke-input-binding.py +++ b/examples/invoke-binding/invoke-input-binding.py @@ -3,7 +3,7 @@ app = App() -@app.binding("kafkaBinding") +@app.binding('kafkaBinding') def binding(request: BindingRequest): print(request.text(), flush=True) diff --git a/examples/invoke-binding/invoke-output-binding.py b/examples/invoke-binding/invoke-output-binding.py index da5918ef..c4ce999d 100644 --- a/examples/invoke-binding/invoke-output-binding.py +++ b/examples/invoke-binding/invoke-output-binding.py @@ -7,11 +7,11 @@ n = 0 while True: n += 1 - req_data = {"id": n, "message": "hello world"} + req_data = {'id': n, 'message': 'hello world'} print(f'Sending message id: {req_data["id"]}, message "{req_data["message"]}"', flush=True) # Create a typed message with content type and body - resp = d.invoke_binding("kafkaBinding", "create", json.dumps(req_data)) + resp = d.invoke_binding('kafkaBinding', 'create', json.dumps(req_data)) time.sleep(1) diff --git a/examples/invoke-custom-data/invoke-caller.py b/examples/invoke-custom-data/invoke-caller.py index 8a2a0833..27dabd4d 100644 --- a/examples/invoke-custom-data/invoke-caller.py +++ b/examples/invoke-custom-data/invoke-caller.py @@ -5,10 +5,10 @@ with DaprClient() as d: # Create a typed message with content type and body resp = d.invoke_method( - app_id="invoke-receiver", - method_name="my_method", - data=b"SOME_DATA", - content_type="text/plain; charset=UTF-8", + app_id='invoke-receiver', + method_name='my_method', + data=b'SOME_DATA', + content_type='text/plain; charset=UTF-8', ) res = response_messages.CustomResponse() diff --git a/examples/invoke-custom-data/invoke-receiver.py b/examples/invoke-custom-data/invoke-receiver.py index f0564437..e2ad83ce 100644 --- a/examples/invoke-custom-data/invoke-receiver.py +++ b/examples/invoke-custom-data/invoke-receiver.py @@ -5,13 +5,13 @@ app = App() -@app.method("my_method") +@app.method('my_method') def mymethod(request: InvokeMethodRequest): print(request.metadata, flush=True) print(request.text(), flush=True) return response_messages.CustomResponse( - isSuccess=True, code=200, message="Hello World - Success!" + isSuccess=True, code=200, message='Hello World - Success!' ) diff --git a/examples/invoke-custom-data/proto/response_pb2.py b/examples/invoke-custom-data/proto/response_pb2.py index fa3fddbb..373ce113 100644 --- a/examples/invoke-custom-data/proto/response_pb2.py +++ b/examples/invoke-custom-data/proto/response_pb2.py @@ -17,13 +17,13 @@ ) -_CUSTOMRESPONSE = DESCRIPTOR.message_types_by_name["CustomResponse"] +_CUSTOMRESPONSE = DESCRIPTOR.message_types_by_name['CustomResponse'] CustomResponse = _reflection.GeneratedProtocolMessageType( - "CustomResponse", + 'CustomResponse', (_message.Message,), { - "DESCRIPTOR": _CUSTOMRESPONSE, - "__module__": "response_pb2", + 'DESCRIPTOR': _CUSTOMRESPONSE, + '__module__': 'response_pb2', # @@protoc_insertion_point(class_scope:CustomResponse) }, ) diff --git a/examples/invoke-http/invoke-caller.py b/examples/invoke-http/invoke-caller.py index 6fbadb58..6e2c3120 100644 --- a/examples/invoke-http/invoke-caller.py +++ b/examples/invoke-http/invoke-caller.py @@ -4,14 +4,14 @@ from dapr.clients import DaprClient with DaprClient() as d: - req_data = {"id": 1, "message": "hello world"} + req_data = {'id': 1, 'message': 'hello world'} while True: # Create a typed message with content type and body resp = d.invoke_method( - "invoke-receiver", - "my-method", - http_verb="POST", + 'invoke-receiver', + 'my-method', + http_verb='POST', data=json.dumps(req_data), ) diff --git a/examples/invoke-http/invoke-receiver.py b/examples/invoke-http/invoke-receiver.py index 3aea8a7e..95ac3192 100644 --- a/examples/invoke-http/invoke-receiver.py +++ b/examples/invoke-http/invoke-receiver.py @@ -5,11 +5,11 @@ app = Flask(__name__) -@app.route("/my-method", methods=["POST"]) +@app.route('/my-method', methods=['POST']) def getOrder(): data = request.json - print("Order received : " + json.dumps(data), flush=True) - return json.dumps({"success": True}), 200, {"ContentType": "application/json"} + print('Order received : ' + json.dumps(data), flush=True) + return json.dumps({'success': True}), 200, {'ContentType': 'application/json'} app.run(port=8088) diff --git a/examples/invoke-simple/invoke-caller.py b/examples/invoke-simple/invoke-caller.py index 911f7516..5c5773ea 100644 --- a/examples/invoke-simple/invoke-caller.py +++ b/examples/invoke-simple/invoke-caller.py @@ -4,13 +4,13 @@ from dapr.clients import DaprClient with DaprClient() as d: - req_data = {"id": 1, "message": "hello world"} + req_data = {'id': 1, 'message': 'hello world'} while True: # Create a typed message with content type and body resp = d.invoke_method( - "invoke-receiver", - "my-method", + 'invoke-receiver', + 'my-method', data=json.dumps(req_data), ) diff --git a/examples/invoke-simple/invoke-receiver.py b/examples/invoke-simple/invoke-receiver.py index debb9267..2d1f0c2e 100644 --- a/examples/invoke-simple/invoke-receiver.py +++ b/examples/invoke-simple/invoke-receiver.py @@ -3,12 +3,12 @@ app = App() -@app.method(name="my-method") +@app.method(name='my-method') def mymethod(request: InvokeMethodRequest) -> InvokeMethodResponse: print(request.metadata, flush=True) print(request.text(), flush=True) - return InvokeMethodResponse(b"INVOKE_RECEIVED", "text/plain; charset=UTF-8") + return InvokeMethodResponse(b'INVOKE_RECEIVED', 'text/plain; charset=UTF-8') app.run(50051) diff --git a/examples/metadata/app.py b/examples/metadata/app.py index 3ff66eee..df1b285d 100644 --- a/examples/metadata/app.py +++ b/examples/metadata/app.py @@ -15,35 +15,35 @@ def main(): - extended_attribute_name = "is-this-our-metadata-example" + extended_attribute_name = 'is-this-our-metadata-example' with DaprClient() as dapr: - print("First, we will assign a new custom label to Dapr sidecar") + print('First, we will assign a new custom label to Dapr sidecar') # We do this so example can be made deterministic across # multiple invocations. - original_value = "yes" + original_value = 'yes' dapr.set_metadata(extended_attribute_name, original_value) print("Now, we will fetch the sidecar's metadata") metadata = dapr.get_metadata() old_value = metadata.extended_metadata[extended_attribute_name] - print("And this is what we got:") - print(f" application_id: {metadata.application_id}") - print(f" active_actors_count: {metadata.active_actors_count}") - print(" registered_components:") + print('And this is what we got:') + print(f' application_id: {metadata.application_id}') + print(f' active_actors_count: {metadata.active_actors_count}') + print(' registered_components:') for name, type, version, caps in sorted(metadata.registered_components): - print(f" name={name} type={type} version={version} capabilities={sorted(caps)}") + print(f' name={name} type={type} version={version} capabilities={sorted(caps)}') - print("We will update our custom label value and check it was persisted") - dapr.set_metadata(extended_attribute_name, "You bet it is!") + print('We will update our custom label value and check it was persisted') + dapr.set_metadata(extended_attribute_name, 'You bet it is!') metadata = dapr.get_metadata() new_value = metadata.extended_metadata[extended_attribute_name] - print("We added a custom label named [%s]" % extended_attribute_name) - print("Its old value was [%s] but now it is [%s]" % (old_value, new_value)) + print('We added a custom label named [%s]' % extended_attribute_name) + print('Its old value was [%s] but now it is [%s]' % (old_value, new_value)) - print("And we are done 👋", flush=True) + print('And we are done 👋', flush=True) -if __name__ == "__main__": +if __name__ == '__main__': main() diff --git a/examples/pubsub-simple/publisher.py b/examples/pubsub-simple/publisher.py index 8b51b1ea..f6681f9e 100644 --- a/examples/pubsub-simple/publisher.py +++ b/examples/pubsub-simple/publisher.py @@ -20,14 +20,14 @@ id = 0 while id < 3: id += 1 - req_data = {"id": id, "message": "hello world"} + req_data = {'id': id, 'message': 'hello world'} # Create a typed message with content type and body resp = d.publish_event( - pubsub_name="pubsub", - topic_name="TOPIC_A", + pubsub_name='pubsub', + topic_name='TOPIC_A', data=json.dumps(req_data), - data_content_type="application/json", + data_content_type='application/json', ) # Print the request @@ -41,12 +41,12 @@ id = 3 while id < 6: id += 1 - req_data = {"id": id, "message": "hello world"} + req_data = {'id': id, 'message': 'hello world'} resp = d.publish_event( - pubsub_name="pubsub", - topic_name=f"topic/{id}", + pubsub_name='pubsub', + topic_name=f'topic/{id}', data=json.dumps(req_data), - data_content_type="application/json", + data_content_type='application/json', ) # Print the request @@ -55,13 +55,13 @@ time.sleep(0.5) # This topic will fail - initiate a retry which gets routed to the dead letter topic - req_data["id"] = 7 + req_data['id'] = 7 resp = d.publish_event( - pubsub_name="pubsub", - topic_name="TOPIC_D", + pubsub_name='pubsub', + topic_name='TOPIC_D', data=json.dumps(req_data), - data_content_type="application/json", - publish_metadata={"custommeta": "somevalue"}, + data_content_type='application/json', + publish_metadata={'custommeta': 'somevalue'}, ) # Print the request diff --git a/examples/pubsub-simple/subscriber.py b/examples/pubsub-simple/subscriber.py index 031adf5b..e74192f3 100644 --- a/examples/pubsub-simple/subscriber.py +++ b/examples/pubsub-simple/subscriber.py @@ -23,7 +23,7 @@ should_retry = True # To control whether dapr should retry sending a message -@app.subscribe(pubsub_name="pubsub", topic="TOPIC_A") +@app.subscribe(pubsub_name='pubsub', topic='TOPIC_A') def mytopic(event: v1.Event) -> TopicEventResponse: global should_retry data = json.loads(event.Data()) @@ -36,16 +36,16 @@ def mytopic(event: v1.Event) -> TopicEventResponse: if should_retry: should_retry = False # we only retry once in this example sleep(0.5) # add some delay to help with ordering of expected logs - return TopicEventResponse("retry") - return TopicEventResponse("success") + return TopicEventResponse('retry') + return TopicEventResponse('success') -@app.subscribe(pubsub_name="pubsub", topic="TOPIC_D", dead_letter_topic="TOPIC_D_DEAD") +@app.subscribe(pubsub_name='pubsub', topic='TOPIC_D', dead_letter_topic='TOPIC_D_DEAD') def fail_and_send_to_dead_topic(event: v1.Event) -> TopicEventResponse: - return TopicEventResponse("retry") + return TopicEventResponse('retry') -@app.subscribe(pubsub_name="pubsub", topic="TOPIC_D_DEAD") +@app.subscribe(pubsub_name='pubsub', topic='TOPIC_D_DEAD') def mytopic_dead(event: v1.Event) -> TopicEventResponse: data = json.loads(event.Data()) print( @@ -53,12 +53,12 @@ def mytopic_dead(event: v1.Event) -> TopicEventResponse: f'content_type="{event.content_type}"', flush=True, ) - print("Dead-Letter Subscriber. Received via deadletter topic: " + event.Subject(), flush=True) + print('Dead-Letter Subscriber. Received via deadletter topic: ' + event.Subject(), flush=True) print( - "Dead-Letter Subscriber. Originally intended topic: " + event.Extensions()["topic"], + 'Dead-Letter Subscriber. Originally intended topic: ' + event.Extensions()['topic'], flush=True, ) - return TopicEventResponse("success") + return TopicEventResponse('success') # == for testing with Redis only == @@ -66,13 +66,13 @@ def mytopic_dead(event: v1.Event) -> TopicEventResponse: # we manually register the distinct topics for id in range(4, 7): app._servicer._registered_topics.append( - appcallback_v1.TopicSubscription(pubsub_name="pubsub", topic=f"topic/{id}") + appcallback_v1.TopicSubscription(pubsub_name='pubsub', topic=f'topic/{id}') ) # ================================= # this allows subscribing to all events sent to this app - useful for wildcard topics -@app.subscribe(pubsub_name="pubsub", topic="topic/#", disable_topic_validation=True) +@app.subscribe(pubsub_name='pubsub', topic='topic/#', disable_topic_validation=True) def mytopic_wildcard(event: v1.Event) -> TopicEventResponse: data = json.loads(event.Data()) print( @@ -80,7 +80,7 @@ def mytopic_wildcard(event: v1.Event) -> TopicEventResponse: f'content_type="{event.content_type}"', flush=True, ) - return TopicEventResponse("success") + return TopicEventResponse('success') app.run(50051) diff --git a/examples/secret_store/example.py b/examples/secret_store/example.py index 4375fa9e..22d9a505 100644 --- a/examples/secret_store/example.py +++ b/examples/secret_store/example.py @@ -14,20 +14,20 @@ from dapr.clients import DaprClient with DaprClient() as d: - key = "secretKey" - randomKey = "random" - storeName = "localsecretstore" + key = 'secretKey' + randomKey = 'random' + storeName = 'localsecretstore' resp = d.get_secret(store_name=storeName, key=key) - print("Got!") + print('Got!') print(resp.secret) resp = d.get_bulk_secret(store_name=storeName) - print("Got!") + print('Got!') # Converts dict into sorted list of tuples for deterministic output. print(sorted(resp.secrets.items())) try: resp = d.get_secret(store_name=storeName, key=randomKey) - print("Got!") + print('Got!') print(resp.secret) except: - print("Got expected error for accessing random key") + print('Got expected error for accessing random key') diff --git a/examples/state_store/state_store.py b/examples/state_store/state_store.py index 5bf9f4c6..411e809a 100644 --- a/examples/state_store/state_store.py +++ b/examples/state_store/state_store.py @@ -10,31 +10,31 @@ from dapr.clients.grpc._state import StateItem with DaprClient() as d: - storeName = "statestore" + storeName = 'statestore' - key = "key_1" - value = "value_1" - updated_value = "value_1_updated" + key = 'key_1' + value = 'value_1' + updated_value = 'value_1_updated' - another_key = "key_2" - another_value = "value_2" + another_key = 'key_2' + another_value = 'value_2' - yet_another_key = "key_3" - yet_another_value = "value_3" + yet_another_key = 'key_3' + yet_another_value = 'value_3' # Wait for sidecar to be up within 5 seconds. d.wait(5) # Save single state. d.save_state(store_name=storeName, key=key, value=value) - print(f"State store has successfully saved {value} with {key} as key") + print(f'State store has successfully saved {value} with {key} as key') # Save with an etag that is different from the one stored in the database. try: - d.save_state(store_name=storeName, key=key, value=another_value, etag="9999") + d.save_state(store_name=storeName, key=key, value=another_value, etag='9999') except grpc.RpcError as err: # StatusCode should be StatusCode.ABORTED. - print(f"Cannot save due to bad etag. ErrorCode={err.code()}") + print(f'Cannot save due to bad etag. ErrorCode={err.code()}') # For detailed error messages from the dapr runtime: # print(f"Details={err.details()}) @@ -47,28 +47,28 @@ StateItem(key=yet_another_key, value=yet_another_value), ], ) - print(f"State store has successfully saved {another_value} with {another_key} as key") - print(f"State store has successfully saved {yet_another_value} with {yet_another_key} as key") + print(f'State store has successfully saved {another_value} with {another_key} as key') + print(f'State store has successfully saved {yet_another_value} with {yet_another_key} as key') # Save bulk with etag that is different from the one stored in the database. try: d.save_bulk_state( store_name=storeName, states=[ - StateItem(key=another_key, value=another_value, etag="999"), - StateItem(key=yet_another_key, value=yet_another_value, etag="999"), + StateItem(key=another_key, value=another_value, etag='999'), + StateItem(key=yet_another_key, value=yet_another_value, etag='999'), ], ) except grpc.RpcError as err: # StatusCode should be StatusCode.ABORTED. - print(f"Cannot save bulk due to bad etags. ErrorCode={err.code()}") + print(f'Cannot save bulk due to bad etags. ErrorCode={err.code()}') # For detailed error messages from the dapr runtime: # print(f"Details={err.details()}) # Get one state by key. - state = d.get_state(store_name=storeName, key=key, state_metadata={"metakey": "metavalue"}) - print(f"Got value={state.data} eTag={state.etag}") + state = d.get_state(store_name=storeName, key=key, state_metadata={'metakey': 'metavalue'}) + print(f'Got value={state.data} eTag={state.etag}') # Transaction upsert d.execute_state_transaction( @@ -86,11 +86,11 @@ # Batch get items = d.get_bulk_state( - store_name=storeName, keys=[key, another_key], states_metadata={"metakey": "metavalue"} + store_name=storeName, keys=[key, another_key], states_metadata={'metakey': 'metavalue'} ).items - print(f"Got items with etags: {[(i.data, i.etag) for i in items]}") + print(f'Got items with etags: {[(i.data, i.etag) for i in items]}') # Delete one state by key. - d.delete_state(store_name=storeName, key=key, state_metadata={"metakey": "metavalue"}) + d.delete_state(store_name=storeName, key=key, state_metadata={'metakey': 'metavalue'}) data = d.get_state(store_name=storeName, key=key).data - print(f"Got value after delete: {data}") + print(f'Got value after delete: {data}') diff --git a/examples/state_store_query/state_store_query.py b/examples/state_store_query/state_store_query.py index 3b273fbc..90aa23be 100644 --- a/examples/state_store_query/state_store_query.py +++ b/examples/state_store_query/state_store_query.py @@ -8,23 +8,23 @@ import json with DaprClient() as d: - storeName = "statestore" + storeName = 'statestore' # Wait for sidecar to be up within 5 seconds. d.wait(5) # Query the state store - query = open("query.json", "r").read() + query = open('query.json', 'r').read() res = d.query_state(store_name=storeName, query=query) for r in res.results: - print(r.key, json.dumps(json.loads(str(r.value, "UTF-8")), sort_keys=True)) - print("Token:", res.token) + print(r.key, json.dumps(json.loads(str(r.value, 'UTF-8')), sort_keys=True)) + print('Token:', res.token) # Get more results using a pagination token - query = open("query-token.json", "r").read() + query = open('query-token.json', 'r').read() res = d.query_state(store_name=storeName, query=query) for r in res.results: - print(r.key, json.dumps(json.loads(str(r.value, "UTF-8")), sort_keys=True)) - print("Token:", res.token) + print(r.key, json.dumps(json.loads(str(r.value, 'UTF-8')), sort_keys=True)) + print('Token:', res.token) diff --git a/examples/w3c-tracing/invoke-caller.py b/examples/w3c-tracing/invoke-caller.py index aef558f4..d5b0d2e5 100644 --- a/examples/w3c-tracing/invoke-caller.py +++ b/examples/w3c-tracing/invoke-caller.py @@ -7,12 +7,12 @@ from opencensus.trace.samplers import AlwaysOnSampler ze = ZipkinExporter( - service_name="python-example", host_name="localhost", port=9411, endpoint="/api/v2/spans" + service_name='python-example', host_name='localhost', port=9411, endpoint='/api/v2/spans' ) tracer = Tracer(exporter=ze, sampler=AlwaysOnSampler()) -with tracer.span(name="main") as span: +with tracer.span(name='main') as span: with DaprClient( headers_callback=lambda: tracer.propagator.to_headers(tracer.span_context) ) as d: @@ -21,15 +21,15 @@ for i in range(num_messages): # Create a typed message with content type and body resp = d.invoke_method( - "invoke-receiver", - "say", - data=json.dumps({"id": i, "message": "hello world"}), + 'invoke-receiver', + 'say', + data=json.dumps({'id': i, 'message': 'hello world'}), ) # Print the response print(resp.content_type, flush=True) print(resp.text(), flush=True) - resp = d.invoke_method("invoke-receiver", "sleep", data="") + resp = d.invoke_method('invoke-receiver', 'sleep', data='') # Print the response print(resp.content_type, flush=True) print(resp.text(), flush=True) diff --git a/examples/w3c-tracing/invoke-receiver.py b/examples/w3c-tracing/invoke-receiver.py index 3aa0e967..9dd2594c 100644 --- a/examples/w3c-tracing/invoke-receiver.py +++ b/examples/w3c-tracing/invoke-receiver.py @@ -15,27 +15,27 @@ ) -@app.method(name="say") +@app.method(name='say') def say(request: InvokeMethodRequest) -> InvokeMethodResponse: tracer = Tracer(sampler=AlwaysOnSampler()) - with tracer.span(name="say") as span: + with tracer.span(name='say') as span: data = request.text() - span.add_annotation("Request length", len=len(data)) + span.add_annotation('Request length', len=len(data)) print(request.metadata, flush=True) print(request.text(), flush=True) - return InvokeMethodResponse(b"SAY", "text/plain; charset=UTF-8") + return InvokeMethodResponse(b'SAY', 'text/plain; charset=UTF-8') -@app.method(name="sleep") +@app.method(name='sleep') def sleep(request: InvokeMethodRequest) -> InvokeMethodResponse: tracer = Tracer(sampler=AlwaysOnSampler()) - with tracer.span(name="sleep") as _: + with tracer.span(name='sleep') as _: time.sleep(2) print(request.metadata, flush=True) print(request.text(), flush=True) - return InvokeMethodResponse(b"SLEEP", "text/plain; charset=UTF-8") + return InvokeMethodResponse(b'SLEEP', 'text/plain; charset=UTF-8') app.run(3001) diff --git a/examples/workflow/child_workflow.py b/examples/workflow/child_workflow.py index 48dd9504..dccaa631 100644 --- a/examples/workflow/child_workflow.py +++ b/examples/workflow/child_workflow.py @@ -20,13 +20,13 @@ def main_workflow(ctx: wf.DaprWorkflowContext): try: instance_id = ctx.instance_id - child_instance_id = instance_id + "-child" - print(f"*** Calling child workflow {child_instance_id}", flush=True) + child_instance_id = instance_id + '-child' + print(f'*** Calling child workflow {child_instance_id}', flush=True) yield ctx.call_child_workflow( workflow=child_workflow, input=None, instance_id=child_instance_id ) except Exception as e: - print(f"*** Exception: {e}") + print(f'*** Exception: {e}') return @@ -34,10 +34,10 @@ def main_workflow(ctx: wf.DaprWorkflowContext): @wfr.workflow def child_workflow(ctx: wf.DaprWorkflowContext): instance_id = ctx.instance_id - print(f"*** Child workflow {instance_id} called", flush=True) + print(f'*** Child workflow {instance_id} called', flush=True) -if __name__ == "__main__": +if __name__ == '__main__': wfr.start() time.sleep(10) # wait for workflow runtime to start diff --git a/examples/workflow/fan_out_fan_in.py b/examples/workflow/fan_out_fan_in.py index eb7513d9..e5799862 100644 --- a/examples/workflow/fan_out_fan_in.py +++ b/examples/workflow/fan_out_fan_in.py @@ -17,7 +17,7 @@ wfr = wf.WorkflowRuntime() -@wfr.workflow(name="batch_processing") +@wfr.workflow(name='batch_processing') def batch_processing_workflow(ctx: wf.DaprWorkflowContext, wf_input: int): # get a batch of N work items to process in parallel work_batch = yield ctx.call_activity(get_work_batch, input=wf_input) @@ -33,32 +33,32 @@ def batch_processing_workflow(ctx: wf.DaprWorkflowContext, wf_input: int): yield ctx.call_activity(process_results, input=total) -@wfr.activity(name="get_batch") +@wfr.activity(name='get_batch') def get_work_batch(ctx, batch_size: int) -> List[int]: return [i + 1 for i in range(batch_size)] @wfr.activity def process_work_item(ctx, work_item: int) -> int: - print(f"Processing work item: {work_item}.") + print(f'Processing work item: {work_item}.') time.sleep(5) result = work_item * 2 - print(f"Work item {work_item} processed. Result: {result}.") + print(f'Work item {work_item} processed. Result: {result}.') return result -@wfr.activity(name="final_process") +@wfr.activity(name='final_process') def process_results(ctx, final_result: int): - print(f"Final result: {final_result}.") + print(f'Final result: {final_result}.') -if __name__ == "__main__": +if __name__ == '__main__': wfr.start() time.sleep(10) # wait for workflow runtime to start wf_client = wf.DaprWorkflowClient() instance_id = wf_client.schedule_new_workflow(workflow=batch_processing_workflow, input=10) - print(f"Workflow started. Instance ID: {instance_id}") + print(f'Workflow started. Instance ID: {instance_id}') state = wf_client.wait_for_workflow_completion(instance_id) wfr.shutdown() diff --git a/examples/workflow/human_approval.py b/examples/workflow/human_approval.py index 5cd16bc4..6a8a725d 100644 --- a/examples/workflow/human_approval.py +++ b/examples/workflow/human_approval.py @@ -28,7 +28,7 @@ class Order: quantity: int def __str__(self): - return f"{self.product} ({self.quantity})" + return f'{self.product} ({self.quantity})' @dataclass @@ -40,21 +40,21 @@ def from_dict(dict): return Approval(**dict) -@wfr.workflow(name="purchase_order_wf") +@wfr.workflow(name='purchase_order_wf') def purchase_order_workflow(ctx: wf.DaprWorkflowContext, order: Order): # Orders under $1000 are auto-approved if order.cost < 1000: - return "Auto-approved" + return 'Auto-approved' # Orders of $1000 or more require manager approval yield ctx.call_activity(send_approval_request, input=order) # Approvals must be received within 24 hours or they will be canceled. - approval_event = ctx.wait_for_external_event("approval_received") + approval_event = ctx.wait_for_external_event('approval_received') timeout_event = ctx.create_timer(timedelta(hours=24)) winner = yield wf.when_any([approval_event, timeout_event]) if winner == timeout_event: - return "Cancelled" + return 'Cancelled' # The order was approved yield ctx.call_activity(place_order, input=order) @@ -62,30 +62,30 @@ def purchase_order_workflow(ctx: wf.DaprWorkflowContext, order: Order): return f"Approved by '{approval_details.approver}'" -@wfr.activity(name="send_approval") +@wfr.activity(name='send_approval') def send_approval_request(_, order: Order) -> None: - print(f"*** Requesting approval from user for order: {order}") + print(f'*** Requesting approval from user for order: {order}') @wfr.activity def place_order(_, order: Order) -> None: - print(f"*** Placing order: {order}") + print(f'*** Placing order: {order}') -if __name__ == "__main__": +if __name__ == '__main__': import argparse - parser = argparse.ArgumentParser(description="Order purchasing workflow demo.") - parser.add_argument("--cost", type=int, default=2000, help="Cost of the order") - parser.add_argument("--approver", type=str, default="Me", help="Approver name") - parser.add_argument("--timeout", type=int, default=60, help="Timeout in seconds") + parser = argparse.ArgumentParser(description='Order purchasing workflow demo.') + parser.add_argument('--cost', type=int, default=2000, help='Cost of the order') + parser.add_argument('--approver', type=str, default='Me', help='Approver name') + parser.add_argument('--timeout', type=int, default=60, help='Timeout in seconds') args = parser.parse_args() # start the workflow runtime wfr.start() # Start a purchase order workflow using the user input - order = Order(args.cost, "MyProduct", 1) + order = Order(args.cost, 'MyProduct', 1) wf_client = wf.DaprWorkflowClient() instance_id = wf_client.schedule_new_workflow(workflow=purchase_order_workflow, input=order) @@ -93,12 +93,12 @@ def place_order(_, order: Order) -> None: def prompt_for_approval(): # Give the workflow time to start up and notify the user time.sleep(2) - input("Press [ENTER] to approve the order...\n") + input('Press [ENTER] to approve the order...\n') with DaprClient() as d: d.raise_workflow_event( instance_id=instance_id, - workflow_component="dapr", - event_name="approval_received", + workflow_component='dapr', + event_name='approval_received', event_data=asdict(Approval(args.approver)), ) @@ -111,12 +111,12 @@ def prompt_for_approval(): instance_id, timeout_in_seconds=args.timeout + 2 ) if not state: - print("Workflow not found!") # not expected - elif state.runtime_status.name == "COMPLETED": - print(f"Workflow completed! Result: {state.serialized_output}") + print('Workflow not found!') # not expected + elif state.runtime_status.name == 'COMPLETED': + print(f'Workflow completed! Result: {state.serialized_output}') else: - print(f"Workflow failed! Status: {state.runtime_status.name}") # not expected + print(f'Workflow failed! Status: {state.runtime_status.name}') # not expected except TimeoutError: - print("*** Workflow timed out!") + print('*** Workflow timed out!') wfr.shutdown() diff --git a/examples/workflow/monitor.py b/examples/workflow/monitor.py index 5826988e..a6da1c7d 100644 --- a/examples/workflow/monitor.py +++ b/examples/workflow/monitor.py @@ -25,14 +25,14 @@ class JobStatus: is_healthy: bool -@wfr.workflow(name="status_monitor") +@wfr.workflow(name='status_monitor') def status_monitor_workflow(ctx: wf.DaprWorkflowContext, job: JobStatus): # poll a status endpoint associated with this job status = yield ctx.call_activity(check_status, input=job) if not ctx.is_replaying: print(f"Job '{job.job_id}' is {status}.") - if status == "healthy": + if status == 'healthy': job.is_healthy = True next_sleep_interval = 60 # check less frequently when healthy else: @@ -49,34 +49,34 @@ def status_monitor_workflow(ctx: wf.DaprWorkflowContext, job: JobStatus): @wfr.activity def check_status(ctx, _) -> str: - return random.choice(["healthy", "unhealthy"]) + return random.choice(['healthy', 'unhealthy']) @wfr.activity def send_alert(ctx, message: str): - print(f"*** Alert: {message}") + print(f'*** Alert: {message}') -if __name__ == "__main__": +if __name__ == '__main__': wfr.start() sleep(10) # wait for workflow runtime to start wf_client = wf.DaprWorkflowClient() - job_id = "job1" + job_id = 'job1' status = None try: status = wf_client.get_workflow_state(job_id) except Exception: pass - if not status or status.runtime_status.name != "RUNNING": + if not status or status.runtime_status.name != 'RUNNING': instance_id = wf_client.schedule_new_workflow( workflow=status_monitor_workflow, input=JobStatus(job_id=job_id, is_healthy=True), instance_id=job_id, ) - print(f"Workflow started. Instance ID: {instance_id}") + print(f'Workflow started. Instance ID: {instance_id}') else: - print(f"Workflow already running. Instance ID: {job_id}") + print(f'Workflow already running. Instance ID: {job_id}') - input("Press Enter to stop...\n") + input('Press Enter to stop...\n') wfr.shutdown() diff --git a/examples/workflow/task_chaining.py b/examples/workflow/task_chaining.py index b04a6bf3..c24e340c 100644 --- a/examples/workflow/task_chaining.py +++ b/examples/workflow/task_chaining.py @@ -18,7 +18,7 @@ wfr = wf.WorkflowRuntime() -@wfr.workflow(name="random_workflow") +@wfr.workflow(name='random_workflow') def task_chain_workflow(ctx: wf.DaprWorkflowContext, wf_input: int): try: result1 = yield ctx.call_activity(step1, input=wf_input) @@ -30,41 +30,41 @@ def task_chain_workflow(ctx: wf.DaprWorkflowContext, wf_input: int): return [result1, result2, result3] -@wfr.activity(name="step10") +@wfr.activity(name='step10') def step1(ctx, activity_input): - print(f"Step 1: Received input: {activity_input}.") + print(f'Step 1: Received input: {activity_input}.') # Do some work return activity_input + 1 @wfr.activity def step2(ctx, activity_input): - print(f"Step 2: Received input: {activity_input}.") + print(f'Step 2: Received input: {activity_input}.') # Do some work return activity_input * 2 @wfr.activity def step3(ctx, activity_input): - print(f"Step 3: Received input: {activity_input}.") + print(f'Step 3: Received input: {activity_input}.') # Do some work return activity_input ^ 2 @wfr.activity def error_handler(ctx, error): - print(f"Executing error handler: {error}.") + print(f'Executing error handler: {error}.') # Do some compensating work -if __name__ == "__main__": +if __name__ == '__main__': wfr.start() sleep(10) # wait for workflow runtime to start wf_client = wf.DaprWorkflowClient() instance_id = wf_client.schedule_new_workflow(workflow=task_chain_workflow, input=42) - print(f"Workflow started. Instance ID: {instance_id}") + print(f'Workflow started. Instance ID: {instance_id}') state = wf_client.wait_for_workflow_completion(instance_id) - print(f"Workflow completed! Status: {state.runtime_status}") + print(f'Workflow completed! Status: {state.runtime_status}') wfr.shutdown() diff --git a/ext/dapr-ext-fastapi/dapr/ext/fastapi/__init__.py b/ext/dapr-ext-fastapi/dapr/ext/fastapi/__init__.py index 8c616895..94260307 100644 --- a/ext/dapr-ext-fastapi/dapr/ext/fastapi/__init__.py +++ b/ext/dapr-ext-fastapi/dapr/ext/fastapi/__init__.py @@ -17,4 +17,4 @@ from .app import DaprApp -__all__ = ["DaprActor", "DaprApp"] +__all__ = ['DaprActor', 'DaprApp'] diff --git a/ext/dapr-ext-fastapi/dapr/ext/fastapi/actor.py b/ext/dapr-ext-fastapi/dapr/ext/fastapi/actor.py index ec18f5d7..cf509fd6 100644 --- a/ext/dapr-ext-fastapi/dapr/ext/fastapi/actor.py +++ b/ext/dapr-ext-fastapi/dapr/ext/fastapi/actor.py @@ -23,8 +23,8 @@ from dapr.clients.exceptions import DaprInternalError, ERROR_CODE_UNKNOWN from dapr.serializers import DefaultJSONSerializer -DEFAULT_CONTENT_TYPE = "application/json; utf-8" -DAPR_REENTRANCY_ID_HEADER = "Dapr-Reentrancy-Id" +DEFAULT_CONTENT_TYPE = 'application/json; utf-8' +DAPR_REENTRANCY_ID_HEADER = 'Dapr-Reentrancy-Id' def _wrap_response( @@ -36,10 +36,10 @@ def _wrap_response( resp = None if isinstance(msg, str): response_obj = { - "message": msg, + 'message': msg, } if not (status_code >= 200 and status_code < 300) and error_code: - response_obj["errorCode"] = error_code + response_obj['errorCode'] = error_code resp = JSONResponse(content=response_obj, status_code=status_code) elif isinstance(msg, bytes): resp = Response(content=msg, media_type=content_type) @@ -49,7 +49,7 @@ def _wrap_response( class DaprActor(object): - def __init__(self, app: FastAPI, router_tags: Optional[List[str]] = ["Actor"]): + def __init__(self, app: FastAPI, router_tags: Optional[List[str]] = ['Actor']): # router_tags should be added to all magic Dapr Actor methods implemented here self._router_tags = router_tags self._router = APIRouter() @@ -58,16 +58,16 @@ def __init__(self, app: FastAPI, router_tags: Optional[List[str]] = ["Actor"]): app.include_router(self._router) def init_routes(self, router: APIRouter): - @router.get("/healthz", tags=self._router_tags) + @router.get('/healthz', tags=self._router_tags) async def healthz(): - return {"status": "ok"} + return {'status': 'ok'} - @router.get("/dapr/config", tags=self._router_tags) + @router.get('/dapr/config', tags=self._router_tags) async def dapr_config(): serialized = self._dapr_serializer.serialize(ActorRuntime.get_actor_config()) return _wrap_response(status.HTTP_200_OK, serialized) - @router.delete("/actors/{actor_type_name}/{actor_id}", tags=self._router_tags) + @router.delete('/actors/{actor_type_name}/{actor_id}', tags=self._router_tags) async def actor_deactivation(actor_type_name: str, actor_id: str): try: await ActorRuntime.deactivate(actor_type_name, actor_id) @@ -78,12 +78,12 @@ async def actor_deactivation(actor_type_name: str, actor_id: str): status.HTTP_500_INTERNAL_SERVER_ERROR, repr(ex), ERROR_CODE_UNKNOWN ) - msg = f"deactivated actor: {actor_type_name}.{actor_id}" + msg = f'deactivated actor: {actor_type_name}.{actor_id}' logger.debug(msg) return _wrap_response(status.HTTP_200_OK, msg) @router.put( - "/actors/{actor_type_name}/{actor_id}/method/{method_name}", tags=self._router_tags + '/actors/{actor_type_name}/{actor_id}/method/{method_name}', tags=self._router_tags ) async def actor_method( actor_type_name: str, actor_id: str, method_name: str, request: Request @@ -102,12 +102,12 @@ async def actor_method( status.HTTP_500_INTERNAL_SERVER_ERROR, repr(ex), ERROR_CODE_UNKNOWN ) - msg = f"called method. actor: {actor_type_name}.{actor_id}, method: {method_name}" + msg = f'called method. actor: {actor_type_name}.{actor_id}, method: {method_name}' logger.debug(msg) return _wrap_response(status.HTTP_200_OK, result) @router.put( - "/actors/{actor_type_name}/{actor_id}/method/timer/{timer_name}", tags=self._router_tags + '/actors/{actor_type_name}/{actor_id}/method/timer/{timer_name}', tags=self._router_tags ) async def actor_timer( actor_type_name: str, actor_id: str, timer_name: str, request: Request @@ -123,12 +123,12 @@ async def actor_timer( status.HTTP_500_INTERNAL_SERVER_ERROR, repr(ex), ERROR_CODE_UNKNOWN ) - msg = f"called timer. actor: {actor_type_name}.{actor_id}, timer: {timer_name}" + msg = f'called timer. actor: {actor_type_name}.{actor_id}, timer: {timer_name}' logger.debug(msg) return _wrap_response(status.HTTP_200_OK, msg) @router.put( - "/actors/{actor_type_name}/{actor_id}/method/remind/{reminder_name}", + '/actors/{actor_type_name}/{actor_id}/method/remind/{reminder_name}', tags=self._router_tags, ) async def actor_reminder( @@ -145,10 +145,10 @@ async def actor_reminder( status.HTTP_500_INTERNAL_SERVER_ERROR, repr(ex), ERROR_CODE_UNKNOWN ) - msg = f"called reminder. actor: {actor_type_name}.{actor_id}, reminder: {reminder_name}" + msg = f'called reminder. actor: {actor_type_name}.{actor_id}, reminder: {reminder_name}' logger.debug(msg) return _wrap_response(status.HTTP_200_OK, msg) async def register_actor(self, actor: Type[Actor]) -> None: await ActorRuntime.register_actor(actor) - logger.debug(f"registered actor: {actor.__class__.__name__}") + logger.debug(f'registered actor: {actor.__class__.__name__}') diff --git a/ext/dapr-ext-fastapi/dapr/ext/fastapi/app.py b/ext/dapr-ext-fastapi/dapr/ext/fastapi/app.py index 5773beb2..d926fac5 100644 --- a/ext/dapr-ext-fastapi/dapr/ext/fastapi/app.py +++ b/ext/dapr-ext-fastapi/dapr/ext/fastapi/app.py @@ -24,14 +24,14 @@ class DaprApp: app_instance: The FastAPI instance to wrap. """ - def __init__(self, app_instance: FastAPI, router_tags: Optional[List[str]] = ["PubSub"]): + def __init__(self, app_instance: FastAPI, router_tags: Optional[List[str]] = ['PubSub']): # The router_tags should be added to all magic Dapr App PubSub methods implemented here self._router_tags = router_tags self._app = app_instance self._subscriptions: List[Dict[str, object]] = [] self._app.add_api_route( - "/dapr/subscribe", self._get_subscriptions, methods=["GET"], tags=self._router_tags + '/dapr/subscribe', self._get_subscriptions, methods=['GET'], tags=self._router_tags ) def subscribe( @@ -75,20 +75,20 @@ def subscribe( """ def decorator(func): - event_handler_route = f"/events/{pubsub}/{topic}" if route is None else route + event_handler_route = f'/events/{pubsub}/{topic}' if route is None else route self._app.add_api_route( - event_handler_route, func, methods=["POST"], tags=self._router_tags + event_handler_route, func, methods=['POST'], tags=self._router_tags ) self._subscriptions.append( { - "pubsubname": pubsub, - "topic": topic, - "route": event_handler_route, - "metadata": metadata, + 'pubsubname': pubsub, + 'topic': topic, + 'route': event_handler_route, + 'metadata': metadata, **( - {"deadLetterTopic": dead_letter_topic} + {'deadLetterTopic': dead_letter_topic} if dead_letter_topic is not None else {} ), diff --git a/ext/dapr-ext-fastapi/dapr/ext/fastapi/version.py b/ext/dapr-ext-fastapi/dapr/ext/fastapi/version.py index 3bd3df76..2fea8188 100644 --- a/ext/dapr-ext-fastapi/dapr/ext/fastapi/version.py +++ b/ext/dapr-ext-fastapi/dapr/ext/fastapi/version.py @@ -13,4 +13,4 @@ limitations under the License. """ -__version__ = "1.11.0rc1.dev" +__version__ = '1.11.0rc1.dev' diff --git a/ext/dapr-ext-fastapi/setup.py b/ext/dapr-ext-fastapi/setup.py index 5cd85528..8d6a400c 100644 --- a/ext/dapr-ext-fastapi/setup.py +++ b/ext/dapr-ext-fastapi/setup.py @@ -19,18 +19,18 @@ # Load version in dapr package. version_info = {} -with open("dapr/ext/fastapi/version.py") as fp: +with open('dapr/ext/fastapi/version.py') as fp: exec(fp.read(), version_info) -__version__ = version_info["__version__"] +__version__ = version_info['__version__'] def is_release(): - return ".dev" not in __version__ + return '.dev' not in __version__ -name = "dapr-ext-fastapi" +name = 'dapr-ext-fastapi' version = __version__ -description = "The official release of Dapr FastAPI extension." +description = 'The official release of Dapr FastAPI extension.' long_description = """ This is the FastAPI extension for Dapr. @@ -45,15 +45,15 @@ def is_release(): """.lstrip() # Get build number from GITHUB_RUN_NUMBER environment variable -build_number = os.environ.get("GITHUB_RUN_NUMBER", "0") +build_number = os.environ.get('GITHUB_RUN_NUMBER', '0') if not is_release(): - name += "-dev" - version = f"{__version__}{build_number}" - description = "The developmental release for Dapr FastAPI extension." - long_description = "This is the developmental release for Dapr FastAPI extension." + name += '-dev' + version = f'{__version__}{build_number}' + description = 'The developmental release for Dapr FastAPI extension.' + long_description = 'This is the developmental release for Dapr FastAPI extension.' -print(f"package name: {name}, version: {version}", flush=True) +print(f'package name: {name}, version: {version}', flush=True) setup( diff --git a/ext/dapr-ext-fastapi/tests/test_app.py b/ext/dapr-ext-fastapi/tests/test_app.py index a8d5a74b..98da225b 100644 --- a/ext/dapr-ext-fastapi/tests/test_app.py +++ b/ext/dapr-ext-fastapi/tests/test_app.py @@ -17,75 +17,75 @@ def setUp(self): self.client = TestClient(self.app) def test_subscribe_subscription_registered(self): - @self.dapr_app.subscribe(pubsub="pubsub", topic="test") + @self.dapr_app.subscribe(pubsub='pubsub', topic='test') def event_handler(event_data: Message): - return "default route" + return 'default route' self.assertEqual(len(self.dapr_app._subscriptions), 1) - self.assertIn("/dapr/subscribe", [route.path for route in self.app.router.routes]) - self.assertIn("/events/pubsub/test", [route.path for route in self.app.router.routes]) + self.assertIn('/dapr/subscribe', [route.path for route in self.app.router.routes]) + self.assertIn('/events/pubsub/test', [route.path for route in self.app.router.routes]) - response = self.client.get("/dapr/subscribe") + response = self.client.get('/dapr/subscribe') self.assertEqual( [ { - "pubsubname": "pubsub", - "topic": "test", - "route": "/events/pubsub/test", - "metadata": {}, + 'pubsubname': 'pubsub', + 'topic': 'test', + 'route': '/events/pubsub/test', + 'metadata': {}, } ], response.json(), ) - response = self.client.post("/events/pubsub/test", json={"body": "new message"}) + response = self.client.post('/events/pubsub/test', json={'body': 'new message'}) self.assertEqual(response.status_code, 200) self.assertEqual(response.text, '"default route"') def test_subscribe_with_route_subscription_registered_with_custom_route(self): - @self.dapr_app.subscribe(pubsub="pubsub", topic="test", route="/do-something") + @self.dapr_app.subscribe(pubsub='pubsub', topic='test', route='/do-something') def event_handler(event_data: Message): - return "custom route" + return 'custom route' self.assertEqual(len(self.dapr_app._subscriptions), 1) - self.assertIn("/dapr/subscribe", [route.path for route in self.app.router.routes]) - self.assertIn("/do-something", [route.path for route in self.app.router.routes]) + self.assertIn('/dapr/subscribe', [route.path for route in self.app.router.routes]) + self.assertIn('/do-something', [route.path for route in self.app.router.routes]) - response = self.client.get("/dapr/subscribe") + response = self.client.get('/dapr/subscribe') self.assertEqual( - [{"pubsubname": "pubsub", "topic": "test", "route": "/do-something", "metadata": {}}], + [{'pubsubname': 'pubsub', 'topic': 'test', 'route': '/do-something', 'metadata': {}}], response.json(), ) - response = self.client.post("/do-something", json={"body": "new message"}) + response = self.client.post('/do-something', json={'body': 'new message'}) self.assertEqual(response.status_code, 200) self.assertEqual(response.text, '"custom route"') def test_subscribe_metadata(self): - handler_metadata = {"rawPayload": "true"} + handler_metadata = {'rawPayload': 'true'} - @self.dapr_app.subscribe(pubsub="pubsub", topic="test", metadata=handler_metadata) + @self.dapr_app.subscribe(pubsub='pubsub', topic='test', metadata=handler_metadata) def event_handler(event_data: Message): - return "custom metadata" + return 'custom metadata' - self.assertEqual((self.dapr_app._subscriptions[0]["metadata"]["rawPayload"]), "true") + self.assertEqual((self.dapr_app._subscriptions[0]['metadata']['rawPayload']), 'true') - response = self.client.get("/dapr/subscribe") + response = self.client.get('/dapr/subscribe') self.assertEqual( [ { - "pubsubname": "pubsub", - "topic": "test", - "route": "/events/pubsub/test", - "metadata": {"rawPayload": "true"}, + 'pubsubname': 'pubsub', + 'topic': 'test', + 'route': '/events/pubsub/test', + 'metadata': {'rawPayload': 'true'}, } ], response.json(), ) - response = self.client.post("/events/pubsub/test", json={"body": "new message"}) + response = self.client.post('/events/pubsub/test', json={'body': 'new message'}) self.assertEqual(response.status_code, 200) self.assertEqual(response.text, '"custom metadata"') @@ -93,64 +93,64 @@ def test_router_tag(self): app1 = FastAPI() app2 = FastAPI() app3 = FastAPI() - DaprApp(app_instance=app1, router_tags=["MyTag", "PubSub"]).subscribe( - pubsub="mypubsub", topic="test" + DaprApp(app_instance=app1, router_tags=['MyTag', 'PubSub']).subscribe( + pubsub='mypubsub', topic='test' ) - DaprApp(app_instance=app2).subscribe(pubsub="mypubsub", topic="test") - DaprApp(app_instance=app3, router_tags=None).subscribe(pubsub="mypubsub", topic="test") + DaprApp(app_instance=app2).subscribe(pubsub='mypubsub', topic='test') + DaprApp(app_instance=app3, router_tags=None).subscribe(pubsub='mypubsub', topic='test') - PATHS_WITH_EXPECTED_TAGS = ["/dapr/subscribe", "/events/mypubsub/test"] + PATHS_WITH_EXPECTED_TAGS = ['/dapr/subscribe', '/events/mypubsub/test'] foundTags = False for route in app1.router.routes: - if hasattr(route, "tags"): + if hasattr(route, 'tags'): self.assertIn(route.path, PATHS_WITH_EXPECTED_TAGS) - self.assertEqual(["MyTag", "PubSub"], route.tags) + self.assertEqual(['MyTag', 'PubSub'], route.tags) foundTags = True if not foundTags: - self.fail("No tags found") + self.fail('No tags found') foundTags = False for route in app2.router.routes: - if hasattr(route, "tags"): + if hasattr(route, 'tags'): self.assertIn(route.path, PATHS_WITH_EXPECTED_TAGS) - self.assertEqual(["PubSub"], route.tags) + self.assertEqual(['PubSub'], route.tags) foundTags = True if not foundTags: - self.fail("No tags found") + self.fail('No tags found') for route in app3.router.routes: - if hasattr(route, "tags"): + if hasattr(route, 'tags'): if len(route.tags) > 0: - self.fail("Found tags on route that should not have any") + self.fail('Found tags on route that should not have any') def test_subscribe_dead_letter(self): - dead_letter_topic = "dead-test" + dead_letter_topic = 'dead-test' - @self.dapr_app.subscribe(pubsub="pubsub", topic="test", dead_letter_topic=dead_letter_topic) + @self.dapr_app.subscribe(pubsub='pubsub', topic='test', dead_letter_topic=dead_letter_topic) def event_handler(event_data: Message): - return "dead letter test" + return 'dead letter test' - self.assertEqual((self.dapr_app._subscriptions[0]["deadLetterTopic"]), dead_letter_topic) + self.assertEqual((self.dapr_app._subscriptions[0]['deadLetterTopic']), dead_letter_topic) - response = self.client.get("/dapr/subscribe") + response = self.client.get('/dapr/subscribe') self.assertEqual( [ { - "pubsubname": "pubsub", - "topic": "test", - "route": "/events/pubsub/test", - "metadata": {}, - "deadLetterTopic": dead_letter_topic, + 'pubsubname': 'pubsub', + 'topic': 'test', + 'route': '/events/pubsub/test', + 'metadata': {}, + 'deadLetterTopic': dead_letter_topic, } ], response.json(), ) - response = self.client.post("/events/pubsub/test", json={"body": "new message"}) + response = self.client.post('/events/pubsub/test', json={'body': 'new message'}) self.assertEqual(response.status_code, 200) self.assertEqual(response.text, '"dead letter test"') -if __name__ == "__main__": +if __name__ == '__main__': unittest.main() diff --git a/ext/dapr-ext-fastapi/tests/test_dapractor.py b/ext/dapr-ext-fastapi/tests/test_dapractor.py index 42b77274..ee863d72 100644 --- a/ext/dapr-ext-fastapi/tests/test_dapractor.py +++ b/ext/dapr-ext-fastapi/tests/test_dapractor.py @@ -23,23 +23,23 @@ class DaprActorTest(unittest.TestCase): def test_wrap_response_str(self): - r = _wrap_response(200, "fake_message") - self.assertEqual({"message": "fake_message"}, json.loads(r.body)) + r = _wrap_response(200, 'fake_message') + self.assertEqual({'message': 'fake_message'}, json.loads(r.body)) self.assertEqual(200, r.status_code) def test_wrap_response_str_err(self): - r = _wrap_response(400, "fake_message", "ERR_FAKE") - self.assertEqual({"message": "fake_message", "errorCode": "ERR_FAKE"}, json.loads(r.body)) + r = _wrap_response(400, 'fake_message', 'ERR_FAKE') + self.assertEqual({'message': 'fake_message', 'errorCode': 'ERR_FAKE'}, json.loads(r.body)) self.assertEqual(400, r.status_code) def test_wrap_response_bytes_text(self): - r = _wrap_response(200, b"fake_bytes_message", content_type="text/plain") - self.assertEqual(b"fake_bytes_message", r.body) + r = _wrap_response(200, b'fake_bytes_message', content_type='text/plain') + self.assertEqual(b'fake_bytes_message', r.body) self.assertEqual(200, r.status_code) - self.assertEqual("text/plain", r.media_type) + self.assertEqual('text/plain', r.media_type) def test_wrap_response_obj(self): - fake_data = {"message": "ok"} + fake_data = {'message': 'ok'} r = _wrap_response(200, fake_data) self.assertEqual(fake_data, json.loads(r.body)) self.assertEqual(200, r.status_code) @@ -48,42 +48,42 @@ def test_router_tag(self): app1 = FastAPI() app2 = FastAPI() app3 = FastAPI() - DaprActor(app=app1, router_tags=["MyTag", "Actor"]) + DaprActor(app=app1, router_tags=['MyTag', 'Actor']) DaprActor(app=app2) DaprActor(app=app3, router_tags=None) PATHS_WITH_EXPECTED_TAGS = [ - "/healthz", - "/dapr/config", - "/actors/{actor_type_name}/{actor_id}", - "/actors/{actor_type_name}/{actor_id}/method/{method_name}", - "/actors/{actor_type_name}/{actor_id}/method/timer/{timer_name}", - "/actors/{actor_type_name}/{actor_id}/method/remind/{reminder_name}", + '/healthz', + '/dapr/config', + '/actors/{actor_type_name}/{actor_id}', + '/actors/{actor_type_name}/{actor_id}/method/{method_name}', + '/actors/{actor_type_name}/{actor_id}/method/timer/{timer_name}', + '/actors/{actor_type_name}/{actor_id}/method/remind/{reminder_name}', ] foundTags = False for route in app1.router.routes: - if hasattr(route, "tags"): + if hasattr(route, 'tags'): self.assertIn(route.path, PATHS_WITH_EXPECTED_TAGS) - self.assertEqual(["MyTag", "Actor"], route.tags) + self.assertEqual(['MyTag', 'Actor'], route.tags) foundTags = True if not foundTags: - self.fail("No tags found") + self.fail('No tags found') foundTags = False for route in app2.router.routes: - if hasattr(route, "tags"): + if hasattr(route, 'tags'): self.assertIn(route.path, PATHS_WITH_EXPECTED_TAGS) - self.assertEqual(["Actor"], route.tags) + self.assertEqual(['Actor'], route.tags) foundTags = True if not foundTags: - self.fail("No tags found") + self.fail('No tags found') for route in app3.router.routes: - if hasattr(route, "tags"): + if hasattr(route, 'tags'): if len(route.tags) > 0: - self.fail("Found tags on route that should not have any") + self.fail('Found tags on route that should not have any') -if __name__ == "__main__": +if __name__ == '__main__': unittest.main() diff --git a/ext/dapr-ext-grpc/dapr/ext/grpc/__init__.py b/ext/dapr-ext-grpc/dapr/ext/grpc/__init__.py index a030859c..3a843ea9 100644 --- a/ext/dapr-ext-grpc/dapr/ext/grpc/__init__.py +++ b/ext/dapr-ext-grpc/dapr/ext/grpc/__init__.py @@ -20,10 +20,10 @@ __all__ = [ - "App", - "Rule", - "InvokeMethodRequest", - "InvokeMethodResponse", - "BindingRequest", - "TopicEventResponse", + 'App', + 'Rule', + 'InvokeMethodRequest', + 'InvokeMethodResponse', + 'BindingRequest', + 'TopicEventResponse', ] diff --git a/ext/dapr-ext-grpc/dapr/ext/grpc/_servicier.py b/ext/dapr-ext-grpc/dapr/ext/grpc/_servicier.py index 19833113..2217d50f 100644 --- a/ext/dapr-ext-grpc/dapr/ext/grpc/_servicier.py +++ b/ext/dapr-ext-grpc/dapr/ext/grpc/_servicier.py @@ -32,7 +32,7 @@ TopicSubscribeCallable = Callable[[v1.Event], Optional[TopicEventResponse]] BindingCallable = Callable[[BindingRequest], None] -DELIMITER = ":" +DELIMITER = ':' class Rule: @@ -73,7 +73,7 @@ def __init__(self): def register_method(self, method: str, cb: InvokeMethodCallable) -> None: """Registers method for service invocation.""" if method in self._invoke_method_map: - raise ValueError(f"{method} is already registered") + raise ValueError(f'{method} is already registered') self._invoke_method_map[method] = cb def register_topic( @@ -93,10 +93,10 @@ def register_topic( topic_key = pubsub_name pubsub_topic = topic_key + DELIMITER if rule is not None: - path = getattr(cb, "__name__", rule.match) + path = getattr(cb, '__name__', rule.match) pubsub_topic = pubsub_topic + path if pubsub_topic in self._topic_map: - raise ValueError(f"{topic} is already registered with {pubsub_name}") + raise ValueError(f'{topic} is already registered with {pubsub_name}') self._topic_map[pubsub_topic] = cb registered_topic = self._registered_topics_map.get(topic_key) @@ -119,7 +119,7 @@ def register_topic( rules = registered_topic.rules if rule: - path = getattr(cb, "__name__", rule.match) + path = getattr(cb, '__name__', rule.match) rules.append((rule.priority, appcallback_v1.TopicRule(match=rule.match, path=path))) rules.sort(key=lambda x: x[0]) rs = [rule for id, rule in rules] @@ -129,7 +129,7 @@ def register_topic( def register_binding(self, name: str, cb: BindingCallable) -> None: """Registers input bindings.""" if name in self._binding_map: - raise ValueError(f"{name} is already registered") + raise ValueError(f'{name} is already registered') self._binding_map[name] = cb self._registered_bindings.append(name) @@ -137,7 +137,7 @@ def OnInvoke(self, request: InvokeRequest, context): """Invokes service method with InvokeRequest.""" if request.method not in self._invoke_method_map: context.set_code(grpc.StatusCode.UNIMPLEMENTED) # type: ignore - raise NotImplementedError(f"{request.method} method not implemented!") + raise NotImplementedError(f'{request.method} method not implemented!') req = InvokeMethodRequest(request.data, request.content_type) req.metadata = context.invocation_metadata() @@ -156,13 +156,13 @@ def OnInvoke(self, request: InvokeRequest, context): resp_data = resp else: context.set_code(grpc.StatusCode.OUT_OF_RANGE) - context.set_details(f"{type(resp)} is the invalid return type.") - raise NotImplementedError(f"{request.method} method not implemented!") + context.set_details(f'{type(resp)} is the invalid return type.') + raise NotImplementedError(f'{request.method} method not implemented!') if len(resp_data.get_headers()) > 0: context.send_initial_metadata(resp_data.get_headers()) - content_type = "" + content_type = '' if resp_data.content_type: content_type = resp_data.content_type @@ -182,14 +182,14 @@ def OnTopicEvent(self, request: TopicEventRequest, context): pubsub_topic = no_validation_key else: context.set_code(grpc.StatusCode.UNIMPLEMENTED) # type: ignore - raise NotImplementedError(f"topic {request.topic} is not implemented!") + raise NotImplementedError(f'topic {request.topic} is not implemented!') customdata: Struct = request.extensions extensions = dict() for k, v in customdata.items(): extensions[k] = v for k, v in context.invocation_metadata(): - extensions["_metadata_" + k] = v + extensions['_metadata_' + k] = v event = v1.Event() event.SetEventType(request.type) @@ -216,7 +216,7 @@ def OnBindingEvent(self, request: BindingEventRequest, context): """ if request.name not in self._binding_map: context.set_code(grpc.StatusCode.UNIMPLEMENTED) # type: ignore - raise NotImplementedError(f"{request.name} binding not implemented!") + raise NotImplementedError(f'{request.name} binding not implemented!') req = BindingRequest(request.data, dict(request.metadata)) req.metadata = context.invocation_metadata() diff --git a/ext/dapr-ext-grpc/dapr/ext/grpc/app.py b/ext/dapr-ext-grpc/dapr/ext/grpc/app.py index 7eba8a09..b08421d7 100644 --- a/ext/dapr-ext-grpc/dapr/ext/grpc/app.py +++ b/ext/dapr-ext-grpc/dapr/ext/grpc/app.py @@ -47,8 +47,8 @@ def __init__(self, max_grpc_message_length: Optional[int] = None, **kwargs): options = [] if max_grpc_message_length is not None: options = [ - ("grpc.max_send_message_length", max_grpc_message_length), - ("grpc.max_receive_message_length", max_grpc_message_length), + ('grpc.max_send_message_length', max_grpc_message_length), + ('grpc.max_receive_message_length', max_grpc_message_length), ] self._server = grpc.server( # type: ignore futures.ThreadPoolExecutor(max_workers=10), options=options diff --git a/ext/dapr-ext-grpc/dapr/ext/grpc/version.py b/ext/dapr-ext-grpc/dapr/ext/grpc/version.py index 3bd3df76..2fea8188 100644 --- a/ext/dapr-ext-grpc/dapr/ext/grpc/version.py +++ b/ext/dapr-ext-grpc/dapr/ext/grpc/version.py @@ -13,4 +13,4 @@ limitations under the License. """ -__version__ = "1.11.0rc1.dev" +__version__ = '1.11.0rc1.dev' diff --git a/ext/dapr-ext-grpc/setup.py b/ext/dapr-ext-grpc/setup.py index 4c269596..67d282b6 100644 --- a/ext/dapr-ext-grpc/setup.py +++ b/ext/dapr-ext-grpc/setup.py @@ -19,18 +19,18 @@ # Load version in dapr package. version_info = {} -with open("dapr/ext/grpc/version.py") as fp: +with open('dapr/ext/grpc/version.py') as fp: exec(fp.read(), version_info) -__version__ = version_info["__version__"] +__version__ = version_info['__version__'] def is_release(): - return ".dev" not in __version__ + return '.dev' not in __version__ -name = "dapr-ext-grpc" +name = 'dapr-ext-grpc' version = __version__ -description = "The official release of Dapr Python SDK gRPC Extension." +description = 'The official release of Dapr Python SDK gRPC Extension.' long_description = """ This is the gRPC extension for Dapr. @@ -45,15 +45,15 @@ def is_release(): """.lstrip() # Get build number from GITHUB_RUN_NUMBER environment variable -build_number = os.environ.get("GITHUB_RUN_NUMBER", "0") +build_number = os.environ.get('GITHUB_RUN_NUMBER', '0') if not is_release(): - name += "-dev" - version = f"{__version__}{build_number}" - description = "The developmental release for Dapr gRPC AppCallback." - long_description = "This is the developmental release for Dapr gRPC AppCallback." + name += '-dev' + version = f'{__version__}{build_number}' + description = 'The developmental release for Dapr gRPC AppCallback.' + long_description = 'This is the developmental release for Dapr gRPC AppCallback.' -print(f"package name: {name}, version: {version}", flush=True) +print(f'package name: {name}, version: {version}', flush=True) setup( diff --git a/ext/dapr-ext-grpc/tests/test_app.py b/ext/dapr-ext-grpc/tests/test_app.py index 6d62a448..a8b63b35 100644 --- a/ext/dapr-ext-grpc/tests/test_app.py +++ b/ext/dapr-ext-grpc/tests/test_app.py @@ -24,53 +24,53 @@ def setUp(self): self._app = App() def test_method_decorator(self): - @self._app.method("Method1") + @self._app.method('Method1') def method1(request: InvokeMethodRequest): pass - @self._app.method("Method2") + @self._app.method('Method2') def method2(request: InvokeMethodRequest): pass method_map = self._app._servicer._invoke_method_map - self.assertIn("AppTests.test_method_decorator..method1", str(method_map["Method1"])) - self.assertIn("AppTests.test_method_decorator..method2", str(method_map["Method2"])) + self.assertIn('AppTests.test_method_decorator..method1', str(method_map['Method1'])) + self.assertIn('AppTests.test_method_decorator..method2', str(method_map['Method2'])) def test_binding_decorator(self): - @self._app.binding("binding1") + @self._app.binding('binding1') def binding1(request: BindingRequest): pass binding_map = self._app._servicer._binding_map self.assertIn( - "AppTests.test_binding_decorator..binding1", str(binding_map["binding1"]) + 'AppTests.test_binding_decorator..binding1', str(binding_map['binding1']) ) def test_subscribe_decorator(self): - @self._app.subscribe(pubsub_name="pubsub", topic="topic") + @self._app.subscribe(pubsub_name='pubsub', topic='topic') def handle_default(event: v1.Event) -> None: pass @self._app.subscribe( - pubsub_name="pubsub", topic="topic", rule=Rule('event.type == "test"', 1) + pubsub_name='pubsub', topic='topic', rule=Rule('event.type == "test"', 1) ) def handle_test_event(event: v1.Event) -> None: pass - @self._app.subscribe(pubsub_name="pubsub", topic="topic2", dead_letter_topic="topic2_dead") + @self._app.subscribe(pubsub_name='pubsub', topic='topic2', dead_letter_topic='topic2_dead') def handle_dead_letter(event: v1.Event) -> None: pass subscription_map = self._app._servicer._topic_map self.assertIn( - "AppTests.test_subscribe_decorator..handle_default", - str(subscription_map["pubsub:topic:"]), + 'AppTests.test_subscribe_decorator..handle_default', + str(subscription_map['pubsub:topic:']), ) self.assertIn( - "AppTests.test_subscribe_decorator..handle_test_event", - str(subscription_map["pubsub:topic:handle_test_event"]), + 'AppTests.test_subscribe_decorator..handle_test_event', + str(subscription_map['pubsub:topic:handle_test_event']), ) self.assertIn( - "AppTests.test_subscribe_decorator..handle_dead_letter", - str(subscription_map["pubsub:topic2:"]), + 'AppTests.test_subscribe_decorator..handle_dead_letter', + str(subscription_map['pubsub:topic2:']), ) diff --git a/ext/dapr-ext-grpc/tests/test_servicier.py b/ext/dapr-ext-grpc/tests/test_servicier.py index 5fc623cd..4be179c7 100644 --- a/ext/dapr-ext-grpc/tests/test_servicier.py +++ b/ext/dapr-ext-grpc/tests/test_servicier.py @@ -35,8 +35,8 @@ def _on_invoke(self, method_name, method_cb): # fake context fake_context = MagicMock() fake_context.invocation_metadata.return_value = ( - ("key1", "value1"), - ("key2", "value1"), + ('key1', 'value1'), + ('key2', 'value1'), ) return self._servicier.OnInvoke( @@ -46,49 +46,49 @@ def _on_invoke(self, method_name, method_cb): def test_on_invoke_return_str(self): def method_cb(request: InvokeMethodRequest): - return "method_str_cb" + return 'method_str_cb' - resp = self._on_invoke("method_str", method_cb) + resp = self._on_invoke('method_str', method_cb) - self.assertEqual(b"method_str_cb", resp.data.value) + self.assertEqual(b'method_str_cb', resp.data.value) def test_on_invoke_return_bytes(self): def method_cb(request: InvokeMethodRequest): - return b"method_str_cb" + return b'method_str_cb' - resp = self._on_invoke("method_bytes", method_cb) + resp = self._on_invoke('method_bytes', method_cb) - self.assertEqual(b"method_str_cb", resp.data.value) + self.assertEqual(b'method_str_cb', resp.data.value) def test_on_invoke_return_proto(self): def method_cb(request: InvokeMethodRequest): - return common_v1.StateItem(key="fake_key") + return common_v1.StateItem(key='fake_key') - resp = self._on_invoke("method_proto", method_cb) + resp = self._on_invoke('method_proto', method_cb) state = common_v1.StateItem() resp.data.Unpack(state) - self.assertEqual("fake_key", state.key) + self.assertEqual('fake_key', state.key) def test_on_invoke_return_invoke_method_response(self): def method_cb(request: InvokeMethodRequest): return InvokeMethodResponse( - data="fake_data", - content_type="text/plain", + data='fake_data', + content_type='text/plain', ) - resp = self._on_invoke("method_resp", method_cb) + resp = self._on_invoke('method_resp', method_cb) - self.assertEqual(b"fake_data", resp.data.value) - self.assertEqual("text/plain", resp.content_type) + self.assertEqual(b'fake_data', resp.data.value) + self.assertEqual('text/plain', resp.content_type) def test_on_invoke_invalid_response(self): def method_cb(request: InvokeMethodRequest): return 1000 with self.assertRaises(NotImplementedError): - self._on_invoke("method_resp", method_cb) + self._on_invoke('method_resp', method_cb) class TopicSubscriptionTests(unittest.TestCase): @@ -97,54 +97,54 @@ def setUp(self): self._topic1_method = Mock() self._topic2_method = Mock() self._topic3_method = Mock() - self._topic3_method.return_value = TopicEventResponse("success") + self._topic3_method.return_value = TopicEventResponse('success') self._topic4_method = Mock() - self._servicier.register_topic("pubsub1", "topic1", self._topic1_method, {"session": "key"}) - self._servicier.register_topic("pubsub1", "topic3", self._topic3_method, {"session": "key"}) - self._servicier.register_topic("pubsub2", "topic2", self._topic2_method, {"session": "key"}) - self._servicier.register_topic("pubsub2", "topic3", self._topic3_method, {"session": "key"}) + self._servicier.register_topic('pubsub1', 'topic1', self._topic1_method, {'session': 'key'}) + self._servicier.register_topic('pubsub1', 'topic3', self._topic3_method, {'session': 'key'}) + self._servicier.register_topic('pubsub2', 'topic2', self._topic2_method, {'session': 'key'}) + self._servicier.register_topic('pubsub2', 'topic3', self._topic3_method, {'session': 'key'}) self._servicier.register_topic( - "pubsub3", - "topic4", + 'pubsub3', + 'topic4', self._topic4_method, - {"session": "key"}, + {'session': 'key'}, disable_topic_validation=True, ) # fake context self.fake_context = MagicMock() self.fake_context.invocation_metadata.return_value = ( - ("key1", "value1"), - ("key2", "value1"), + ('key1', 'value1'), + ('key2', 'value1'), ) def test_duplicated_topic(self): with self.assertRaises(ValueError): self._servicier.register_topic( - "pubsub1", "topic1", self._topic1_method, {"session": "key"} + 'pubsub1', 'topic1', self._topic1_method, {'session': 'key'} ) def test_list_topic_subscription(self): resp = self._servicier.ListTopicSubscriptions(None, None) - self.assertEqual("pubsub1", resp.subscriptions[0].pubsub_name) - self.assertEqual("topic1", resp.subscriptions[0].topic) - self.assertEqual({"session": "key"}, resp.subscriptions[0].metadata) - self.assertEqual("pubsub1", resp.subscriptions[1].pubsub_name) - self.assertEqual("topic3", resp.subscriptions[1].topic) - self.assertEqual({"session": "key"}, resp.subscriptions[1].metadata) - self.assertEqual("pubsub2", resp.subscriptions[2].pubsub_name) - self.assertEqual("topic2", resp.subscriptions[2].topic) - self.assertEqual({"session": "key"}, resp.subscriptions[2].metadata) - self.assertEqual("pubsub2", resp.subscriptions[3].pubsub_name) - self.assertEqual("topic3", resp.subscriptions[3].topic) - self.assertEqual({"session": "key"}, resp.subscriptions[3].metadata) - self.assertEqual("topic4", resp.subscriptions[4].topic) - self.assertEqual({"session": "key"}, resp.subscriptions[4].metadata) + self.assertEqual('pubsub1', resp.subscriptions[0].pubsub_name) + self.assertEqual('topic1', resp.subscriptions[0].topic) + self.assertEqual({'session': 'key'}, resp.subscriptions[0].metadata) + self.assertEqual('pubsub1', resp.subscriptions[1].pubsub_name) + self.assertEqual('topic3', resp.subscriptions[1].topic) + self.assertEqual({'session': 'key'}, resp.subscriptions[1].metadata) + self.assertEqual('pubsub2', resp.subscriptions[2].pubsub_name) + self.assertEqual('topic2', resp.subscriptions[2].topic) + self.assertEqual({'session': 'key'}, resp.subscriptions[2].metadata) + self.assertEqual('pubsub2', resp.subscriptions[3].pubsub_name) + self.assertEqual('topic3', resp.subscriptions[3].topic) + self.assertEqual({'session': 'key'}, resp.subscriptions[3].metadata) + self.assertEqual('topic4', resp.subscriptions[4].topic) + self.assertEqual({'session': 'key'}, resp.subscriptions[4].metadata) def test_topic_event(self): self._servicier.OnTopicEvent( - appcallback_v1.TopicEventRequest(pubsub_name="pubsub1", topic="topic1"), + appcallback_v1.TopicEventRequest(pubsub_name='pubsub1', topic='topic1'), self.fake_context, ) @@ -152,7 +152,7 @@ def test_topic_event(self): def test_topic3_event_called_once(self): self._servicier.OnTopicEvent( - appcallback_v1.TopicEventRequest(pubsub_name="pubsub1", topic="topic3"), + appcallback_v1.TopicEventRequest(pubsub_name='pubsub1', topic='topic3'), self.fake_context, ) @@ -160,7 +160,7 @@ def test_topic3_event_called_once(self): def test_topic3_event_response(self): response = self._servicier.OnTopicEvent( - appcallback_v1.TopicEventRequest(pubsub_name="pubsub1", topic="topic3"), + appcallback_v1.TopicEventRequest(pubsub_name='pubsub1', topic='topic3'), self.fake_context, ) self.assertIsInstance(response, appcallback_v1.TopicEventResponse) @@ -170,7 +170,7 @@ def test_topic3_event_response(self): def test_disable_topic_validation(self): self._servicier.OnTopicEvent( - appcallback_v1.TopicEventRequest(pubsub_name="pubsub3", topic="should_be_ignored"), + appcallback_v1.TopicEventRequest(pubsub_name='pubsub3', topic='should_be_ignored'), self.fake_context, ) @@ -179,7 +179,7 @@ def test_disable_topic_validation(self): def test_non_registered_topic(self): with self.assertRaises(NotImplementedError): self._servicier.OnTopicEvent( - appcallback_v1.TopicEventRequest(pubsub_name="pubsub1", topic="topic_non_existed"), + appcallback_v1.TopicEventRequest(pubsub_name='pubsub1', topic='topic_non_existed'), self.fake_context, ) @@ -190,28 +190,28 @@ def setUp(self): self._binding1_method = Mock() self._binding2_method = Mock() - self._servicier.register_binding("binding1", self._binding1_method) - self._servicier.register_binding("binding2", self._binding2_method) + self._servicier.register_binding('binding1', self._binding1_method) + self._servicier.register_binding('binding2', self._binding2_method) # fake context self.fake_context = MagicMock() self.fake_context.invocation_metadata.return_value = ( - ("key1", "value1"), - ("key2", "value1"), + ('key1', 'value1'), + ('key2', 'value1'), ) def test_duplicated_binding(self): with self.assertRaises(ValueError): - self._servicier.register_binding("binding1", self._binding1_method) + self._servicier.register_binding('binding1', self._binding1_method) def test_list_bindings(self): resp = self._servicier.ListInputBindings(None, None) - self.assertEqual("binding1", resp.bindings[0]) - self.assertEqual("binding2", resp.bindings[1]) + self.assertEqual('binding1', resp.bindings[0]) + self.assertEqual('binding2', resp.bindings[1]) def test_binding_event(self): self._servicier.OnBindingEvent( - appcallback_v1.BindingEventRequest(name="binding1"), + appcallback_v1.BindingEventRequest(name='binding1'), self.fake_context, ) @@ -220,10 +220,10 @@ def test_binding_event(self): def test_non_registered_binding(self): with self.assertRaises(NotImplementedError): self._servicier.OnBindingEvent( - appcallback_v1.BindingEventRequest(name="binding3"), + appcallback_v1.BindingEventRequest(name='binding3'), self.fake_context, ) -if __name__ == "__main__": +if __name__ == '__main__': unittest.main() diff --git a/ext/dapr-ext-grpc/tests/test_topic_event_response.py b/ext/dapr-ext-grpc/tests/test_topic_event_response.py index b93d4e38..ca004133 100644 --- a/ext/dapr-ext-grpc/tests/test_topic_event_response.py +++ b/ext/dapr-ext-grpc/tests/test_topic_event_response.py @@ -26,7 +26,7 @@ def test_topic_event_response_creation_from_enum(self): def test_topic_event_response_creation_fails(self): with self.assertRaises(KeyError): - TopicEventResponse("invalid") + TopicEventResponse('invalid') def test_topic_event_response_creation_from_str(self): for status in TopicEventResponseStatus: @@ -38,5 +38,5 @@ def test_topic_event_response_creation_fails_with_object(self): TopicEventResponse(None) -if __name__ == "__main__": +if __name__ == '__main__': unittest.main() diff --git a/ext/dapr-ext-workflow/dapr/ext/workflow/__init__.py b/ext/dapr-ext-workflow/dapr/ext/workflow/__init__.py index c45c8f2f..f7861511 100644 --- a/ext/dapr-ext-workflow/dapr/ext/workflow/__init__.py +++ b/ext/dapr-ext-workflow/dapr/ext/workflow/__init__.py @@ -22,14 +22,14 @@ from dapr.ext.workflow.retry_policy import RetryPolicy __all__ = [ - "WorkflowRuntime", - "DaprWorkflowClient", - "DaprWorkflowContext", - "WorkflowActivityContext", - "WorkflowState", - "WorkflowStatus", - "when_all", - "when_any", - "alternate_name", - "RetryPolicy", + 'WorkflowRuntime', + 'DaprWorkflowClient', + 'DaprWorkflowContext', + 'WorkflowActivityContext', + 'WorkflowState', + 'WorkflowStatus', + 'when_all', + 'when_any', + 'alternate_name', + 'RetryPolicy', ] diff --git a/ext/dapr-ext-workflow/dapr/ext/workflow/dapr_workflow_client.py b/ext/dapr-ext-workflow/dapr/ext/workflow/dapr_workflow_client.py index 3f86ebbd..62d422c6 100644 --- a/ext/dapr-ext-workflow/dapr/ext/workflow/dapr_workflow_client.py +++ b/ext/dapr-ext-workflow/dapr/ext/workflow/dapr_workflow_client.py @@ -29,9 +29,9 @@ from dapr.conf.helpers import GrpcEndpoint from dapr.ext.workflow.logger import LoggerOptions, Logger -T = TypeVar("T") -TInput = TypeVar("TInput") -TOutput = TypeVar("TOutput") +T = TypeVar('T') +TInput = TypeVar('TInput') +TOutput = TypeVar('TOutput') class DaprWorkflowClient: @@ -55,9 +55,9 @@ def __init__( try: uri = GrpcEndpoint(address) except ValueError as error: - raise DaprInternalError(f"{error}") from error + raise DaprInternalError(f'{error}') from error - self._logger = Logger("DaprWorkflowClient", logger_options) + self._logger = Logger('DaprWorkflowClient', logger_options) metadata = tuple() if settings.DAPR_API_TOKEN: @@ -94,9 +94,9 @@ def schedule_new_workflow( Returns: The ID of the scheduled workflow instance. """ - if hasattr(workflow, "_dapr_alternate_name"): + if hasattr(workflow, '_dapr_alternate_name'): return self.__obj.schedule_new_orchestration( - workflow.__dict__["_dapr_alternate_name"], + workflow.__dict__['_dapr_alternate_name'], input=input, instance_id=instance_id, start_at=start_at, diff --git a/ext/dapr-ext-workflow/dapr/ext/workflow/dapr_workflow_context.py b/ext/dapr-ext-workflow/dapr/ext/workflow/dapr_workflow_context.py index 11585b91..dbcccd64 100644 --- a/ext/dapr-ext-workflow/dapr/ext/workflow/dapr_workflow_context.py +++ b/ext/dapr-ext-workflow/dapr/ext/workflow/dapr_workflow_context.py @@ -23,9 +23,9 @@ from dapr.ext.workflow.logger import LoggerOptions, Logger from dapr.ext.workflow.retry_policy import RetryPolicy -T = TypeVar("T") -TInput = TypeVar("TInput") -TOutput = TypeVar("TOutput") +T = TypeVar('T') +TInput = TypeVar('TInput') +TOutput = TypeVar('TOutput') class DaprWorkflowContext(WorkflowContext): @@ -35,7 +35,7 @@ def __init__( self, ctx: task.OrchestrationContext, logger_options: Optional[LoggerOptions] = None ): self.__obj = ctx - self._logger = Logger("DaprWorkflowContext", logger_options) + self._logger = Logger('DaprWorkflowContext', logger_options) # provide proxy access to regular attributes of wrapped object def __getattr__(self, name): @@ -54,7 +54,7 @@ def is_replaying(self) -> bool: return self.__obj.is_replaying def create_timer(self, fire_at: Union[datetime, timedelta]) -> task.Task: - self._logger.debug(f"{self.instance_id}: Creating timer to fire at {fire_at} time") + self._logger.debug(f'{self.instance_id}: Creating timer to fire at {fire_at} time') return self.__obj.create_timer(fire_at) def call_activity( @@ -64,9 +64,9 @@ def call_activity( input: TInput = None, retry_policy: Optional[RetryPolicy] = None, ) -> task.Task[TOutput]: - self._logger.debug(f"{self.instance_id}: Creating activity {activity.__name__}") - if hasattr(activity, "_dapr_alternate_name"): - act = activity.__dict__["_dapr_alternate_name"] + self._logger.debug(f'{self.instance_id}: Creating activity {activity.__name__}') + if hasattr(activity, '_dapr_alternate_name'): + act = activity.__dict__['_dapr_alternate_name'] else: # this case should ideally never happen act = activity.__name__ @@ -82,7 +82,7 @@ def call_child_workflow( instance_id: Optional[str] = None, retry_policy: Optional[RetryPolicy] = None, ) -> task.Task[TOutput]: - self._logger.debug(f"{self.instance_id}: Creating child workflow {workflow.__name__}") + self._logger.debug(f'{self.instance_id}: Creating child workflow {workflow.__name__}') def wf(ctx: task.OrchestrationContext, inp: TInput): daprWfContext = DaprWorkflowContext(ctx, self._logger.get_options()) @@ -90,8 +90,8 @@ def wf(ctx: task.OrchestrationContext, inp: TInput): # copy workflow name so durabletask.worker can find the orchestrator in its registry - if hasattr(workflow, "_dapr_alternate_name"): - wf.__name__ = workflow.__dict__["_dapr_alternate_name"] + if hasattr(workflow, '_dapr_alternate_name'): + wf.__name__ = workflow.__dict__['_dapr_alternate_name'] else: # this case should ideally never happen wf.__name__ = workflow.__name__ @@ -102,11 +102,11 @@ def wf(ctx: task.OrchestrationContext, inp: TInput): ) def wait_for_external_event(self, name: str) -> task.Task: - self._logger.debug(f"{self.instance_id}: Waiting for external event {name}") + self._logger.debug(f'{self.instance_id}: Waiting for external event {name}') return self.__obj.wait_for_external_event(name) def continue_as_new(self, new_input: Any, *, save_events: bool = False) -> None: - self._logger.debug(f"{self.instance_id}: Continuing as new") + self._logger.debug(f'{self.instance_id}: Continuing as new') self.__obj.continue_as_new(new_input, save_events=save_events) diff --git a/ext/dapr-ext-workflow/dapr/ext/workflow/logger/__init__.py b/ext/dapr-ext-workflow/dapr/ext/workflow/logger/__init__.py index 08226c87..5583bde7 100644 --- a/ext/dapr-ext-workflow/dapr/ext/workflow/logger/__init__.py +++ b/ext/dapr-ext-workflow/dapr/ext/workflow/logger/__init__.py @@ -1,4 +1,4 @@ from dapr.ext.workflow.logger.options import LoggerOptions from dapr.ext.workflow.logger.logger import Logger -__all__ = ["LoggerOptions", "Logger"] +__all__ = ['LoggerOptions', 'Logger'] diff --git a/ext/dapr-ext-workflow/dapr/ext/workflow/logger/options.py b/ext/dapr-ext-workflow/dapr/ext/workflow/logger/options.py index abe88226..0be44c52 100644 --- a/ext/dapr-ext-workflow/dapr/ext/workflow/logger/options.py +++ b/ext/dapr-ext-workflow/dapr/ext/workflow/logger/options.py @@ -33,8 +33,8 @@ def __init__( # Set a default log formatter if none is provided if log_formatter is None: log_formatter = logging.Formatter( - fmt="%(asctime)s.%(msecs)03d %(name)s %(levelname)s: %(message)s", - datefmt="%Y-%m-%d %H:%M:%S", + fmt='%(asctime)s.%(msecs)03d %(name)s %(levelname)s: %(message)s', + datefmt='%Y-%m-%d %H:%M:%S', ) self.log_level = log_level self.log_handler = log_handler diff --git a/ext/dapr-ext-workflow/dapr/ext/workflow/retry_policy.py b/ext/dapr-ext-workflow/dapr/ext/workflow/retry_policy.py index b5c191a2..af1f5ea9 100644 --- a/ext/dapr-ext-workflow/dapr/ext/workflow/retry_policy.py +++ b/ext/dapr-ext-workflow/dapr/ext/workflow/retry_policy.py @@ -18,9 +18,9 @@ from durabletask import task -T = TypeVar("T") -TInput = TypeVar("TInput") -TOutput = TypeVar("TOutput") +T = TypeVar('T') +TInput = TypeVar('TInput') +TOutput = TypeVar('TOutput') class RetryPolicy: @@ -49,15 +49,15 @@ def __init__( """ # validate inputs if first_retry_interval < timedelta(seconds=0): - raise ValueError("first_retry_interval must be >= 0") + raise ValueError('first_retry_interval must be >= 0') if max_number_of_attempts < 1: - raise ValueError("max_number_of_attempts must be >= 1") + raise ValueError('max_number_of_attempts must be >= 1') if backoff_coefficient is not None and backoff_coefficient < 1: - raise ValueError("backoff_coefficient must be >= 1") + raise ValueError('backoff_coefficient must be >= 1') if max_retry_interval is not None and max_retry_interval < timedelta(seconds=0): - raise ValueError("max_retry_interval must be >= 0") + raise ValueError('max_retry_interval must be >= 0') if retry_timeout is not None and retry_timeout < timedelta(seconds=0): - raise ValueError("retry_timeout must be >= 0") + raise ValueError('retry_timeout must be >= 0') self._obj = task.RetryPolicy( first_retry_interval=first_retry_interval, diff --git a/ext/dapr-ext-workflow/dapr/ext/workflow/util.py b/ext/dapr-ext-workflow/dapr/ext/workflow/util.py index b35e3a57..648bc973 100644 --- a/ext/dapr-ext-workflow/dapr/ext/workflow/util.py +++ b/ext/dapr-ext-workflow/dapr/ext/workflow/util.py @@ -21,11 +21,11 @@ def getAddress(host: Optional[str] = None, port: Optional[str] = None) -> str: if not host and not port: address = settings.DAPR_GRPC_ENDPOINT or ( - f"{settings.DAPR_RUNTIME_HOST}:" f"{settings.DAPR_GRPC_PORT}" + f'{settings.DAPR_RUNTIME_HOST}:' f'{settings.DAPR_GRPC_PORT}' ) else: host = host or settings.DAPR_RUNTIME_HOST port = port or settings.DAPR_GRPC_PORT - address = f"{host}:{port}" + address = f'{host}:{port}' return address diff --git a/ext/dapr-ext-workflow/dapr/ext/workflow/version.py b/ext/dapr-ext-workflow/dapr/ext/workflow/version.py index 922d5535..7046b9d2 100644 --- a/ext/dapr-ext-workflow/dapr/ext/workflow/version.py +++ b/ext/dapr-ext-workflow/dapr/ext/workflow/version.py @@ -13,4 +13,4 @@ limitations under the License. """ -__version__ = "0.2.0rc1.dev" +__version__ = '0.2.0rc1.dev' diff --git a/ext/dapr-ext-workflow/dapr/ext/workflow/workflow_activity_context.py b/ext/dapr-ext-workflow/dapr/ext/workflow/workflow_activity_context.py index 667ed345..f460e801 100644 --- a/ext/dapr-ext-workflow/dapr/ext/workflow/workflow_activity_context.py +++ b/ext/dapr-ext-workflow/dapr/ext/workflow/workflow_activity_context.py @@ -18,9 +18,9 @@ from durabletask import task -T = TypeVar("T") -TInput = TypeVar("TInput") -TOutput = TypeVar("TOutput") +T = TypeVar('T') +TInput = TypeVar('TInput') +TOutput = TypeVar('TOutput') class WorkflowActivityContext: diff --git a/ext/dapr-ext-workflow/dapr/ext/workflow/workflow_context.py b/ext/dapr-ext-workflow/dapr/ext/workflow/workflow_context.py index 92b6cc85..e0e3c736 100644 --- a/ext/dapr-ext-workflow/dapr/ext/workflow/workflow_context.py +++ b/ext/dapr-ext-workflow/dapr/ext/workflow/workflow_context.py @@ -22,9 +22,9 @@ from dapr.ext.workflow.workflow_activity_context import Activity -T = TypeVar("T") -TInput = TypeVar("TInput") -TOutput = TypeVar("TOutput") +T = TypeVar('T') +TInput = TypeVar('TInput') +TOutput = TypeVar('TOutput') class WorkflowContext(ABC): diff --git a/ext/dapr-ext-workflow/dapr/ext/workflow/workflow_runtime.py b/ext/dapr-ext-workflow/dapr/ext/workflow/workflow_runtime.py index cc228c8e..d1f02b35 100644 --- a/ext/dapr-ext-workflow/dapr/ext/workflow/workflow_runtime.py +++ b/ext/dapr-ext-workflow/dapr/ext/workflow/workflow_runtime.py @@ -30,9 +30,9 @@ from dapr.conf.helpers import GrpcEndpoint from dapr.ext.workflow.logger import LoggerOptions, Logger -T = TypeVar("T") -TInput = TypeVar("TInput") -TOutput = TypeVar("TOutput") +T = TypeVar('T') +TInput = TypeVar('TInput') +TOutput = TypeVar('TOutput') class WorkflowRuntime: @@ -44,7 +44,7 @@ def __init__( port: Optional[str] = None, logger_options: Optional[LoggerOptions] = None, ): - self._logger = Logger("WorkflowRuntime", logger_options) + self._logger = Logger('WorkflowRuntime', logger_options) metadata = tuple() if settings.DAPR_API_TOKEN: metadata = ((DAPR_API_TOKEN_HEADER, settings.DAPR_API_TOKEN),) @@ -53,7 +53,7 @@ def __init__( try: uri = GrpcEndpoint(address) except ValueError as error: - raise DaprInternalError(f"{error}") from error + raise DaprInternalError(f'{error}') from error options = self._logger.get_options() self.__worker = worker.TaskHubGrpcWorker( @@ -74,22 +74,22 @@ def orchestrationWrapper(ctx: task.OrchestrationContext, inp: Optional[TInput] = return fn(daprWfContext) return fn(daprWfContext, inp) - if hasattr(fn, "_workflow_registered"): + if hasattr(fn, '_workflow_registered'): # whenever a workflow is registered, it has a _dapr_alternate_name attribute - alt_name = fn.__dict__["_dapr_alternate_name"] - raise ValueError(f"Workflow {fn.__name__} already registered as {alt_name}") - if hasattr(fn, "_dapr_alternate_name"): + alt_name = fn.__dict__['_dapr_alternate_name'] + raise ValueError(f'Workflow {fn.__name__} already registered as {alt_name}') + if hasattr(fn, '_dapr_alternate_name'): alt_name = fn._dapr_alternate_name if name is not None: - m = f"Workflow {fn.__name__} already has an alternate name {alt_name}" + m = f'Workflow {fn.__name__} already has an alternate name {alt_name}' raise ValueError(m) else: - fn.__dict__["_dapr_alternate_name"] = name if name else fn.__name__ + fn.__dict__['_dapr_alternate_name'] = name if name else fn.__name__ self.__worker._registry.add_named_orchestrator( - fn.__dict__["_dapr_alternate_name"], orchestrationWrapper + fn.__dict__['_dapr_alternate_name'], orchestrationWrapper ) - fn.__dict__["_workflow_registered"] = True + fn.__dict__['_workflow_registered'] = True def register_activity(self, fn: Activity, *, name: Optional[str] = None): """Registers a workflow activity as a function that takes @@ -104,22 +104,22 @@ def activityWrapper(ctx: task.ActivityContext, inp: Optional[TInput] = None): return fn(wfActivityContext) return fn(wfActivityContext, inp) - if hasattr(fn, "_activity_registered"): + if hasattr(fn, '_activity_registered'): # whenever an activity is registered, it has a _dapr_alternate_name attribute - alt_name = fn.__dict__["_dapr_alternate_name"] - raise ValueError(f"Activity {fn.__name__} already registered as {alt_name}") - if hasattr(fn, "_dapr_alternate_name"): + alt_name = fn.__dict__['_dapr_alternate_name'] + raise ValueError(f'Activity {fn.__name__} already registered as {alt_name}') + if hasattr(fn, '_dapr_alternate_name'): alt_name = fn._dapr_alternate_name if name is not None: - m = f"Activity {fn.__name__} already has an alternate name {alt_name}" + m = f'Activity {fn.__name__} already has an alternate name {alt_name}' raise ValueError(m) else: - fn.__dict__["_dapr_alternate_name"] = name if name else fn.__name__ + fn.__dict__['_dapr_alternate_name'] = name if name else fn.__name__ self.__worker._registry.add_named_activity( - fn.__dict__["_dapr_alternate_name"], activityWrapper + fn.__dict__['_dapr_alternate_name'], activityWrapper ) - fn.__dict__["_activity_registered"] = True + fn.__dict__['_activity_registered'] = True def start(self): """Starts the listening for work items on a background thread.""" @@ -163,10 +163,10 @@ def wrapper(fn: Workflow): def innerfn(): return fn - if hasattr(fn, "_dapr_alternate_name"): - innerfn.__dict__["_dapr_alternate_name"] = fn.__dict__["_dapr_alternate_name"] + if hasattr(fn, '_dapr_alternate_name'): + innerfn.__dict__['_dapr_alternate_name'] = fn.__dict__['_dapr_alternate_name'] else: - innerfn.__dict__["_dapr_alternate_name"] = name if name else fn.__name__ + innerfn.__dict__['_dapr_alternate_name'] = name if name else fn.__name__ innerfn.__signature__ = inspect.signature(fn) return innerfn @@ -210,10 +210,10 @@ def wrapper(fn: Activity): def innerfn(): return fn - if hasattr(fn, "_dapr_alternate_name"): - innerfn.__dict__["_dapr_alternate_name"] = fn.__dict__["_dapr_alternate_name"] + if hasattr(fn, '_dapr_alternate_name'): + innerfn.__dict__['_dapr_alternate_name'] = fn.__dict__['_dapr_alternate_name'] else: - innerfn.__dict__["_dapr_alternate_name"] = name if name else fn.__name__ + innerfn.__dict__['_dapr_alternate_name'] = name if name else fn.__name__ innerfn.__signature__ = inspect.signature(fn) return innerfn @@ -244,17 +244,17 @@ def add(ctx, x: int, y: int) -> int: """ def wrapper(fn: any): - if hasattr(fn, "_dapr_alternate_name"): + if hasattr(fn, '_dapr_alternate_name'): raise ValueError( - f"Function {fn.__name__} already has an alternate name {fn._dapr_alternate_name}" + f'Function {fn.__name__} already has an alternate name {fn._dapr_alternate_name}' ) - fn.__dict__["_dapr_alternate_name"] = name if name else fn.__name__ + fn.__dict__['_dapr_alternate_name'] = name if name else fn.__name__ @wraps(fn) def innerfn(*args, **kwargs): return fn(*args, **kwargs) - innerfn.__dict__["_dapr_alternate_name"] = name if name else fn.__name__ + innerfn.__dict__['_dapr_alternate_name'] = name if name else fn.__name__ innerfn.__signature__ = inspect.signature(fn) return innerfn diff --git a/ext/dapr-ext-workflow/dapr/ext/workflow/workflow_state.py b/ext/dapr-ext-workflow/dapr/ext/workflow/workflow_state.py index 0b45c1fb..d93a3c01 100644 --- a/ext/dapr-ext-workflow/dapr/ext/workflow/workflow_state.py +++ b/ext/dapr-ext-workflow/dapr/ext/workflow/workflow_state.py @@ -61,17 +61,17 @@ def __str__(self) -> str: def to_json(self): return { - "instance_id": self.__obj.instance_id, - "name": self.__obj.name, - "runtime_status": self.__obj.runtime_status.name, - "created_at": self.__obj.created_at, - "last_updated_at": self.__obj.last_updated_at, - "serialized_input": self.__obj.serialized_input, - "serialized_output": self.__obj.serialized_output, - "serialized_custom_status": self.__obj.serialized_custom_status, - "failure_details": { - "message": self.__obj.failure_details.message, - "error_type": self.__obj.failure_details.error_type, - "stack_trace": self.__obj.failure_details.stack_trace, + 'instance_id': self.__obj.instance_id, + 'name': self.__obj.name, + 'runtime_status': self.__obj.runtime_status.name, + 'created_at': self.__obj.created_at, + 'last_updated_at': self.__obj.last_updated_at, + 'serialized_input': self.__obj.serialized_input, + 'serialized_output': self.__obj.serialized_output, + 'serialized_custom_status': self.__obj.serialized_custom_status, + 'failure_details': { + 'message': self.__obj.failure_details.message, + 'error_type': self.__obj.failure_details.error_type, + 'stack_trace': self.__obj.failure_details.stack_trace, }, } diff --git a/ext/dapr-ext-workflow/setup.py b/ext/dapr-ext-workflow/setup.py index 26043a7d..e66837f7 100644 --- a/ext/dapr-ext-workflow/setup.py +++ b/ext/dapr-ext-workflow/setup.py @@ -19,18 +19,18 @@ # Load version in dapr package. version_info = {} -with open("dapr/ext/workflow/version.py") as fp: +with open('dapr/ext/workflow/version.py') as fp: exec(fp.read(), version_info) -__version__ = version_info["__version__"] +__version__ = version_info['__version__'] def is_release(): - return ".dev" not in __version__ + return '.dev' not in __version__ -name = "dapr-ext-workflow" +name = 'dapr-ext-workflow' version = __version__ -description = "The official release of Dapr Python SDK Workflow Authoring Extension." +description = 'The official release of Dapr Python SDK Workflow Authoring Extension.' long_description = """ This is the Workflow authoring extension for Dapr. @@ -45,15 +45,15 @@ def is_release(): """.lstrip() # Get build number from GITHUB_RUN_NUMBER environment variable -build_number = os.environ.get("GITHUB_RUN_NUMBER", "0") +build_number = os.environ.get('GITHUB_RUN_NUMBER', '0') if not is_release(): - name += "-dev" - version = f"{__version__}{build_number}" - description = "The developmental release for Dapr Workflow Authoring." - long_description = "This is the developmental release for Dapr Workflow Authoring." + name += '-dev' + version = f'{__version__}{build_number}' + description = 'The developmental release for Dapr Workflow Authoring.' + long_description = 'This is the developmental release for Dapr Workflow Authoring.' -print(f"package name: {name}, version: {version}", flush=True) +print(f'package name: {name}, version: {version}', flush=True) setup( diff --git a/ext/dapr-ext-workflow/tests/test_dapr_workflow_context.py b/ext/dapr-ext-workflow/tests/test_dapr_workflow_context.py index 78762473..6b3c9ad3 100644 --- a/ext/dapr-ext-workflow/tests/test_dapr_workflow_context.py +++ b/ext/dapr-ext-workflow/tests/test_dapr_workflow_context.py @@ -21,10 +21,10 @@ from durabletask import worker mock_date_time = datetime(2023, 4, 27) -mock_instance_id = "instance001" -mock_create_timer = "create_timer" -mock_call_activity = "call_activity" -mock_call_sub_orchestrator = "call_sub_orchestrator" +mock_instance_id = 'instance001' +mock_create_timer = 'create_timer' +mock_call_activity = 'call_activity' +mock_call_sub_orchestrator = 'call_sub_orchestrator' class FakeOrchestrationContext: @@ -43,14 +43,14 @@ def call_sub_orchestrator(self, orchestrator, input, instance_id): class DaprWorkflowContextTest(unittest.TestCase): def mock_client_activity(ctx: WorkflowActivityContext, input): - print(f"{input}!", flush=True) + print(f'{input}!', flush=True) def mock_client_child_wf(ctx: DaprWorkflowContext, input): - print(f"{input}") + print(f'{input}') def test_workflow_context_functions(self): with mock.patch( - "durabletask.worker._RuntimeOrchestrationContext", + 'durabletask.worker._RuntimeOrchestrationContext', return_value=FakeOrchestrationContext(), ): fakeContext = worker._RuntimeOrchestrationContext(mock_instance_id) diff --git a/ext/dapr-ext-workflow/tests/test_workflow_activity_context.py b/ext/dapr-ext-workflow/tests/test_workflow_activity_context.py index 177f1ea5..a45b8b7c 100644 --- a/ext/dapr-ext-workflow/tests/test_workflow_activity_context.py +++ b/ext/dapr-ext-workflow/tests/test_workflow_activity_context.py @@ -18,7 +18,7 @@ from durabletask import task from dapr.ext.workflow.workflow_activity_context import WorkflowActivityContext -mock_orchestration_id = "orchestration001" +mock_orchestration_id = 'orchestration001' mock_task = 10 @@ -34,7 +34,7 @@ def task_id(self): class WorkflowActivityContextTest(unittest.TestCase): def test_workflow_activity_context(self): - with mock.patch("durabletask.task.ActivityContext", return_value=FakeActivityContext()): + with mock.patch('durabletask.task.ActivityContext', return_value=FakeActivityContext()): fake_act_ctx = task.ActivityContext( orchestration_id=mock_orchestration_id, task_id=mock_task ) diff --git a/ext/dapr-ext-workflow/tests/test_workflow_client.py b/ext/dapr-ext-workflow/tests/test_workflow_client.py index 86b6f01b..4a7f93b9 100644 --- a/ext/dapr-ext-workflow/tests/test_workflow_client.py +++ b/ext/dapr-ext-workflow/tests/test_workflow_client.py @@ -21,12 +21,12 @@ from dapr.ext.workflow.dapr_workflow_client import DaprWorkflowClient from durabletask import client -mock_schedule_result = "workflow001" -mock_raise_event_result = "event001" -mock_terminate_result = "terminate001" -mock_suspend_result = "suspend001" -mock_resume_result = "resume001" -mockInstanceId = "instance001" +mock_schedule_result = 'workflow001' +mock_raise_event_result = 'event001' +mock_terminate_result = 'terminate001' +mock_suspend_result = 'suspend001' +mock_resume_result = 'resume001' +mockInstanceId = 'instance001' class FakeTaskHubGrpcClient: @@ -61,7 +61,7 @@ def resume_orchestration(self, instance_id: str): def _inner_get_orchestration_state(self, instance_id, state: client.OrchestrationStatus): return client.OrchestrationState( instance_id=instance_id, - name="", + name='', runtime_status=state, created_at=datetime.now(), last_updated_at=datetime.now(), @@ -74,43 +74,43 @@ def _inner_get_orchestration_state(self, instance_id, state: client.Orchestratio class WorkflowClientTest(unittest.TestCase): def mock_client_wf(ctx: DaprWorkflowContext, input): - print(f"{input}") + print(f'{input}') def test_client_functions(self): with mock.patch( - "durabletask.client.TaskHubGrpcClient", return_value=FakeTaskHubGrpcClient() + 'durabletask.client.TaskHubGrpcClient', return_value=FakeTaskHubGrpcClient() ): wfClient = DaprWorkflowClient() actual_schedule_result = wfClient.schedule_new_workflow( - workflow=self.mock_client_wf, input="Hi Chef!" + workflow=self.mock_client_wf, input='Hi Chef!' ) assert actual_schedule_result == mock_schedule_result actual_get_result = wfClient.get_workflow_state( instance_id=mockInstanceId, fetch_payloads=True ) - assert actual_get_result.runtime_status.name == "PENDING" + assert actual_get_result.runtime_status.name == 'PENDING' assert actual_get_result.instance_id == mockInstanceId actual_wait_start_result = wfClient.wait_for_workflow_start( instance_id=mockInstanceId, timeout_in_seconds=30 ) - assert actual_wait_start_result.runtime_status.name == "RUNNING" + assert actual_wait_start_result.runtime_status.name == 'RUNNING' assert actual_wait_start_result.instance_id == mockInstanceId actual_wait_completion_result = wfClient.wait_for_workflow_completion( instance_id=mockInstanceId, timeout_in_seconds=30 ) - assert actual_wait_completion_result.runtime_status.name == "COMPLETED" + assert actual_wait_completion_result.runtime_status.name == 'COMPLETED' assert actual_wait_completion_result.instance_id == mockInstanceId actual_raise_event_result = wfClient.raise_workflow_event( - instance_id=mockInstanceId, event_name="test_event", data="test_data" + instance_id=mockInstanceId, event_name='test_event', data='test_data' ) assert actual_raise_event_result == mock_raise_event_result actual_terminate_result = wfClient.terminate_workflow( - instance_id=mockInstanceId, output="test_output" + instance_id=mockInstanceId, output='test_output' ) assert actual_terminate_result == mock_terminate_result diff --git a/ext/dapr-ext-workflow/tests/test_workflow_runtime.py b/ext/dapr-ext-workflow/tests/test_workflow_runtime.py index 2310af36..02d6c6f3 100644 --- a/ext/dapr-ext-workflow/tests/test_workflow_runtime.py +++ b/ext/dapr-ext-workflow/tests/test_workflow_runtime.py @@ -36,28 +36,28 @@ class WorkflowRuntimeTest(unittest.TestCase): def setUp(self): listActivities.clear() listOrchestrators.clear() - mock.patch("durabletask.worker._Registry", return_value=FakeTaskHubGrpcWorker()).start() + mock.patch('durabletask.worker._Registry', return_value=FakeTaskHubGrpcWorker()).start() self.runtime_options = WorkflowRuntime() - if hasattr(self.mock_client_wf, "_dapr_alternate_name"): - del self.mock_client_wf.__dict__["_dapr_alternate_name"] - if hasattr(self.mock_client_activity, "_dapr_alternate_name"): - del self.mock_client_activity.__dict__["_dapr_alternate_name"] - if hasattr(self.mock_client_wf, "_workflow_registered"): - del self.mock_client_wf.__dict__["_workflow_registered"] - if hasattr(self.mock_client_activity, "_activity_registered"): - del self.mock_client_activity.__dict__["_activity_registered"] + if hasattr(self.mock_client_wf, '_dapr_alternate_name'): + del self.mock_client_wf.__dict__['_dapr_alternate_name'] + if hasattr(self.mock_client_activity, '_dapr_alternate_name'): + del self.mock_client_activity.__dict__['_dapr_alternate_name'] + if hasattr(self.mock_client_wf, '_workflow_registered'): + del self.mock_client_wf.__dict__['_workflow_registered'] + if hasattr(self.mock_client_activity, '_activity_registered'): + del self.mock_client_activity.__dict__['_activity_registered'] def mock_client_wf(ctx: DaprWorkflowContext, input): - print(f"{input}") + print(f'{input}') def mock_client_activity(ctx: WorkflowActivityContext, input): - print(f"{input}!", flush=True) + print(f'{input}!', flush=True) def test_register(self): - self.runtime_options.register_workflow(self.mock_client_wf, name="mock_client_wf") + self.runtime_options.register_workflow(self.mock_client_wf, name='mock_client_wf') wanted_orchestrator = [self.mock_client_wf.__name__] assert listOrchestrators == wanted_orchestrator - assert self.mock_client_wf._dapr_alternate_name == "mock_client_wf" + assert self.mock_client_wf._dapr_alternate_name == 'mock_client_wf' assert self.mock_client_wf._workflow_registered self.runtime_options.register_activity(self.mock_client_activity) @@ -79,94 +79,94 @@ def test_decorator_register(self): assert self.mock_client_activity._activity_registered def test_both_decorator_and_register(self): - client_wf = (self.runtime_options.workflow(name="test_wf"))(self.mock_client_wf) - wanted_orchestrator = ["test_wf"] + client_wf = (self.runtime_options.workflow(name='test_wf'))(self.mock_client_wf) + wanted_orchestrator = ['test_wf'] assert listOrchestrators == wanted_orchestrator - assert client_wf._dapr_alternate_name == "test_wf" + assert client_wf._dapr_alternate_name == 'test_wf' assert self.mock_client_wf._workflow_registered - self.runtime_options.register_activity(self.mock_client_activity, name="test_act") - wanted_activity = ["test_act"] + self.runtime_options.register_activity(self.mock_client_activity, name='test_act') + wanted_activity = ['test_act'] assert listActivities == wanted_activity - assert hasattr(self.mock_client_activity, "_dapr_alternate_name") + assert hasattr(self.mock_client_activity, '_dapr_alternate_name') assert self.mock_client_activity._activity_registered def test_register_wf_act_using_both_decorator_and_method(self): - client_wf = (self.runtime_options.workflow(name="test_wf"))(self.mock_client_wf) + client_wf = (self.runtime_options.workflow(name='test_wf'))(self.mock_client_wf) - wanted_orchestrator = ["test_wf"] + wanted_orchestrator = ['test_wf'] assert listOrchestrators == wanted_orchestrator - assert client_wf._dapr_alternate_name == "test_wf" + assert client_wf._dapr_alternate_name == 'test_wf' with self.assertRaises(ValueError) as exeception_context: self.runtime_options.register_workflow(self.mock_client_wf) wf_name = self.mock_client_wf.__name__ self.assertEqual( exeception_context.exception.args[0], - f"Workflow {wf_name} already registered as test_wf", + f'Workflow {wf_name} already registered as test_wf', ) - client_act = (self.runtime_options.activity(name="test_act"))(self.mock_client_activity) - wanted_activity = ["test_act"] + client_act = (self.runtime_options.activity(name='test_act'))(self.mock_client_activity) + wanted_activity = ['test_act'] assert listActivities == wanted_activity - assert client_act._dapr_alternate_name == "test_act" + assert client_act._dapr_alternate_name == 'test_act' with self.assertRaises(ValueError) as exeception_context: self.runtime_options.register_activity(self.mock_client_activity) act_name = self.mock_client_activity.__name__ self.assertEqual( exeception_context.exception.args[0], - f"Activity {act_name} already registered as test_act", + f'Activity {act_name} already registered as test_act', ) def test_duplicate_dapr_alternate_name_registration(self): - client_wf = (alternate_name(name="test"))(self.mock_client_wf) + client_wf = (alternate_name(name='test'))(self.mock_client_wf) with self.assertRaises(ValueError) as exeception_context: - (self.runtime_options.workflow(name="random"))(client_wf) + (self.runtime_options.workflow(name='random'))(client_wf) self.assertEqual( exeception_context.exception.args[0], - f"Workflow {client_wf.__name__} already has an alternate name test", + f'Workflow {client_wf.__name__} already has an alternate name test', ) - client_act = (alternate_name(name="test"))(self.mock_client_activity) + client_act = (alternate_name(name='test'))(self.mock_client_activity) with self.assertRaises(ValueError) as exeception_context: - (self.runtime_options.activity(name="random"))(client_act) + (self.runtime_options.activity(name='random'))(client_act) self.assertEqual( exeception_context.exception.args[0], - f"Activity {client_act.__name__} already has an alternate name test", + f'Activity {client_act.__name__} already has an alternate name test', ) def test_register_wf_act_using_both_decorator_and_method_without_name(self): client_wf = (self.runtime_options.workflow())(self.mock_client_wf) - wanted_orchestrator = ["mock_client_wf"] + wanted_orchestrator = ['mock_client_wf'] assert listOrchestrators == wanted_orchestrator - assert client_wf._dapr_alternate_name == "mock_client_wf" + assert client_wf._dapr_alternate_name == 'mock_client_wf' with self.assertRaises(ValueError) as exeception_context: - self.runtime_options.register_workflow(self.mock_client_wf, name="test_wf") + self.runtime_options.register_workflow(self.mock_client_wf, name='test_wf') wf_name = self.mock_client_wf.__name__ self.assertEqual( exeception_context.exception.args[0], - f"Workflow {wf_name} already registered as mock_client_wf", + f'Workflow {wf_name} already registered as mock_client_wf', ) client_act = (self.runtime_options.activity())(self.mock_client_activity) - wanted_activity = ["mock_client_activity"] + wanted_activity = ['mock_client_activity'] assert listActivities == wanted_activity - assert client_act._dapr_alternate_name == "mock_client_activity" + assert client_act._dapr_alternate_name == 'mock_client_activity' with self.assertRaises(ValueError) as exeception_context: - self.runtime_options.register_activity(self.mock_client_activity, name="test_act") + self.runtime_options.register_activity(self.mock_client_activity, name='test_act') act_name = self.mock_client_activity.__name__ self.assertEqual( exeception_context.exception.args[0], - f"Activity {act_name} already registered as mock_client_activity", + f'Activity {act_name} already registered as mock_client_activity', ) def test_decorator_register_optinal_name(self): - client_wf = (self.runtime_options.workflow(name="test_wf"))(self.mock_client_wf) - wanted_orchestrator = ["test_wf"] + client_wf = (self.runtime_options.workflow(name='test_wf'))(self.mock_client_wf) + wanted_orchestrator = ['test_wf'] assert listOrchestrators == wanted_orchestrator - assert client_wf._dapr_alternate_name == "test_wf" + assert client_wf._dapr_alternate_name == 'test_wf' - client_act = (self.runtime_options.activity(name="test_act"))(self.mock_client_activity) - wanted_activity = ["test_act"] + client_act = (self.runtime_options.activity(name='test_act'))(self.mock_client_activity) + wanted_activity = ['test_act'] assert listActivities == wanted_activity - assert client_act._dapr_alternate_name == "test_act" + assert client_act._dapr_alternate_name == 'test_act' diff --git a/ext/dapr-ext-workflow/tests/test_workflow_util.py b/ext/dapr-ext-workflow/tests/test_workflow_util.py index bcad9e81..878ee737 100644 --- a/ext/dapr-ext-workflow/tests/test_workflow_util.py +++ b/ext/dapr-ext-workflow/tests/test_workflow_util.py @@ -7,23 +7,23 @@ class DaprWorkflowUtilTest(unittest.TestCase): def test_get_address_default(self): - expected = f"{settings.DAPR_RUNTIME_HOST}:{settings.DAPR_GRPC_PORT}" + expected = f'{settings.DAPR_RUNTIME_HOST}:{settings.DAPR_GRPC_PORT}' self.assertEqual(expected, getAddress()) def test_get_address_with_constructor_arguments(self): - self.assertEqual("test.com:5000", getAddress("test.com", "5000")) + self.assertEqual('test.com:5000', getAddress('test.com', '5000')) def test_get_address_with_partial_constructor_arguments(self): - expected = f"{settings.DAPR_RUNTIME_HOST}:5000" - self.assertEqual(expected, getAddress(port="5000")) + expected = f'{settings.DAPR_RUNTIME_HOST}:5000' + self.assertEqual(expected, getAddress(port='5000')) - expected = f"test.com:{settings.DAPR_GRPC_PORT}" - self.assertEqual(expected, getAddress(host="test.com")) + expected = f'test.com:{settings.DAPR_GRPC_PORT}' + self.assertEqual(expected, getAddress(host='test.com')) - @patch.object(settings, "DAPR_GRPC_ENDPOINT", "https://domain1.com:5000") + @patch.object(settings, 'DAPR_GRPC_ENDPOINT', 'https://domain1.com:5000') def test_get_address_with_constructor_arguments_and_env_variable(self): - self.assertEqual("test.com:5000", getAddress("test.com", "5000")) + self.assertEqual('test.com:5000', getAddress('test.com', '5000')) - @patch.object(settings, "DAPR_GRPC_ENDPOINT", "https://domain1.com:5000") + @patch.object(settings, 'DAPR_GRPC_ENDPOINT', 'https://domain1.com:5000') def test_get_address_with_env_variable(self): - self.assertEqual("https://domain1.com:5000", getAddress()) + self.assertEqual('https://domain1.com:5000', getAddress()) diff --git a/ext/flask_dapr/flask_dapr/__init__.py b/ext/flask_dapr/flask_dapr/__init__.py index 4694e389..e43df65c 100644 --- a/ext/flask_dapr/flask_dapr/__init__.py +++ b/ext/flask_dapr/flask_dapr/__init__.py @@ -16,4 +16,4 @@ from .actor import DaprActor from .app import DaprApp -__all__ = ["DaprActor", "DaprApp"] +__all__ = ['DaprActor', 'DaprApp'] diff --git a/ext/flask_dapr/flask_dapr/actor.py b/ext/flask_dapr/flask_dapr/actor.py index effd5205..17a40636 100644 --- a/ext/flask_dapr/flask_dapr/actor.py +++ b/ext/flask_dapr/flask_dapr/actor.py @@ -22,8 +22,8 @@ from dapr.clients.exceptions import DaprInternalError, ERROR_CODE_UNKNOWN from dapr.serializers import DefaultJSONSerializer -DEFAULT_CONTENT_TYPE = "application/json; utf-8" -DAPR_REENTRANCY_ID_HEADER = "Dapr-Reentrancy-Id" +DEFAULT_CONTENT_TYPE = 'application/json; utf-8' +DAPR_REENTRANCY_ID_HEADER = 'Dapr-Reentrancy-Id' class DaprActor(object): @@ -35,42 +35,42 @@ def __init__(self, app=None): self.init_routes(app) def init_routes(self, app): - app.add_url_rule("/healthz", None, self._healthz_handler, methods=["GET"]) - app.add_url_rule("/dapr/config", None, self._config_handler, methods=["GET"]) + app.add_url_rule('/healthz', None, self._healthz_handler, methods=['GET']) + app.add_url_rule('/dapr/config', None, self._config_handler, methods=['GET']) app.add_url_rule( - "/actors//", + '/actors//', None, self._deactivation_handler, - methods=["DELETE"], + methods=['DELETE'], ) app.add_url_rule( - "/actors///method/", + '/actors///method/', None, self._method_handler, - methods=["PUT"], + methods=['PUT'], ) app.add_url_rule( - "/actors///method/timer/", + '/actors///method/timer/', None, self._timer_handler, - methods=["PUT"], + methods=['PUT'], ) app.add_url_rule( - "/actors///method/remind/", + '/actors///method/remind/', None, self._reminder_handler, - methods=["PUT"], + methods=['PUT'], ) def teardown(self, exception): - self._app.logger.debug("actor service is shutting down.") + self._app.logger.debug('actor service is shutting down.') def register_actor(self, actor: Type[Actor]) -> None: asyncio.run(ActorRuntime.register_actor(actor)) - self._app.logger.debug(f"registered actor: {actor.__class__.__name__}") + self._app.logger.debug(f'registered actor: {actor.__class__.__name__}') def _healthz_handler(self): - return wrap_response(200, "ok") + return wrap_response(200, 'ok') def _config_handler(self): serialized = self._dapr_serializer.serialize(ActorRuntime.get_actor_config()) @@ -84,7 +84,7 @@ def _deactivation_handler(self, actor_type_name, actor_id): except Exception as ex: return wrap_response(500, repr(ex), ERROR_CODE_UNKNOWN) - msg = f"deactivated actor: {actor_type_name}.{actor_id}" + msg = f'deactivated actor: {actor_type_name}.{actor_id}' self._app.logger.debug(msg) return wrap_response(200, msg) @@ -103,7 +103,7 @@ def _method_handler(self, actor_type_name, actor_id, method_name): except Exception as ex: return wrap_response(500, repr(ex), ERROR_CODE_UNKNOWN) - msg = f"called method. actor: {actor_type_name}.{actor_id}, method: {method_name}" + msg = f'called method. actor: {actor_type_name}.{actor_id}, method: {method_name}' self._app.logger.debug(msg) return wrap_response(200, result) @@ -117,7 +117,7 @@ def _timer_handler(self, actor_type_name, actor_id, timer_name): except Exception as ex: return wrap_response(500, repr(ex), ERROR_CODE_UNKNOWN) - msg = f"called timer. actor: {actor_type_name}.{actor_id}, timer: {timer_name}" + msg = f'called timer. actor: {actor_type_name}.{actor_id}, timer: {timer_name}' self._app.logger.debug(msg) return wrap_response(200, msg) @@ -133,7 +133,7 @@ def _reminder_handler(self, actor_type_name, actor_id, reminder_name): except Exception as ex: return wrap_response(500, repr(ex), ERROR_CODE_UNKNOWN) - msg = f"called reminder. actor: {actor_type_name}.{actor_id}, reminder: {reminder_name}" + msg = f'called reminder. actor: {actor_type_name}.{actor_id}, reminder: {reminder_name}' self._app.logger.debug(msg) return wrap_response(200, msg) @@ -145,14 +145,14 @@ def wrap_response( resp = None if isinstance(msg, str): response_obj = { - "message": msg, + 'message': msg, } if not (status >= 200 and status < 300) and error_code: - response_obj["errorCode"] = error_code + response_obj['errorCode'] = error_code resp = make_response(jsonify(response_obj), status) elif isinstance(msg, bytes): resp = make_response(msg, status) else: resp = make_response(jsonify(msg), status) - resp.headers["Content-type"] = content_type or DEFAULT_CONTENT_TYPE + resp.headers['Content-type'] = content_type or DEFAULT_CONTENT_TYPE return resp diff --git a/ext/flask_dapr/flask_dapr/app.py b/ext/flask_dapr/flask_dapr/app.py index b934d587..c8d5def9 100644 --- a/ext/flask_dapr/flask_dapr/app.py +++ b/ext/flask_dapr/flask_dapr/app.py @@ -30,7 +30,7 @@ def __init__(self, app_instance: Flask): self._subscriptions: List[Dict[str, object]] = [] self._app.add_url_rule( - "/dapr/subscribe", "/dapr/subscribe", self._get_subscriptions, methods=["GET"] + '/dapr/subscribe', '/dapr/subscribe', self._get_subscriptions, methods=['GET'] ) def subscribe( @@ -74,18 +74,18 @@ def subscribe( """ def decorator(func): - event_handler_route = f"/events/{pubsub}/{topic}" if route is None else route + event_handler_route = f'/events/{pubsub}/{topic}' if route is None else route - self._app.add_url_rule(event_handler_route, event_handler_route, func, methods=["POST"]) + self._app.add_url_rule(event_handler_route, event_handler_route, func, methods=['POST']) self._subscriptions.append( { - "pubsubname": pubsub, - "topic": topic, - "route": event_handler_route, - "metadata": metadata, + 'pubsubname': pubsub, + 'topic': topic, + 'route': event_handler_route, + 'metadata': metadata, **( - {"deadLetterTopic": dead_letter_topic} + {'deadLetterTopic': dead_letter_topic} if dead_letter_topic is not None else {} ), diff --git a/ext/flask_dapr/flask_dapr/version.py b/ext/flask_dapr/flask_dapr/version.py index 3bd3df76..2fea8188 100644 --- a/ext/flask_dapr/flask_dapr/version.py +++ b/ext/flask_dapr/flask_dapr/version.py @@ -13,4 +13,4 @@ limitations under the License. """ -__version__ = "1.11.0rc1.dev" +__version__ = '1.11.0rc1.dev' diff --git a/ext/flask_dapr/setup.py b/ext/flask_dapr/setup.py index 6785fc9c..d2aca057 100644 --- a/ext/flask_dapr/setup.py +++ b/ext/flask_dapr/setup.py @@ -19,18 +19,18 @@ # Load version in dapr package. version_info = {} -with open("flask_dapr/version.py") as fp: +with open('flask_dapr/version.py') as fp: exec(fp.read(), version_info) -__version__ = version_info["__version__"] +__version__ = version_info['__version__'] def is_release(): - return ".dev" not in __version__ + return '.dev' not in __version__ -name = "flask-dapr" +name = 'flask-dapr' version = __version__ -description = "The official release of Dapr Python SDK Flask Extension." +description = 'The official release of Dapr Python SDK Flask Extension.' long_description = """ This is the Flask extension for Dapr. @@ -45,15 +45,15 @@ def is_release(): """.lstrip() # Get build number from GITHUB_RUN_NUMBER environment variable -build_number = os.environ.get("GITHUB_RUN_NUMBER", "0") +build_number = os.environ.get('GITHUB_RUN_NUMBER', '0') if not is_release(): - name += "-dev" - version = f"{__version__}{build_number}" - description = "The developmental release for Dapr Python SDK Flask." - long_description = "This is the developmental release for Dapr Python SDK Flask." + name += '-dev' + version = f'{__version__}{build_number}' + description = 'The developmental release for Dapr Python SDK Flask.' + long_description = 'This is the developmental release for Dapr Python SDK Flask.' -print(f"package name: {name}, version: {version}", flush=True) +print(f'package name: {name}, version: {version}', flush=True) setup( diff --git a/ext/flask_dapr/tests/test_app.py b/ext/flask_dapr/tests/test_app.py index 7aeb19b7..8fb764a5 100644 --- a/ext/flask_dapr/tests/test_app.py +++ b/ext/flask_dapr/tests/test_app.py @@ -8,111 +8,111 @@ class DaprAppTest(unittest.TestCase): def setUp(self): - self.app = Flask("test_app") + self.app = Flask('test_app') self.app.testing = True self.dapr_app = DaprApp(self.app) self.client = self.app.test_client() def test_subscribe_subscription_registered(self): - @self.dapr_app.subscribe(pubsub="pubsub", topic="test") + @self.dapr_app.subscribe(pubsub='pubsub', topic='test') def event_handler(): - return "default route" + return 'default route' self.assertEqual(len(self.dapr_app._subscriptions), 1) - self.assertIn("/dapr/subscribe", [r.rule for r in self.app.url_map.iter_rules()]) - self.assertIn("/events/pubsub/test", [r.rule for r in self.app.url_map.iter_rules()]) + self.assertIn('/dapr/subscribe', [r.rule for r in self.app.url_map.iter_rules()]) + self.assertIn('/events/pubsub/test', [r.rule for r in self.app.url_map.iter_rules()]) - response = self.client.get("/dapr/subscribe") + response = self.client.get('/dapr/subscribe') self.assertEqual( [ { - "pubsubname": "pubsub", - "topic": "test", - "route": "/events/pubsub/test", - "metadata": {}, + 'pubsubname': 'pubsub', + 'topic': 'test', + 'route': '/events/pubsub/test', + 'metadata': {}, } ], json.loads(response.data), ) - response = self.client.post("/events/pubsub/test", json={"body": "new message"}) + response = self.client.post('/events/pubsub/test', json={'body': 'new message'}) self.assertEqual(response.status_code, 200) - self.assertEqual(response.data.decode("utf-8"), "default route") + self.assertEqual(response.data.decode('utf-8'), 'default route') def test_subscribe_with_route_subscription_registered_with_custom_route(self): - @self.dapr_app.subscribe(pubsub="pubsub", topic="test", route="/do-something") + @self.dapr_app.subscribe(pubsub='pubsub', topic='test', route='/do-something') def event_handler(): - return "custom route" + return 'custom route' self.assertEqual(len(self.dapr_app._subscriptions), 1) - self.assertIn("/dapr/subscribe", [r.rule for r in self.app.url_map.iter_rules()]) - self.assertIn("/do-something", [r.rule for r in self.app.url_map.iter_rules()]) + self.assertIn('/dapr/subscribe', [r.rule for r in self.app.url_map.iter_rules()]) + self.assertIn('/do-something', [r.rule for r in self.app.url_map.iter_rules()]) - response = self.client.get("/dapr/subscribe") + response = self.client.get('/dapr/subscribe') self.assertEqual( - [{"pubsubname": "pubsub", "topic": "test", "route": "/do-something", "metadata": {}}], + [{'pubsubname': 'pubsub', 'topic': 'test', 'route': '/do-something', 'metadata': {}}], json.loads(response.data), ) - response = self.client.post("/do-something", json={"body": "new message"}) + response = self.client.post('/do-something', json={'body': 'new message'}) self.assertEqual(response.status_code, 200) - self.assertEqual(response.data.decode("utf-8"), "custom route") + self.assertEqual(response.data.decode('utf-8'), 'custom route') def test_subscribe_metadata(self): - handler_metadata = {"rawPayload": "true"} + handler_metadata = {'rawPayload': 'true'} - @self.dapr_app.subscribe(pubsub="pubsub", topic="test", metadata=handler_metadata) + @self.dapr_app.subscribe(pubsub='pubsub', topic='test', metadata=handler_metadata) def event_handler(): - return "custom metadata" + return 'custom metadata' - self.assertEqual((self.dapr_app._subscriptions[0]["metadata"]["rawPayload"]), "true") + self.assertEqual((self.dapr_app._subscriptions[0]['metadata']['rawPayload']), 'true') - response = self.client.get("/dapr/subscribe") + response = self.client.get('/dapr/subscribe') self.assertEqual( [ { - "pubsubname": "pubsub", - "topic": "test", - "route": "/events/pubsub/test", - "metadata": {"rawPayload": "true"}, + 'pubsubname': 'pubsub', + 'topic': 'test', + 'route': '/events/pubsub/test', + 'metadata': {'rawPayload': 'true'}, } ], json.loads(response.data), ) - response = self.client.post("/events/pubsub/test", json={"body": "new message"}) + response = self.client.post('/events/pubsub/test', json={'body': 'new message'}) self.assertEqual(response.status_code, 200) - self.assertEqual(response.data.decode("utf-8"), "custom metadata") + self.assertEqual(response.data.decode('utf-8'), 'custom metadata') def test_subscribe_dead_letter(self): - dead_letter_topic = "dead-test" + dead_letter_topic = 'dead-test' - @self.dapr_app.subscribe(pubsub="pubsub", topic="test", dead_letter_topic=dead_letter_topic) + @self.dapr_app.subscribe(pubsub='pubsub', topic='test', dead_letter_topic=dead_letter_topic) def event_handler(): - return "dead letter test" + return 'dead letter test' - self.assertEqual((self.dapr_app._subscriptions[0]["deadLetterTopic"]), dead_letter_topic) + self.assertEqual((self.dapr_app._subscriptions[0]['deadLetterTopic']), dead_letter_topic) - response = self.client.get("/dapr/subscribe") + response = self.client.get('/dapr/subscribe') self.assertEqual( [ { - "pubsubname": "pubsub", - "topic": "test", - "route": "/events/pubsub/test", - "metadata": {}, - "deadLetterTopic": dead_letter_topic, + 'pubsubname': 'pubsub', + 'topic': 'test', + 'route': '/events/pubsub/test', + 'metadata': {}, + 'deadLetterTopic': dead_letter_topic, } ], json.loads(response.data), ) - response = self.client.post("/events/pubsub/test", json={"body": "new message"}) + response = self.client.post('/events/pubsub/test', json={'body': 'new message'}) self.assertEqual(response.status_code, 200) - self.assertEqual(response.data.decode("utf-8"), "dead letter test") + self.assertEqual(response.data.decode('utf-8'), 'dead letter test') -if __name__ == "__main__": +if __name__ == '__main__': unittest.main() diff --git a/pyproject.toml b/pyproject.toml index 850327ed..fa0e12b2 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -16,3 +16,5 @@ ignore = [ # Undefined name {name} "F821", ] +[tool.ruff.format] +quote-style = 'single' diff --git a/setup.py b/setup.py index e0bc2838..75dce736 100644 --- a/setup.py +++ b/setup.py @@ -19,18 +19,18 @@ # Load version in dapr package. version_info = {} -with open("dapr/version/version.py") as fp: +with open('dapr/version/version.py') as fp: exec(fp.read(), version_info) -__version__ = version_info["__version__"] +__version__ = version_info['__version__'] def is_release(): - return ".dev" not in __version__ + return '.dev' not in __version__ -name = "dapr" +name = 'dapr' version = __version__ -description = "The official release of Dapr Python SDK." +description = 'The official release of Dapr Python SDK.' long_description = """ Dapr is a portable, serverless, event-driven runtime that makes it easy for developers to build resilient, stateless and stateful microservices that run on the cloud and edge and @@ -43,15 +43,15 @@ def is_release(): """.lstrip() # Get build number from GITHUB_RUN_NUMBER environment variable -build_number = os.environ.get("GITHUB_RUN_NUMBER", "0") +build_number = os.environ.get('GITHUB_RUN_NUMBER', '0') if not is_release(): - name += "-dev" - version = f"{__version__}{build_number}" - description = "The developmental release for Dapr Python SDK." - long_description = "This is the developmental release for Dapr Python SDK." + name += '-dev' + version = f'{__version__}{build_number}' + description = 'The developmental release for Dapr Python SDK.' + long_description = 'This is the developmental release for Dapr Python SDK.' -print(f"package name: {name}, version: {version}", flush=True) +print(f'package name: {name}, version: {version}', flush=True) setup( diff --git a/tests/actor/fake_actor_classes.py b/tests/actor/fake_actor_classes.py index 405a755b..50fe63fc 100644 --- a/tests/actor/fake_actor_classes.py +++ b/tests/actor/fake_actor_classes.py @@ -27,7 +27,7 @@ # Fake Simple Actor Class for testing class FakeSimpleActorInterface(ActorInterface): - @actormethod(name="ActorMethod") + @actormethod(name='ActorMethod') async def actor_method(self, arg: int) -> dict: ... @@ -37,7 +37,7 @@ def __init__(self, ctx, actor_id): super(FakeSimpleActor, self).__init__(ctx, actor_id) async def actor_method(self, arg: int) -> dict: - return {"name": "actor_method"} + return {'name': 'actor_method'} async def non_actor_method(self, arg0: int, arg1: str, arg2: float) -> str: pass @@ -48,7 +48,7 @@ def __init__(self, ctx, actor_id): super(FakeSimpleReminderActor, self).__init__(ctx, actor_id) async def actor_method(self, arg: int) -> dict: - return {"name": "actor_method"} + return {'name': 'actor_method'} async def non_actor_method(self, arg0: int, arg1: str, arg2: float) -> str: pass @@ -70,7 +70,7 @@ def __init__(self, ctx, actor_id): self.timer_called = False async def actor_method(self, arg: int) -> dict: - return {"name": "actor_method"} + return {'name': 'actor_method'} async def timer_callback(self, obj) -> None: self.timer_called = True @@ -88,39 +88,39 @@ async def receive_reminder( class FakeActorCls1Interface(ActorInterface): # Fake Actor Class deriving multiple ActorInterfaces - @actormethod(name="ActorCls1Method") + @actormethod(name='ActorCls1Method') async def actor_cls1_method(self, arg): ... - @actormethod(name="ActorCls1Method1") + @actormethod(name='ActorCls1Method1') async def actor_cls1_method1(self, arg): ... - @actormethod(name="ActorCls1Method2") + @actormethod(name='ActorCls1Method2') async def actor_cls1_method2(self, arg): ... class FakeActorCls2Interface(ActorInterface): - @actormethod(name="ActorCls2Method") + @actormethod(name='ActorCls2Method') async def actor_cls2_method(self, arg): ... - @actormethod(name="ActionMethod") + @actormethod(name='ActionMethod') async def action(self, data: object) -> str: ... - @actormethod(name="ActionMethodWithoutArg") + @actormethod(name='ActionMethodWithoutArg') async def action_no_arg(self) -> str: ... class ReentrantActorInterface(ActorInterface): - @actormethod(name="ReentrantMethod") + @actormethod(name='ReentrantMethod') async def reentrant_method(self, data: object) -> str: ... - @actormethod(name="ReentrantMethodWithPassthrough") + @actormethod(name='ReentrantMethodWithPassthrough') async def reentrant_pass_through_method(self, arg): ... @@ -148,11 +148,11 @@ async def actor_cls2_method(self, arg): async def action(self, data: object) -> str: self.action_data = data - return self.action_data["message"] + return self.action_data['message'] async def action_no_arg(self) -> str: - self.action_data = {"message": "no_arg"} - return self.action_data["message"] + self.action_data = {'message': 'no_arg'} + return self.action_data['message'] async def _on_activate(self): self.activated = True @@ -164,7 +164,7 @@ async def _on_deactivate(self): async def reentrant_method(self, data: object) -> str: self.action_data = data - return self.action_data["message"] + return self.action_data['message'] async def reentrant_pass_through_method(self, arg): pass @@ -181,7 +181,7 @@ async def reentrant_pass_through_method(self, arg): from dapr.actor.client import proxy await proxy.DaprActorHttpClient(DefaultJSONSerializer()).invoke_method( - FakeSlowReentrantActor.__name__, "test-id", "ReentrantMethod" + FakeSlowReentrantActor.__name__, 'test-id', 'ReentrantMethod' ) async def actor_cls1_method(self, arg): @@ -206,7 +206,7 @@ async def reentrant_pass_through_method(self, arg): from dapr.actor.client import proxy await proxy.DaprActorHttpClient(DefaultJSONSerializer()).invoke_method( - FakeReentrantActor.__name__, "test-id", "ReentrantMethod" + FakeReentrantActor.__name__, 'test-id', 'ReentrantMethod' ) async def actor_cls2_method(self, arg): diff --git a/tests/actor/test_actor.py b/tests/actor/test_actor.py index 189f9996..d8b209c0 100644 --- a/tests/actor/test_actor.py +++ b/tests/actor/test_actor.py @@ -47,7 +47,7 @@ def setUp(self): def test_get_registered_actor_types(self): actor_types = ActorRuntime.get_registered_actor_types() - self.assertTrue(actor_types.index("FakeSimpleActor") >= 0) + self.assertTrue(actor_types.index('FakeSimpleActor') >= 0) self.assertTrue(actor_types.index(FakeMultiInterfacesActor.__name__) >= 0) def test_actor_config(self): @@ -89,34 +89,34 @@ def test_dispatch(self): _run(ActorRuntime.register_actor(FakeMultiInterfacesActor)) request_body = { - "message": "hello dapr", + 'message': 'hello dapr', } test_request_body = self._serializer.serialize(request_body) response = _run( ActorRuntime.dispatch( - FakeMultiInterfacesActor.__name__, "test-id", "ActionMethod", test_request_body + FakeMultiInterfacesActor.__name__, 'test-id', 'ActionMethod', test_request_body ) ) self.assertEqual(b'"hello dapr"', response) - _run(ActorRuntime.deactivate(FakeMultiInterfacesActor.__name__, "test-id")) + _run(ActorRuntime.deactivate(FakeMultiInterfacesActor.__name__, 'test-id')) # Ensure test-id is deactivated with self.assertRaises(ValueError): - _run(ActorRuntime.deactivate(FakeMultiInterfacesActor.__name__, "test-id")) + _run(ActorRuntime.deactivate(FakeMultiInterfacesActor.__name__, 'test-id')) @mock.patch( - "tests.actor.fake_client.FakeDaprActorClient.register_reminder", + 'tests.actor.fake_client.FakeDaprActorClient.register_reminder', new=_async_mock(return_value=b'"ok"'), ) @mock.patch( - "tests.actor.fake_client.FakeDaprActorClient.unregister_reminder", + 'tests.actor.fake_client.FakeDaprActorClient.unregister_reminder', new=_async_mock(return_value=b'"ok"'), ) def test_register_reminder(self): - test_actor_id = ActorId("test_id") + test_actor_id = ActorId('test_id') test_type_info = ActorTypeInformation.create(FakeSimpleReminderActor) test_client = FakeDaprActorClient ctx = ActorRuntimeContext(test_type_info, self._serializer, self._serializer, test_client) @@ -125,34 +125,34 @@ def test_register_reminder(self): # register reminder _run( test_actor.register_reminder( - "test_reminder", b"reminder_message", timedelta(seconds=1), timedelta(seconds=1) + 'test_reminder', b'reminder_message', timedelta(seconds=1), timedelta(seconds=1) ) ) test_client.register_reminder.mock.assert_called_once() test_client.register_reminder.mock.assert_called_with( - "FakeSimpleReminderActor", - "test_id", - "test_reminder", + 'FakeSimpleReminderActor', + 'test_id', + 'test_reminder', b'{"reminderName":"test_reminder","dueTime":"0h0m1s0ms0\\u03bcs","period":"0h0m1s0ms0\\u03bcs","data":"cmVtaW5kZXJfbWVzc2FnZQ=="}', ) # noqa E501 # unregister reminder - _run(test_actor.unregister_reminder("test_reminder")) + _run(test_actor.unregister_reminder('test_reminder')) test_client.unregister_reminder.mock.assert_called_once() test_client.unregister_reminder.mock.assert_called_with( - "FakeSimpleReminderActor", "test_id", "test_reminder" + 'FakeSimpleReminderActor', 'test_id', 'test_reminder' ) @mock.patch( - "tests.actor.fake_client.FakeDaprActorClient.register_timer", + 'tests.actor.fake_client.FakeDaprActorClient.register_timer', new=_async_mock(return_value=b'"ok"'), ) @mock.patch( - "tests.actor.fake_client.FakeDaprActorClient.unregister_timer", + 'tests.actor.fake_client.FakeDaprActorClient.unregister_timer', new=_async_mock(return_value=b'"ok"'), ) def test_register_timer(self): - test_actor_id = ActorId("test_id") + test_actor_id = ActorId('test_id') test_type_info = ActorTypeInformation.create(FakeSimpleTimerActor) test_client = FakeDaprActorClient ctx = ActorRuntimeContext(test_type_info, self._serializer, self._serializer, test_client) @@ -161,26 +161,26 @@ def test_register_timer(self): # register timer _run( test_actor.register_timer( - "test_timer", + 'test_timer', test_actor.timer_callback, - "mydata", + 'mydata', timedelta(seconds=1), timedelta(seconds=2), ) ) test_client.register_timer.mock.assert_called_once() test_client.register_timer.mock.assert_called_with( - "FakeSimpleTimerActor", - "test_id", - "test_timer", + 'FakeSimpleTimerActor', + 'test_id', + 'test_timer', b'{"callback":"timer_callback","data":"mydata","dueTime":"0h0m1s0ms0\\u03bcs","period":"0h0m2s0ms0\\u03bcs"}', ) # noqa E501 # unregister timer - _run(test_actor.unregister_timer("test_timer")) + _run(test_actor.unregister_timer('test_timer')) test_client.unregister_timer.mock.assert_called_once() test_client.unregister_timer.mock.assert_called_with( - "FakeSimpleTimerActor", "test_id", "test_timer" + 'FakeSimpleTimerActor', 'test_id', 'test_timer' ) # register timer without timer name @@ -188,7 +188,7 @@ def test_register_timer(self): test_actor.register_timer( None, test_actor.timer_callback, - "timer call", + 'timer call', timedelta(seconds=1), timedelta(seconds=1), ) diff --git a/tests/actor/test_actor_id.py b/tests/actor/test_actor_id.py index b9de8d19..7fa34141 100644 --- a/tests/actor/test_actor_id.py +++ b/tests/actor/test_actor_id.py @@ -20,21 +20,21 @@ class ActorIdTests(unittest.TestCase): def test_create_actor_id(self): - actor_id_1 = ActorId("1") - self.assertEqual("1", actor_id_1.id) + actor_id_1 = ActorId('1') + self.assertEqual('1', actor_id_1.id) def test_create_random_id(self): actor_id_random = ActorId.create_random_id() - self.assertEqual(len("f56d5aec5b3b11ea9121acde48001122"), len(actor_id_random.id)) + self.assertEqual(len('f56d5aec5b3b11ea9121acde48001122'), len(actor_id_random.id)) def test_get_hash(self): - actor_test_id = ActorId("testId") + actor_test_id = ActorId('testId') self.assertIsNotNone(actor_test_id.__hash__) def test_comparison(self): - actor_id_1 = ActorId("1") - actor_id_1a = ActorId("1") + actor_id_1 = ActorId('1') + actor_id_1a = ActorId('1') self.assertTrue(actor_id_1 == actor_id_1a) - actor_id_2 = ActorId("2") + actor_id_2 = ActorId('2') self.assertFalse(actor_id_1 == actor_id_2) diff --git a/tests/actor/test_actor_manager.py b/tests/actor/test_actor_manager.py index 9d93b4f7..6c21abfb 100644 --- a/tests/actor/test_actor_manager.py +++ b/tests/actor/test_actor_manager.py @@ -51,7 +51,7 @@ def setUp(self): def test_activate_actor(self): """Activate ActorId(1)""" - test_actor_id = ActorId("1") + test_actor_id = ActorId('1') _run(self._manager.activate_actor(test_actor_id)) # assert @@ -61,7 +61,7 @@ def test_activate_actor(self): def test_deactivate_actor(self): """Activate ActorId('2') and deactivate it""" - test_actor_id = ActorId("2") + test_actor_id = ActorId('2') _run(self._manager.activate_actor(test_actor_id)) # assert @@ -74,15 +74,15 @@ def test_deactivate_actor(self): def test_dispatch_success(self): """dispatch ActionMethod""" - test_actor_id = ActorId("dispatch") + test_actor_id = ActorId('dispatch') _run(self._manager.activate_actor(test_actor_id)) request_body = { - "message": "hello dapr", + 'message': 'hello dapr', } test_request_body = self._serializer.serialize(request_body) - response = _run(self._manager.dispatch(test_actor_id, "ActionMethod", test_request_body)) + response = _run(self._manager.dispatch(test_actor_id, 'ActionMethod', test_request_body)) self.assertEqual(b'"hello dapr"', response) @@ -93,11 +93,11 @@ def setUp(self): self._test_reminder_req = self._serializer.serialize( { - "name": "test_reminder", - "dueTime": timedelta(seconds=1), - "period": timedelta(seconds=1), - "ttl": timedelta(seconds=1), - "data": "cmVtaW5kZXJfc3RhdGU=", + 'name': 'test_reminder', + 'dueTime': timedelta(seconds=1), + 'period': timedelta(seconds=1), + 'ttl': timedelta(seconds=1), + 'data': 'cmVtaW5kZXJfc3RhdGU=', } ) @@ -108,17 +108,17 @@ def test_fire_reminder_for_non_reminderable(self): ) manager = ActorManager(ctx) with self.assertRaises(ValueError): - _run(manager.fire_reminder(ActorId("testid"), "test_reminder", self._test_reminder_req)) + _run(manager.fire_reminder(ActorId('testid'), 'test_reminder', self._test_reminder_req)) def test_fire_reminder_success(self): - test_actor_id = ActorId("testid") + test_actor_id = ActorId('testid') test_type_info = ActorTypeInformation.create(FakeSimpleReminderActor) ctx = ActorRuntimeContext( test_type_info, self._serializer, self._serializer, self._fake_client ) manager = ActorManager(ctx) _run(manager.activate_actor(test_actor_id)) - _run(manager.fire_reminder(test_actor_id, "test_reminder", self._test_reminder_req)) + _run(manager.fire_reminder(test_actor_id, 'test_reminder', self._test_reminder_req)) class ActorManagerTimerTests(unittest.TestCase): @@ -128,12 +128,12 @@ def setUp(self): self._fake_client = FakeDaprActorClient @mock.patch( - "tests.actor.fake_client.FakeDaprActorClient.invoke_method", + 'tests.actor.fake_client.FakeDaprActorClient.invoke_method', new=_async_mock(return_value=b'"expected_response"'), ) - @mock.patch("tests.actor.fake_client.FakeDaprActorClient.register_timer", new=_async_mock()) + @mock.patch('tests.actor.fake_client.FakeDaprActorClient.register_timer', new=_async_mock()) def test_fire_timer_success(self): - test_actor_id = ActorId("testid") + test_actor_id = ActorId('testid') test_type_info = ActorTypeInformation.create(FakeSimpleTimerActor) ctx = ActorRuntimeContext( test_type_info, self._serializer, self._serializer, self._fake_client @@ -146,9 +146,9 @@ def test_fire_timer_success(self): # Setup timer _run( actor.register_timer( - "test_timer", + 'test_timer', actor.timer_callback, - "timer call", + 'timer call', timedelta(seconds=1), timedelta(seconds=1), timedelta(seconds=1), @@ -159,8 +159,8 @@ def test_fire_timer_success(self): _run( manager.fire_timer( test_actor_id, - "test_timer", - '{ "callback": "timer_callback", "data": "timer call" }'.encode("UTF8"), + 'test_timer', + '{ "callback": "timer_callback", "data": "timer call" }'.encode('UTF8'), ) ) diff --git a/tests/actor/test_actor_reentrancy.py b/tests/actor/test_actor_reentrancy.py index 4ba9a415..40b948a5 100644 --- a/tests/actor/test_actor_reentrancy.py +++ b/tests/actor/test_actor_reentrancy.py @@ -46,17 +46,17 @@ def test_reentrant_dispatch(self): _run(ActorRuntime.register_actor(FakeMultiInterfacesActor)) request_body = { - "message": "hello dapr", + 'message': 'hello dapr', } - reentrancy_id = "0faa4c8b-f53a-4dff-9a9d-c50205035085" + reentrancy_id = '0faa4c8b-f53a-4dff-9a9d-c50205035085' test_request_body = self._serializer.serialize(request_body) response = _run( ActorRuntime.dispatch( FakeMultiInterfacesActor.__name__, - "test-id", - "ReentrantMethod", + 'test-id', + 'ReentrantMethod', test_request_body, reentrancy_id=reentrancy_id, ) @@ -64,11 +64,11 @@ def test_reentrant_dispatch(self): self.assertEqual(b'"hello dapr"', response) - _run(ActorRuntime.deactivate(FakeMultiInterfacesActor.__name__, "test-id")) + _run(ActorRuntime.deactivate(FakeMultiInterfacesActor.__name__, 'test-id')) # Ensure test-id is deactivated with self.assertRaises(ValueError): - _run(ActorRuntime.deactivate(FakeMultiInterfacesActor.__name__, "test-id")) + _run(ActorRuntime.deactivate(FakeMultiInterfacesActor.__name__, 'test-id')) def test_interleaved_reentrant_actor_dispatch(self): _run(ActorRuntime.register_actor(FakeReentrantActor)) @@ -76,24 +76,24 @@ def test_interleaved_reentrant_actor_dispatch(self): request_body = self._serializer.serialize( { - "message": "Normal", + 'message': 'Normal', } ) - normal_reentrancy_id = "f6319f23-dc0a-4880-90d9-87b23c19c20a" - slow_reentrancy_id = "b1653a2f-fe54-4514-8197-98b52d156454" + normal_reentrancy_id = 'f6319f23-dc0a-4880-90d9-87b23c19c20a' + slow_reentrancy_id = 'b1653a2f-fe54-4514-8197-98b52d156454' async def dispatchReentrantCall(actorName: str, method: str, reentrancy_id: str): return await ActorRuntime.dispatch( - actorName, "test-id", method, request_body, reentrancy_id=reentrancy_id + actorName, 'test-id', method, request_body, reentrancy_id=reentrancy_id ) async def run_parallel_actors(): slow = dispatchReentrantCall( - FakeSlowReentrantActor.__name__, "ReentrantMethod", slow_reentrancy_id + FakeSlowReentrantActor.__name__, 'ReentrantMethod', slow_reentrancy_id ) normal = dispatchReentrantCall( - FakeReentrantActor.__name__, "ReentrantMethod", normal_reentrancy_id + FakeReentrantActor.__name__, 'ReentrantMethod', normal_reentrancy_id ) res = await asyncio.gather(slow, normal) @@ -102,16 +102,16 @@ async def run_parallel_actors(): _run(run_parallel_actors()) - self.assertEqual(self.normal_res, bytes('"' + normal_reentrancy_id + '"', "utf-8")) - self.assertEqual(self.slow_res, bytes('"' + slow_reentrancy_id + '"', "utf-8")) + self.assertEqual(self.normal_res, bytes('"' + normal_reentrancy_id + '"', 'utf-8')) + self.assertEqual(self.slow_res, bytes('"' + slow_reentrancy_id + '"', 'utf-8')) - _run(ActorRuntime.deactivate(FakeSlowReentrantActor.__name__, "test-id")) - _run(ActorRuntime.deactivate(FakeReentrantActor.__name__, "test-id")) + _run(ActorRuntime.deactivate(FakeSlowReentrantActor.__name__, 'test-id')) + _run(ActorRuntime.deactivate(FakeReentrantActor.__name__, 'test-id')) # Ensure test-id is deactivated with self.assertRaises(ValueError): - _run(ActorRuntime.deactivate(FakeSlowReentrantActor.__name__, "test-id")) - _run(ActorRuntime.deactivate(FakeReentrantActor.__name__, "test-id")) + _run(ActorRuntime.deactivate(FakeSlowReentrantActor.__name__, 'test-id')) + _run(ActorRuntime.deactivate(FakeReentrantActor.__name__, 'test-id')) def test_reentrancy_header_passthrough(self): _run(ActorRuntime.register_actor(FakeReentrantActor)) @@ -119,41 +119,41 @@ def test_reentrancy_header_passthrough(self): request_body = self._serializer.serialize( { - "message": "Normal", + 'message': 'Normal', } ) async def expected_return_value(*args, **kwargs): - return ["expected", "None"] + return ['expected', 'None'] - reentrancy_id = "f6319f23-dc0a-4880-90d9-87b23c19c20a" + reentrancy_id = 'f6319f23-dc0a-4880-90d9-87b23c19c20a' actor = FakeSlowReentrantActor.__name__ - method = "ReentrantMethod" + method = 'ReentrantMethod' - with mock.patch("dapr.clients.http.client.DaprHttpClient.send_bytes") as mocked: + with mock.patch('dapr.clients.http.client.DaprHttpClient.send_bytes') as mocked: mocked.side_effect = expected_return_value _run( ActorRuntime.dispatch( FakeReentrantActor.__name__, - "test-id", - "ReentrantMethodWithPassthrough", + 'test-id', + 'ReentrantMethodWithPassthrough', request_body, reentrancy_id=reentrancy_id, ) ) mocked.assert_called_with( - method="POST", - url=f"http://127.0.0.1:3500/v1.0/actors/{actor}/test-id/method/{method}", + method='POST', + url=f'http://127.0.0.1:3500/v1.0/actors/{actor}/test-id/method/{method}', data=None, - headers={"Dapr-Reentrancy-Id": reentrancy_id}, + headers={'Dapr-Reentrancy-Id': reentrancy_id}, ) - _run(ActorRuntime.deactivate(FakeReentrantActor.__name__, "test-id")) + _run(ActorRuntime.deactivate(FakeReentrantActor.__name__, 'test-id')) # Ensure test-id is deactivated with self.assertRaises(ValueError): - _run(ActorRuntime.deactivate(FakeReentrantActor.__name__, "test-id")) + _run(ActorRuntime.deactivate(FakeReentrantActor.__name__, 'test-id')) def test_header_passthrough_reentrancy_disabled(self): config = ActorRuntimeConfig(reentrancy=None) @@ -163,63 +163,63 @@ def test_header_passthrough_reentrancy_disabled(self): request_body = self._serializer.serialize( { - "message": "Normal", + 'message': 'Normal', } ) async def expected_return_value(*args, **kwargs): - return ["expected", "None"] + return ['expected', 'None'] reentrancy_id = None # the runtime would not pass this header actor = FakeSlowReentrantActor.__name__ - method = "ReentrantMethod" + method = 'ReentrantMethod' - with mock.patch("dapr.clients.http.client.DaprHttpClient.send_bytes") as mocked: + with mock.patch('dapr.clients.http.client.DaprHttpClient.send_bytes') as mocked: mocked.side_effect = expected_return_value _run( ActorRuntime.dispatch( FakeReentrantActor.__name__, - "test-id", - "ReentrantMethodWithPassthrough", + 'test-id', + 'ReentrantMethodWithPassthrough', request_body, reentrancy_id=reentrancy_id, ) ) mocked.assert_called_with( - method="POST", - url=f"http://127.0.0.1:3500/v1.0/actors/{actor}/test-id/method/{method}", + method='POST', + url=f'http://127.0.0.1:3500/v1.0/actors/{actor}/test-id/method/{method}', data=None, headers={}, ) - _run(ActorRuntime.deactivate(FakeReentrantActor.__name__, "test-id")) + _run(ActorRuntime.deactivate(FakeReentrantActor.__name__, 'test-id')) # Ensure test-id is deactivated with self.assertRaises(ValueError): - _run(ActorRuntime.deactivate(FakeReentrantActor.__name__, "test-id")) + _run(ActorRuntime.deactivate(FakeReentrantActor.__name__, 'test-id')) def test_parse_incoming_reentrancy_header_flask(self): from ext.flask_dapr import flask_dapr from flask import Flask - app = Flask(f"{FakeReentrantActor.__name__}Service") + app = Flask(f'{FakeReentrantActor.__name__}Service') flask_dapr.DaprActor(app) - reentrancy_id = "b1653a2f-fe54-4514-8197-98b52d156454" + reentrancy_id = 'b1653a2f-fe54-4514-8197-98b52d156454' actor_type_name = FakeReentrantActor.__name__ - actor_id = "test-id" - method_name = "ReentrantMethod" + actor_id = 'test-id' + method_name = 'ReentrantMethod' request_body = self._serializer.serialize( { - "message": "Normal", + 'message': 'Normal', } ) - relativeUrl = f"/actors/{actor_type_name}/{actor_id}/method/{method_name}" + relativeUrl = f'/actors/{actor_type_name}/{actor_id}/method/{method_name}' - with mock.patch("dapr.actor.runtime.runtime.ActorRuntime.dispatch") as mocked: + with mock.patch('dapr.actor.runtime.runtime.ActorRuntime.dispatch') as mocked: client = app.test_client() mocked.return_value = None client.put( @@ -236,23 +236,23 @@ def test_parse_incoming_reentrancy_header_fastapi(self): from fastapi.testclient import TestClient from dapr.ext import fastapi - app = FastAPI(title=f"{FakeReentrantActor.__name__}Service") + app = FastAPI(title=f'{FakeReentrantActor.__name__}Service') fastapi.DaprActor(app) - reentrancy_id = "b1653a2f-fe54-4514-8197-98b52d156454" + reentrancy_id = 'b1653a2f-fe54-4514-8197-98b52d156454' actor_type_name = FakeReentrantActor.__name__ - actor_id = "test-id" - method_name = "ReentrantMethod" + actor_id = 'test-id' + method_name = 'ReentrantMethod' request_body = self._serializer.serialize( { - "message": "Normal", + 'message': 'Normal', } ) - relativeUrl = f"/actors/{actor_type_name}/{actor_id}/method/{method_name}" + relativeUrl = f'/actors/{actor_type_name}/{actor_id}/method/{method_name}' - with mock.patch("dapr.actor.runtime.runtime.ActorRuntime.dispatch") as mocked: + with mock.patch('dapr.actor.runtime.runtime.ActorRuntime.dispatch') as mocked: client = TestClient(app) mocked.return_value = None client.put( diff --git a/tests/actor/test_actor_runtime.py b/tests/actor/test_actor_runtime.py index daac3f17..3aa24289 100644 --- a/tests/actor/test_actor_runtime.py +++ b/tests/actor/test_actor_runtime.py @@ -41,7 +41,7 @@ def setUp(self): def test_get_registered_actor_types(self): actor_types = ActorRuntime.get_registered_actor_types() - self.assertTrue(actor_types.index("FakeSimpleActor") >= 0) + self.assertTrue(actor_types.index('FakeSimpleActor') >= 0) self.assertTrue(actor_types.index(FakeMultiInterfacesActor.__name__) >= 0) self.assertTrue(actor_types.index(FakeSimpleTimerActor.__name__) >= 0) @@ -84,46 +84,46 @@ def test_dispatch(self): _run(ActorRuntime.register_actor(FakeMultiInterfacesActor)) request_body = { - "message": "hello dapr", + 'message': 'hello dapr', } test_request_body = self._serializer.serialize(request_body) response = _run( ActorRuntime.dispatch( - FakeMultiInterfacesActor.__name__, "test-id", "ActionMethod", test_request_body + FakeMultiInterfacesActor.__name__, 'test-id', 'ActionMethod', test_request_body ) ) self.assertEqual(b'"hello dapr"', response) - _run(ActorRuntime.deactivate(FakeMultiInterfacesActor.__name__, "test-id")) + _run(ActorRuntime.deactivate(FakeMultiInterfacesActor.__name__, 'test-id')) # Ensure test-id is deactivated with self.assertRaises(ValueError): - _run(ActorRuntime.deactivate(FakeMultiInterfacesActor.__name__, "test-id")) + _run(ActorRuntime.deactivate(FakeMultiInterfacesActor.__name__, 'test-id')) def test_fire_timer_success(self): # Fire timer _run( ActorRuntime.fire_timer( FakeSimpleTimerActor.__name__, - "test-id", - "test_timer", - '{ "callback": "timer_callback", "data": "timer call" }'.encode("UTF8"), + 'test-id', + 'test_timer', + '{ "callback": "timer_callback", "data": "timer call" }'.encode('UTF8'), ) ) manager = ActorRuntime._actor_managers[FakeSimpleTimerActor.__name__] - actor = manager._active_actors["test-id"] + actor = manager._active_actors['test-id'] self.assertTrue(actor.timer_called) def test_fire_timer_unregistered(self): with self.assertRaises(ValueError): _run( ActorRuntime.fire_timer( - "UnknownType", - "test-id", - "test_timer", - '{ "callback": "timer_callback", "data": "timer call" }'.encode("UTF8"), + 'UnknownType', + 'test-id', + 'test_timer', + '{ "callback": "timer_callback", "data": "timer call" }'.encode('UTF8'), ) ) diff --git a/tests/actor/test_actor_runtime_config.py b/tests/actor/test_actor_runtime_config.py index 4b265d26..7bbd8cef 100644 --- a/tests/actor/test_actor_runtime_config.py +++ b/tests/actor/test_actor_runtime_config.py @@ -21,24 +21,24 @@ class ActorTypeConfigTests(unittest.TestCase): def test_default_config(self): - config = ActorTypeConfig("testactor") + config = ActorTypeConfig('testactor') self.assertEqual(config._actor_idle_timeout, None) self.assertEqual(config._actor_scan_interval, None) self.assertEqual(config._drain_ongoing_call_timeout, None) self.assertEqual(config._drain_rebalanced_actors, None) self.assertEqual(config._reentrancy, None) - self.assertEqual(config.as_dict()["entities"], ["testactor"]) + self.assertEqual(config.as_dict()['entities'], ['testactor']) keys = config.as_dict().keys() - self.assertNotIn("reentrancy", keys) - self.assertNotIn("remindersStoragePartitions", keys) - self.assertNotIn("actorIdleTimeout", keys) - self.assertNotIn("actorScanInterval", keys) - self.assertNotIn("drainOngoingCallTimeout", keys) - self.assertNotIn("drainRebalancedActors", keys) + self.assertNotIn('reentrancy', keys) + self.assertNotIn('remindersStoragePartitions', keys) + self.assertNotIn('actorIdleTimeout', keys) + self.assertNotIn('actorScanInterval', keys) + self.assertNotIn('drainOngoingCallTimeout', keys) + self.assertNotIn('drainRebalancedActors', keys) def test_complete_config(self): config = ActorTypeConfig( - "testactor", + 'testactor', actor_idle_timeout=timedelta(seconds=3600), actor_scan_interval=timedelta(seconds=30), drain_ongoing_call_timeout=timedelta(seconds=60), @@ -53,14 +53,14 @@ def test_complete_config(self): self.assertEqual(config._reentrancy._enabled, True) self.assertEqual(config._reentrancy._maxStackDepth, 32) d = config.as_dict() - self.assertEqual(d["entities"], ["testactor"]) - self.assertEqual(d["reentrancy"]["enabled"], True) - self.assertEqual(d["reentrancy"]["maxStackDepth"], 32) - self.assertEqual(d["remindersStoragePartitions"], 10) - self.assertEqual(d["actorIdleTimeout"], timedelta(seconds=3600)) - self.assertEqual(d["actorScanInterval"], timedelta(seconds=30)) - self.assertEqual(d["drainOngoingCallTimeout"], timedelta(seconds=60)) - self.assertEqual(d["drainRebalancedActors"], False) + self.assertEqual(d['entities'], ['testactor']) + self.assertEqual(d['reentrancy']['enabled'], True) + self.assertEqual(d['reentrancy']['maxStackDepth'], 32) + self.assertEqual(d['remindersStoragePartitions'], 10) + self.assertEqual(d['actorIdleTimeout'], timedelta(seconds=3600)) + self.assertEqual(d['actorScanInterval'], timedelta(seconds=30)) + self.assertEqual(d['drainOngoingCallTimeout'], timedelta(seconds=60)) + self.assertEqual(d['drainRebalancedActors'], False) class ActorRuntimeConfigTests(unittest.TestCase): @@ -74,9 +74,9 @@ def test_default_config(self): self.assertEqual(config._reentrancy, None) self.assertEqual(config._entities, set()) self.assertEqual(config._entitiesConfig, []) - self.assertNotIn("reentrancy", config.as_dict().keys()) - self.assertNotIn("remindersStoragePartitions", config.as_dict().keys()) - self.assertEqual(config.as_dict()["entitiesConfig"], []) + self.assertNotIn('reentrancy', config.as_dict().keys()) + self.assertNotIn('remindersStoragePartitions', config.as_dict().keys()) + self.assertEqual(config.as_dict()['entitiesConfig'], []) def test_default_config_with_reentrancy(self): reentrancyConfig = ActorReentrancyConfig(enabled=True) @@ -89,19 +89,19 @@ def test_default_config_with_reentrancy(self): self.assertEqual(config._reentrancy, reentrancyConfig) self.assertEqual(config._entities, set()) self.assertEqual(config._entitiesConfig, []) - self.assertEqual(config.as_dict()["reentrancy"], reentrancyConfig.as_dict()) - self.assertEqual(config.as_dict()["reentrancy"]["enabled"], True) - self.assertEqual(config.as_dict()["reentrancy"]["maxStackDepth"], 32) - self.assertNotIn("remindersStoragePartitions", config.as_dict().keys()) + self.assertEqual(config.as_dict()['reentrancy'], reentrancyConfig.as_dict()) + self.assertEqual(config.as_dict()['reentrancy']['enabled'], True) + self.assertEqual(config.as_dict()['reentrancy']['maxStackDepth'], 32) + self.assertNotIn('remindersStoragePartitions', config.as_dict().keys()) def test_config_with_actor_type_config(self): typeConfig1 = ActorTypeConfig( - "testactor1", + 'testactor1', actor_scan_interval=timedelta(seconds=10), reentrancy=ActorReentrancyConfig(enabled=True), ) typeConfig2 = ActorTypeConfig( - "testactor2", + 'testactor2', drain_ongoing_call_timeout=timedelta(seconds=60), reminders_storage_partitions=10, ) @@ -111,54 +111,54 @@ def test_config_with_actor_type_config(self): d = config.as_dict() self.assertEqual(config._drain_ongoing_call_timeout, timedelta(seconds=60)) - self.assertEqual(d["entitiesConfig"][0]["entities"], ["testactor1"]) - self.assertEqual(d["entitiesConfig"][0]["actorScanInterval"], timedelta(seconds=10)) - self.assertEqual(d["entitiesConfig"][0]["reentrancy"]["enabled"], True) - self.assertEqual(d["entitiesConfig"][0]["reentrancy"]["maxStackDepth"], 32) - self.assertEqual(d["entitiesConfig"][1]["entities"], ["testactor2"]) - self.assertEqual(d["entitiesConfig"][1]["drainOngoingCallTimeout"], timedelta(seconds=60)) - self.assertEqual(d["entitiesConfig"][1]["remindersStoragePartitions"], 10) - self.assertNotIn("reentrancy", d["entitiesConfig"][1]) - self.assertNotIn("actorScanInterval", d["entitiesConfig"][1]) - self.assertNotIn("draingOngoingCallTimeout", d["entitiesConfig"][0]) - self.assertNotIn("remindersStoragePartitions", d["entitiesConfig"][0]) - self.assertEqual(sorted(d["entities"]), ["testactor1", "testactor2"]) + self.assertEqual(d['entitiesConfig'][0]['entities'], ['testactor1']) + self.assertEqual(d['entitiesConfig'][0]['actorScanInterval'], timedelta(seconds=10)) + self.assertEqual(d['entitiesConfig'][0]['reentrancy']['enabled'], True) + self.assertEqual(d['entitiesConfig'][0]['reentrancy']['maxStackDepth'], 32) + self.assertEqual(d['entitiesConfig'][1]['entities'], ['testactor2']) + self.assertEqual(d['entitiesConfig'][1]['drainOngoingCallTimeout'], timedelta(seconds=60)) + self.assertEqual(d['entitiesConfig'][1]['remindersStoragePartitions'], 10) + self.assertNotIn('reentrancy', d['entitiesConfig'][1]) + self.assertNotIn('actorScanInterval', d['entitiesConfig'][1]) + self.assertNotIn('draingOngoingCallTimeout', d['entitiesConfig'][0]) + self.assertNotIn('remindersStoragePartitions', d['entitiesConfig'][0]) + self.assertEqual(sorted(d['entities']), ['testactor1', 'testactor2']) def test_update_entities(self): config = ActorRuntimeConfig() - config.update_entities(["actortype1"]) + config.update_entities(['actortype1']) self.assertEqual(config._actor_idle_timeout, timedelta(seconds=3600)) self.assertEqual(config._actor_scan_interval, timedelta(seconds=30)) self.assertEqual(config._drain_ongoing_call_timeout, timedelta(seconds=60)) self.assertEqual(config._drain_rebalanced_actors, True) - self.assertEqual(config._entities, {"actortype1"}) + self.assertEqual(config._entities, {'actortype1'}) self.assertEqual(config._entitiesConfig, []) - self.assertNotIn("remindersStoragePartitions", config.as_dict().keys()) + self.assertNotIn('remindersStoragePartitions', config.as_dict().keys()) def test_update_entities_two_types(self): config = ActorRuntimeConfig() - config.update_entities(["actortype1", "actortype1"]) + config.update_entities(['actortype1', 'actortype1']) self.assertEqual(config._actor_idle_timeout, timedelta(seconds=3600)) self.assertEqual(config._actor_scan_interval, timedelta(seconds=30)) self.assertEqual(config._drain_ongoing_call_timeout, timedelta(seconds=60)) self.assertEqual(config._drain_rebalanced_actors, True) - self.assertEqual(config._entities, {"actortype1", "actortype1"}) + self.assertEqual(config._entities, {'actortype1', 'actortype1'}) self.assertEqual(config._entitiesConfig, []) - self.assertNotIn("remindersStoragePartitions", config.as_dict().keys()) + self.assertNotIn('remindersStoragePartitions', config.as_dict().keys()) def test_update_actor_type_config(self): config = ActorRuntimeConfig() - config.update_entities(["actortype1"]) + config.update_entities(['actortype1']) config.update_actor_type_configs( - [ActorTypeConfig("updatetype1", actor_scan_interval=timedelta(seconds=5))] + [ActorTypeConfig('updatetype1', actor_scan_interval=timedelta(seconds=5))] ) d = config.as_dict() - self.assertEqual(sorted(d["entities"]), ["actortype1", "updatetype1"]) - self.assertEqual(d["entitiesConfig"][0]["actorScanInterval"], timedelta(seconds=5)) - self.assertEqual(d["entitiesConfig"][0]["entities"], ["updatetype1"]) - self.assertEqual(d["actorScanInterval"], timedelta(seconds=30)) + self.assertEqual(sorted(d['entities']), ['actortype1', 'updatetype1']) + self.assertEqual(d['entitiesConfig'][0]['actorScanInterval'], timedelta(seconds=5)) + self.assertEqual(d['entitiesConfig'][0]['entities'], ['updatetype1']) + self.assertEqual(d['actorScanInterval'], timedelta(seconds=30)) def test_set_reminders_storage_partitions(self): config = ActorRuntimeConfig(reminders_storage_partitions=12) @@ -166,10 +166,10 @@ def test_set_reminders_storage_partitions(self): self.assertEqual(config._actor_scan_interval, timedelta(seconds=30)) self.assertEqual(config._drain_ongoing_call_timeout, timedelta(seconds=60)) self.assertEqual(config._drain_rebalanced_actors, True) - self.assertNotIn("reentrancy", config.as_dict().keys()) + self.assertNotIn('reentrancy', config.as_dict().keys()) self.assertEqual(config._reminders_storage_partitions, 12) - self.assertEqual(config.as_dict()["remindersStoragePartitions"], 12) + self.assertEqual(config.as_dict()['remindersStoragePartitions'], 12) -if __name__ == "__main__": +if __name__ == '__main__': unittest.main() diff --git a/tests/actor/test_client_proxy.py b/tests/actor/test_client_proxy.py index 9ad5cda1..2e21b634 100644 --- a/tests/actor/test_client_proxy.py +++ b/tests/actor/test_client_proxy.py @@ -49,53 +49,53 @@ def setUp(self): self._fake_factory = FakeActoryProxyFactory(self._fake_client) self._proxy = ActorProxy.create( FakeMultiInterfacesActor.__name__, - ActorId("fake-id"), + ActorId('fake-id'), FakeActorCls2Interface, self._fake_factory, ) @mock.patch( - "tests.actor.fake_client.FakeDaprActorClient.invoke_method", + 'tests.actor.fake_client.FakeDaprActorClient.invoke_method', new=_async_mock(return_value=b'"expected_response"'), ) def test_invoke(self): - response = _run(self._proxy.invoke_method("ActionMethod", b"arg0")) + response = _run(self._proxy.invoke_method('ActionMethod', b'arg0')) self.assertEqual(b'"expected_response"', response) self._fake_client.invoke_method.mock.assert_called_once_with( - FakeMultiInterfacesActor.__name__, "fake-id", "ActionMethod", b"arg0" + FakeMultiInterfacesActor.__name__, 'fake-id', 'ActionMethod', b'arg0' ) @mock.patch( - "tests.actor.fake_client.FakeDaprActorClient.invoke_method", + 'tests.actor.fake_client.FakeDaprActorClient.invoke_method', new=_async_mock(return_value=b'"expected_response"'), ) def test_invoke_no_arg(self): - response = _run(self._proxy.invoke_method("ActionMethodWithoutArg")) + response = _run(self._proxy.invoke_method('ActionMethodWithoutArg')) self.assertEqual(b'"expected_response"', response) self._fake_client.invoke_method.mock.assert_called_once_with( - FakeMultiInterfacesActor.__name__, "fake-id", "ActionMethodWithoutArg", None + FakeMultiInterfacesActor.__name__, 'fake-id', 'ActionMethodWithoutArg', None ) @mock.patch( - "tests.actor.fake_client.FakeDaprActorClient.invoke_method", + 'tests.actor.fake_client.FakeDaprActorClient.invoke_method', new=_async_mock(return_value=b'"expected_response"'), ) def test_invoke_with_static_typing(self): - response = _run(self._proxy.ActionMethod(b"arg0")) - self.assertEqual("expected_response", response) + response = _run(self._proxy.ActionMethod(b'arg0')) + self.assertEqual('expected_response', response) self._fake_client.invoke_method.mock.assert_called_once_with( - FakeMultiInterfacesActor.__name__, "fake-id", "ActionMethod", b"arg0" + FakeMultiInterfacesActor.__name__, 'fake-id', 'ActionMethod', b'arg0' ) @mock.patch( - "tests.actor.fake_client.FakeDaprActorClient.invoke_method", + 'tests.actor.fake_client.FakeDaprActorClient.invoke_method', new=_async_mock(return_value=b'"expected_response"'), ) def test_invoke_with_static_typing_no_arg(self): response = _run(self._proxy.ActionMethodWithoutArg()) - self.assertEqual("expected_response", response) + self.assertEqual('expected_response', response) self._fake_client.invoke_method.mock.assert_called_once_with( - FakeMultiInterfacesActor.__name__, "fake-id", "ActionMethodWithoutArg", None + FakeMultiInterfacesActor.__name__, 'fake-id', 'ActionMethodWithoutArg', None ) def test_raise_exception_non_existing_method(self): diff --git a/tests/actor/test_method_dispatcher.py b/tests/actor/test_method_dispatcher.py index d6435a41..94f48a7b 100644 --- a/tests/actor/test_method_dispatcher.py +++ b/tests/actor/test_method_dispatcher.py @@ -36,21 +36,21 @@ def setUp(self): def test_get_arg_names(self): dispatcher = ActorMethodDispatcher(self._testActorTypeInfo) - arg_names = dispatcher.get_arg_names("ActorMethod") - self.assertEqual(["arg"], arg_names) + arg_names = dispatcher.get_arg_names('ActorMethod') + self.assertEqual(['arg'], arg_names) def test_get_arg_types(self): dispatcher = ActorMethodDispatcher(self._testActorTypeInfo) - arg_names = dispatcher.get_arg_types("ActorMethod") + arg_names = dispatcher.get_arg_types('ActorMethod') self.assertEqual([int], arg_names) def test_get_return_type(self): dispatcher = ActorMethodDispatcher(self._testActorTypeInfo) - arg_names = dispatcher.get_return_type("ActorMethod") + arg_names = dispatcher.get_return_type('ActorMethod') self.assertEqual(dict, arg_names) def test_dispatch(self): dispatcher = ActorMethodDispatcher(self._testActorTypeInfo) actorInstance = FakeSimpleActor(self._fake_runtime_ctx, None) - result = _run(dispatcher.dispatch(actorInstance, "ActorMethod", 10)) - self.assertEqual({"name": "actor_method"}, result) + result = _run(dispatcher.dispatch(actorInstance, 'ActorMethod', 10)) + self.assertEqual({'name': 'actor_method'}, result) diff --git a/tests/actor/test_reminder_data.py b/tests/actor/test_reminder_data.py index 64dabcc7..e142217c 100644 --- a/tests/actor/test_reminder_data.py +++ b/tests/actor/test_reminder_data.py @@ -23,15 +23,15 @@ class ActorReminderTests(unittest.TestCase): def test_invalid_state(self): with self.assertRaises(ValueError): ActorReminderData( - "test_reminder", + 'test_reminder', 123, # int type timedelta(seconds=1), timedelta(seconds=2), timedelta(seconds=3), ) ActorReminderData( - "test_reminder", - "reminder_state", # string type + 'test_reminder', + 'reminder_state', # string type timedelta(seconds=2), timedelta(seconds=1), timedelta(seconds=3), @@ -40,43 +40,43 @@ def test_invalid_state(self): def test_valid_state(self): # bytes type state data reminder = ActorReminderData( - "test_reminder", - b"reminder_state", + 'test_reminder', + b'reminder_state', timedelta(seconds=1), timedelta(seconds=2), timedelta(seconds=3), ) - self.assertEqual(b"reminder_state", reminder.state) + self.assertEqual(b'reminder_state', reminder.state) def test_as_dict(self): reminder = ActorReminderData( - "test_reminder", - b"reminder_state", + 'test_reminder', + b'reminder_state', timedelta(seconds=1), timedelta(seconds=2), timedelta(seconds=3), ) expected = { - "reminderName": "test_reminder", - "dueTime": timedelta(seconds=1), - "period": timedelta(seconds=2), - "ttl": timedelta(seconds=3), - "data": "cmVtaW5kZXJfc3RhdGU=", + 'reminderName': 'test_reminder', + 'dueTime': timedelta(seconds=1), + 'period': timedelta(seconds=2), + 'ttl': timedelta(seconds=3), + 'data': 'cmVtaW5kZXJfc3RhdGU=', } self.assertDictEqual(expected, reminder.as_dict()) def test_from_dict(self): reminder = ActorReminderData.from_dict( - "test_reminder", + 'test_reminder', { - "dueTime": timedelta(seconds=1), - "period": timedelta(seconds=2), - "ttl": timedelta(seconds=3), - "data": "cmVtaW5kZXJfc3RhdGU=", + 'dueTime': timedelta(seconds=1), + 'period': timedelta(seconds=2), + 'ttl': timedelta(seconds=3), + 'data': 'cmVtaW5kZXJfc3RhdGU=', }, ) - self.assertEqual("test_reminder", reminder.reminder_name) + self.assertEqual('test_reminder', reminder.reminder_name) self.assertEqual(timedelta(seconds=1), reminder.due_time) self.assertEqual(timedelta(seconds=2), reminder.period) self.assertEqual(timedelta(seconds=3), reminder.ttl) - self.assertEqual(b"reminder_state", reminder.state) + self.assertEqual(b'reminder_state', reminder.state) diff --git a/tests/actor/test_state_manager.py b/tests/actor/test_state_manager.py index e4793df8..dfaf46bb 100644 --- a/tests/actor/test_state_manager.py +++ b/tests/actor/test_state_manager.py @@ -36,7 +36,7 @@ def setUp(self): # Create mock client self._fake_client = FakeDaprActorClient - self._test_actor_id = ActorId("1") + self._test_actor_id = ActorId('1') self._test_type_info = ActorTypeInformation.create(FakeSimpleActor) self._serializer = DefaultJSONSerializer() self._runtime_ctx = ActorRuntimeContext( @@ -45,212 +45,212 @@ def setUp(self): self._fake_actor = FakeSimpleActor(self._runtime_ctx, self._test_actor_id) @mock.patch( - "tests.actor.fake_client.FakeDaprActorClient.get_state", + 'tests.actor.fake_client.FakeDaprActorClient.get_state', new=_async_mock(return_value=base64.b64encode(b'"value1"')), ) @mock.patch( - "tests.actor.fake_client.FakeDaprActorClient.save_state_transactionally", new=_async_mock() + 'tests.actor.fake_client.FakeDaprActorClient.save_state_transactionally', new=_async_mock() ) def test_add_state(self): state_manager = ActorStateManager(self._fake_actor) state_change_tracker = state_manager._get_contextual_state_tracker() # Add first 'state1' - added = _run(state_manager.try_add_state("state1", "value1")) + added = _run(state_manager.try_add_state('state1', 'value1')) self.assertTrue(added) - state = state_change_tracker["state1"] - self.assertEqual("value1", state.value) + state = state_change_tracker['state1'] + self.assertEqual('value1', state.value) self.assertEqual(StateChangeKind.add, state.change_kind) # Add 'state1' again - added = _run(state_manager.try_add_state("state1", "value1")) + added = _run(state_manager.try_add_state('state1', 'value1')) self.assertFalse(added) - @mock.patch("tests.actor.fake_client.FakeDaprActorClient.get_state", new=_async_mock()) + @mock.patch('tests.actor.fake_client.FakeDaprActorClient.get_state', new=_async_mock()) def test_get_state_for_no_state(self): state_manager = ActorStateManager(self._fake_actor) - has_value, val = _run(state_manager.try_get_state("state1")) + has_value, val = _run(state_manager.try_get_state('state1')) self.assertFalse(has_value) self.assertIsNone(val) # Test if the test value is empty string - self._fake_client.get_state.return_value = "" - has_value, val = _run(state_manager.try_get_state("state1")) + self._fake_client.get_state.return_value = '' + has_value, val = _run(state_manager.try_get_state('state1')) self.assertFalse(has_value) self.assertIsNone(val) @mock.patch( - "tests.actor.fake_client.FakeDaprActorClient.get_state", + 'tests.actor.fake_client.FakeDaprActorClient.get_state', new=_async_mock(return_value=b'"value1"'), ) def test_get_state_for_existing_value(self): state_manager = ActorStateManager(self._fake_actor) - has_value, val = _run(state_manager.try_get_state("state1")) + has_value, val = _run(state_manager.try_get_state('state1')) self.assertTrue(has_value) - self.assertEqual("value1", val) + self.assertEqual('value1', val) @mock.patch( - "tests.actor.fake_client.FakeDaprActorClient.get_state", + 'tests.actor.fake_client.FakeDaprActorClient.get_state', new=_async_mock(return_value=b'"value1"'), ) def test_get_state_for_removed_value(self): state_manager = ActorStateManager(self._fake_actor) state_change_tracker = state_manager._get_contextual_state_tracker() - removed = _run(state_manager.try_remove_state("state1")) + removed = _run(state_manager.try_remove_state('state1')) self.assertTrue(removed) - state = state_change_tracker["state1"] + state = state_change_tracker['state1'] self.assertEqual(StateChangeKind.remove, state.change_kind) - has_value, val = _run(state_manager.try_get_state("state1")) + has_value, val = _run(state_manager.try_get_state('state1')) self.assertFalse(has_value) self.assertIsNone(val) - @mock.patch("tests.actor.fake_client.FakeDaprActorClient.get_state", new=_async_mock()) + @mock.patch('tests.actor.fake_client.FakeDaprActorClient.get_state', new=_async_mock()) def test_set_state_for_new_state(self): state_manager = ActorStateManager(self._fake_actor) state_change_tracker = state_manager._get_contextual_state_tracker() - _run(state_manager.set_state("state1", "value1")) + _run(state_manager.set_state('state1', 'value1')) - state = state_change_tracker["state1"] + state = state_change_tracker['state1'] self.assertEqual(StateChangeKind.add, state.change_kind) - self.assertEqual("value1", state.value) + self.assertEqual('value1', state.value) - @mock.patch("tests.actor.fake_client.FakeDaprActorClient.get_state", new=_async_mock()) + @mock.patch('tests.actor.fake_client.FakeDaprActorClient.get_state', new=_async_mock()) def test_set_state_for_existing_state_only_in_mem(self): state_manager = ActorStateManager(self._fake_actor) state_change_tracker = state_manager._get_contextual_state_tracker() - _run(state_manager.set_state("state1", "value1")) + _run(state_manager.set_state('state1', 'value1')) - state = state_change_tracker["state1"] + state = state_change_tracker['state1'] self.assertEqual(StateChangeKind.add, state.change_kind) - self.assertEqual("value1", state.value) + self.assertEqual('value1', state.value) - _run(state_manager.set_state("state1", "value2")) - state = state_change_tracker["state1"] + _run(state_manager.set_state('state1', 'value2')) + state = state_change_tracker['state1'] self.assertEqual(StateChangeKind.add, state.change_kind) - self.assertEqual("value2", state.value) + self.assertEqual('value2', state.value) @mock.patch( - "tests.actor.fake_client.FakeDaprActorClient.get_state", + 'tests.actor.fake_client.FakeDaprActorClient.get_state', new=_async_mock(return_value=b'"value1"'), ) def test_set_state_for_existing_state(self): state_manager = ActorStateManager(self._fake_actor) state_change_tracker = state_manager._get_contextual_state_tracker() - _run(state_manager.set_state("state1", "value2")) - state = state_change_tracker["state1"] + _run(state_manager.set_state('state1', 'value2')) + state = state_change_tracker['state1'] self.assertEqual(StateChangeKind.update, state.change_kind) - self.assertEqual("value2", state.value) + self.assertEqual('value2', state.value) - @mock.patch("tests.actor.fake_client.FakeDaprActorClient.get_state", new=_async_mock()) + @mock.patch('tests.actor.fake_client.FakeDaprActorClient.get_state', new=_async_mock()) def test_remove_state_for_non_existing_state(self): state_manager = ActorStateManager(self._fake_actor) - removed = _run(state_manager.try_remove_state("state1")) + removed = _run(state_manager.try_remove_state('state1')) self.assertFalse(removed) @mock.patch( - "tests.actor.fake_client.FakeDaprActorClient.get_state", + 'tests.actor.fake_client.FakeDaprActorClient.get_state', new=_async_mock(return_value=b'"value1"'), ) def test_remove_state_for_existing_state(self): state_manager = ActorStateManager(self._fake_actor) state_change_tracker = state_manager._get_contextual_state_tracker() - removed = _run(state_manager.try_remove_state("state1")) + removed = _run(state_manager.try_remove_state('state1')) self.assertTrue(removed) - state = state_change_tracker["state1"] + state = state_change_tracker['state1'] self.assertEqual(StateChangeKind.remove, state.change_kind) - @mock.patch("tests.actor.fake_client.FakeDaprActorClient.get_state", new=_async_mock()) + @mock.patch('tests.actor.fake_client.FakeDaprActorClient.get_state', new=_async_mock()) def test_remove_state_for_existing_state_in_mem(self): state_manager = ActorStateManager(self._fake_actor) - _run(state_manager.set_state("state1", "value1")) - removed = _run(state_manager.try_remove_state("state1")) + _run(state_manager.set_state('state1', 'value1')) + removed = _run(state_manager.try_remove_state('state1')) self.assertTrue(removed) - @mock.patch("tests.actor.fake_client.FakeDaprActorClient.get_state", new=_async_mock()) + @mock.patch('tests.actor.fake_client.FakeDaprActorClient.get_state', new=_async_mock()) def test_remove_state_twice_for_existing_state_in_mem(self): state_manager = ActorStateManager(self._fake_actor) - _run(state_manager.set_state("state1", "value1")) - removed = _run(state_manager.try_remove_state("state1")) + _run(state_manager.set_state('state1', 'value1')) + removed = _run(state_manager.try_remove_state('state1')) self.assertTrue(removed) - removed = _run(state_manager.try_remove_state("state1")) + removed = _run(state_manager.try_remove_state('state1')) self.assertFalse(removed) - @mock.patch("tests.actor.fake_client.FakeDaprActorClient.get_state", new=_async_mock()) + @mock.patch('tests.actor.fake_client.FakeDaprActorClient.get_state', new=_async_mock()) def test_contains_state_for_removed_state(self): state_manager = ActorStateManager(self._fake_actor) - _run(state_manager.set_state("state1", "value1")) + _run(state_manager.set_state('state1', 'value1')) - exist = _run(state_manager.contains_state("state1")) + exist = _run(state_manager.contains_state('state1')) self.assertTrue(exist) @mock.patch( - "tests.actor.fake_client.FakeDaprActorClient.get_state", + 'tests.actor.fake_client.FakeDaprActorClient.get_state', new=_async_mock(return_value=b'"value1"'), ) def test_contains_state_for_existing_state(self): state_manager = ActorStateManager(self._fake_actor) - exist = _run(state_manager.contains_state("state1")) + exist = _run(state_manager.contains_state('state1')) self.assertTrue(exist) @mock.patch( - "tests.actor.fake_client.FakeDaprActorClient.get_state", + 'tests.actor.fake_client.FakeDaprActorClient.get_state', new=_async_mock(return_value=b'"value1"'), ) def test_get_or_add_state_for_existing_state(self): state_manager = ActorStateManager(self._fake_actor) - val = _run(state_manager.get_or_add_state("state1", "value2")) - self.assertEqual("value1", val) + val = _run(state_manager.get_or_add_state('state1', 'value2')) + self.assertEqual('value1', val) - @mock.patch("tests.actor.fake_client.FakeDaprActorClient.get_state", new=_async_mock()) + @mock.patch('tests.actor.fake_client.FakeDaprActorClient.get_state', new=_async_mock()) def test_get_or_add_state_for_non_existing_state(self): state_manager = ActorStateManager(self._fake_actor) state_change_tracker = state_manager._get_contextual_state_tracker() - val = _run(state_manager.get_or_add_state("state1", "value2")) + val = _run(state_manager.get_or_add_state('state1', 'value2')) - state = state_change_tracker["state1"] + state = state_change_tracker['state1'] self.assertEqual(StateChangeKind.add, state.change_kind) - self.assertEqual("value2", val) + self.assertEqual('value2', val) self._fake_client.get_state.mock.assert_called_once_with( - self._test_type_info._name, self._test_actor_id.id, "state1" + self._test_type_info._name, self._test_actor_id.id, 'state1' ) @mock.patch( - "tests.actor.fake_client.FakeDaprActorClient.get_state", + 'tests.actor.fake_client.FakeDaprActorClient.get_state', new=_async_mock(return_value=b'"value1"'), ) def test_get_or_add_state_for_removed_state(self): state_manager = ActorStateManager(self._fake_actor) state_change_tracker = state_manager._get_contextual_state_tracker() - _run(state_manager.remove_state("state1")) - state = state_change_tracker["state1"] + _run(state_manager.remove_state('state1')) + state = state_change_tracker['state1'] self.assertEqual(StateChangeKind.remove, state.change_kind) - val = _run(state_manager.get_or_add_state("state1", "value2")) - state = state_change_tracker["state1"] + val = _run(state_manager.get_or_add_state('state1', 'value2')) + state = state_change_tracker['state1'] self.assertEqual(StateChangeKind.update, state.change_kind) - self.assertEqual("value2", val) + self.assertEqual('value2', val) - @mock.patch("tests.actor.fake_client.FakeDaprActorClient.get_state", new=_async_mock()) + @mock.patch('tests.actor.fake_client.FakeDaprActorClient.get_state', new=_async_mock()) def test_add_or_update_state_for_new_state(self): """adds state if state does not exist.""" def test_update_value(name, value): - return f"{name}-{value}" + return f'{name}-{value}' state_manager = ActorStateManager(self._fake_actor) state_change_tracker = state_manager._get_contextual_state_tracker() - val = _run(state_manager.add_or_update_state("state1", "value1", test_update_value)) - self.assertEqual("value1", val) - state = state_change_tracker["state1"] + val = _run(state_manager.add_or_update_state('state1', 'value1', test_update_value)) + self.assertEqual('value1', val) + state = state_change_tracker['state1'] self.assertEqual(StateChangeKind.add, state.change_kind) @mock.patch( - "tests.actor.fake_client.FakeDaprActorClient.get_state", + 'tests.actor.fake_client.FakeDaprActorClient.get_state', new=_async_mock(return_value=b'"value1"'), ) def test_add_or_update_state_for_state_in_storage(self): @@ -258,108 +258,108 @@ def test_add_or_update_state_for_state_in_storage(self): in the storage.""" def test_update_value(name, value): - return f"{name}-{value}" + return f'{name}-{value}' state_manager = ActorStateManager(self._fake_actor) state_change_tracker = state_manager._get_contextual_state_tracker() - val = _run(state_manager.add_or_update_state("state1", "value1", test_update_value)) - self.assertEqual("state1-value1", val) - state = state_change_tracker["state1"] + val = _run(state_manager.add_or_update_state('state1', 'value1', test_update_value)) + self.assertEqual('state1-value1', val) + state = state_change_tracker['state1'] self.assertEqual(StateChangeKind.update, state.change_kind) @mock.patch( - "tests.actor.fake_client.FakeDaprActorClient.get_state", + 'tests.actor.fake_client.FakeDaprActorClient.get_state', new=_async_mock(return_value=b'"value1"'), ) def test_add_or_update_state_for_removed_state(self): """add state value if state was removed.""" def test_update_value(name, value): - return f"{name}-{value}" + return f'{name}-{value}' state_manager = ActorStateManager(self._fake_actor) - _run(state_manager.remove_state("state1")) + _run(state_manager.remove_state('state1')) - val = _run(state_manager.add_or_update_state("state1", "value1", test_update_value)) - self.assertEqual("value1", val) + val = _run(state_manager.add_or_update_state('state1', 'value1', test_update_value)) + self.assertEqual('value1', val) @mock.patch( - "tests.actor.fake_client.FakeDaprActorClient.get_state", + 'tests.actor.fake_client.FakeDaprActorClient.get_state', new=_async_mock(return_value=b'"value1"'), ) def test_add_or_update_state_for_none_state_key(self): """update state value for StateChangeKind.none state""" def test_update_value(name, value): - return f"{name}-{value}" + return f'{name}-{value}' state_manager = ActorStateManager(self._fake_actor) - has_value, val = _run(state_manager.try_get_state("state1")) + has_value, val = _run(state_manager.try_get_state('state1')) self.assertTrue(has_value) - self.assertEqual("value1", val) + self.assertEqual('value1', val) - val = _run(state_manager.add_or_update_state("state1", "value1", test_update_value)) - self.assertEqual("state1-value1", val) + val = _run(state_manager.add_or_update_state('state1', 'value1', test_update_value)) + self.assertEqual('state1-value1', val) def test_add_or_update_state_without_update_value_factory(self): """tries to add or update state without update_value_factory""" state_manager = ActorStateManager(self._fake_actor) with self.assertRaises(AttributeError): - _run(state_manager.add_or_update_state("state1", "value1", None)) + _run(state_manager.add_or_update_state('state1', 'value1', None)) - @mock.patch("tests.actor.fake_client.FakeDaprActorClient.get_state", new=_async_mock()) + @mock.patch('tests.actor.fake_client.FakeDaprActorClient.get_state', new=_async_mock()) def test_get_state_names(self): state_manager = ActorStateManager(self._fake_actor) - _run(state_manager.set_state("state1", "value1")) - _run(state_manager.set_state("state2", "value2")) - _run(state_manager.set_state("state3", "value3")) + _run(state_manager.set_state('state1', 'value1')) + _run(state_manager.set_state('state2', 'value2')) + _run(state_manager.set_state('state3', 'value3')) names = _run(state_manager.get_state_names()) - self.assertEqual(["state1", "state2", "state3"], names) + self.assertEqual(['state1', 'state2', 'state3'], names) self._fake_client.get_state.mock.assert_any_call( - self._test_type_info._name, self._test_actor_id.id, "state1" + self._test_type_info._name, self._test_actor_id.id, 'state1' ) self._fake_client.get_state.mock.assert_any_call( - self._test_type_info._name, self._test_actor_id.id, "state2" + self._test_type_info._name, self._test_actor_id.id, 'state2' ) self._fake_client.get_state.mock.assert_any_call( - self._test_type_info._name, self._test_actor_id.id, "state3" + self._test_type_info._name, self._test_actor_id.id, 'state3' ) @mock.patch( - "tests.actor.fake_client.FakeDaprActorClient.get_state", + 'tests.actor.fake_client.FakeDaprActorClient.get_state', new=_async_mock(return_value=b'"value0"'), ) def test_clear_cache(self): state_manager = ActorStateManager(self._fake_actor) state_change_tracker = state_manager._get_contextual_state_tracker() - _run(state_manager.set_state("state1", "value1")) - _run(state_manager.set_state("state2", "value2")) - _run(state_manager.set_state("state3", "value3")) + _run(state_manager.set_state('state1', 'value1')) + _run(state_manager.set_state('state2', 'value2')) + _run(state_manager.set_state('state3', 'value3')) _run(state_manager.clear_cache()) self.assertEqual(0, len(state_change_tracker)) @mock.patch( - "tests.actor.fake_client.FakeDaprActorClient.get_state", + 'tests.actor.fake_client.FakeDaprActorClient.get_state', new=_async_mock(return_value=b'"value3"'), ) @mock.patch( - "tests.actor.fake_client.FakeDaprActorClient.save_state_transactionally", new=_async_mock() + 'tests.actor.fake_client.FakeDaprActorClient.save_state_transactionally', new=_async_mock() ) def test_save_state(self): state_manager = ActorStateManager(self._fake_actor) # set states which are StateChangeKind.add - _run(state_manager.set_state("state1", "value1")) - _run(state_manager.set_state("state2", "value2")) + _run(state_manager.set_state('state1', 'value1')) + _run(state_manager.set_state('state2', 'value2')) - has_value, val = _run(state_manager.try_get_state("state3")) + has_value, val = _run(state_manager.try_get_state('state3')) self.assertTrue(has_value) - self.assertEqual("value3", val) + self.assertEqual('value3', val) # set state which is StateChangeKind.remove - _run(state_manager.remove_state("state4")) + _run(state_manager.remove_state('state4')) # set state which is StateChangeKind.update - _run(state_manager.set_state("state5", "value5")) + _run(state_manager.set_state('state5', 'value5')) expected = b'[{"operation":"upsert","request":{"key":"state1","value":"value1"}},{"operation":"upsert","request":{"key":"state2","value":"value2"}},{"operation":"delete","request":{"key":"state4"}},{"operation":"upsert","request":{"key":"state5","value":"value5"}}]' # noqa: E501 # Save the state @@ -370,5 +370,5 @@ def mock_save_state(actor_type, actor_id, data): _run(state_manager.save_state()) -if __name__ == "__main__": +if __name__ == '__main__': unittest.main() diff --git a/tests/actor/test_timer_data.py b/tests/actor/test_timer_data.py index eb182327..ba410cec 100644 --- a/tests/actor/test_timer_data.py +++ b/tests/actor/test_timer_data.py @@ -26,16 +26,16 @@ def my_callback(input: Any): print(input) timer = ActorTimerData( - "timer_name", + 'timer_name', my_callback, - "called", + 'called', timedelta(seconds=2), timedelta(seconds=1), timedelta(seconds=3), ) - self.assertEqual("timer_name", timer.timer_name) - self.assertEqual("my_callback", timer.callback) - self.assertEqual("called", timer.state) + self.assertEqual('timer_name', timer.timer_name) + self.assertEqual('my_callback', timer.callback) + self.assertEqual('called', timer.state) self.assertEqual(timedelta(seconds=2), timer.due_time) self.assertEqual(timedelta(seconds=1), timer.period) self.assertEqual(timedelta(seconds=3), timer.ttl) @@ -45,18 +45,18 @@ def my_callback(input: Any): print(input) timer = ActorTimerData( - "timer_name", + 'timer_name', my_callback, - "called", + 'called', timedelta(seconds=1), timedelta(seconds=1), timedelta(seconds=1), ) expected = { - "callback": "my_callback", - "data": "called", - "dueTime": timedelta(seconds=1), - "period": timedelta(seconds=1), - "ttl": timedelta(seconds=1), + 'callback': 'my_callback', + 'data': 'called', + 'dueTime': timedelta(seconds=1), + 'period': timedelta(seconds=1), + 'ttl': timedelta(seconds=1), } self.assertDictEqual(expected, timer.as_dict()) diff --git a/tests/actor/test_type_utils.py b/tests/actor/test_type_utils.py index 3e470008..f8b2eee2 100644 --- a/tests/actor/test_type_utils.py +++ b/tests/actor/test_type_utils.py @@ -36,11 +36,11 @@ class TypeUtilsTests(unittest.TestCase): def test_get_class_method_args(self): args = get_class_method_args(FakeSimpleActor.actor_method) - self.assertEqual(args, ["arg"]) + self.assertEqual(args, ['arg']) def test_get_method_arg_types(self): arg_types = get_method_arg_types(FakeSimpleActor.non_actor_method) - self.assertEqual(arg_types, [type(int(30)), type(str("102")), type(float(10.0))]) + self.assertEqual(arg_types, [type(int(30)), type(str('102')), type(float(10.0))]) def test_get_return_types(self): rtn_type = get_method_return_types(FakeSimpleActor.actor_method) @@ -69,10 +69,10 @@ def test_get_actor_interface(self): def test_get_dispatchable_attrs(self): dispatchable_attrs = get_dispatchable_attrs(FakeMultiInterfacesActor) expected_dispatchable_attrs = [ - "ActorCls1Method", - "ActorCls1Method1", - "ActorCls1Method2", - "ActorCls2Method", + 'ActorCls1Method', + 'ActorCls1Method1', + 'ActorCls1Method2', + 'ActorCls2Method', ] method_cnt = 0 diff --git a/tests/clients/certs.py b/tests/clients/certs.py index d32d10b3..5fb9b8a6 100644 --- a/tests/clients/certs.py +++ b/tests/clients/certs.py @@ -2,35 +2,35 @@ from OpenSSL import crypto -PRIVATE_KEY_PATH = os.path.join(os.path.dirname(__file__), "private.key") -CERTIFICATE_CHAIN_PATH = os.path.join(os.path.dirname(__file__), "selfsigned.pem") +PRIVATE_KEY_PATH = os.path.join(os.path.dirname(__file__), 'private.key') +CERTIFICATE_CHAIN_PATH = os.path.join(os.path.dirname(__file__), 'selfsigned.pem') -def create_certificates(server_type="grpc"): +def create_certificates(server_type='grpc'): # create a key pair k = crypto.PKey() k.generate_key(crypto.TYPE_RSA, 4096) # create a self-signed cert cert = crypto.X509() - cert.get_subject().organizationName = "Dapr" - cert.get_subject().commonName = "localhost" + cert.get_subject().organizationName = 'Dapr' + cert.get_subject().commonName = 'localhost' cert.gmtime_adj_notBefore(0) cert.gmtime_adj_notAfter(24 * 60 * 60) cert.set_issuer(cert.get_subject()) cert.set_pubkey(k) - if server_type == "http": - cert.add_extensions([crypto.X509Extension(b"subjectAltName", False, b"DNS:localhost")]) + if server_type == 'http': + cert.add_extensions([crypto.X509Extension(b'subjectAltName', False, b'DNS:localhost')]) - cert.sign(k, "sha512") + cert.sign(k, 'sha512') - f_cert = open(CERTIFICATE_CHAIN_PATH, "wt") - f_cert.write(crypto.dump_certificate(crypto.FILETYPE_PEM, cert).decode("utf-8")) + f_cert = open(CERTIFICATE_CHAIN_PATH, 'wt') + f_cert.write(crypto.dump_certificate(crypto.FILETYPE_PEM, cert).decode('utf-8')) f_cert.close() - f_key = open(PRIVATE_KEY_PATH, "wt") - f_key.write(crypto.dump_privatekey(crypto.FILETYPE_PEM, k).decode("utf-8")) + f_key = open(PRIVATE_KEY_PATH, 'wt') + f_key.write(crypto.dump_privatekey(crypto.FILETYPE_PEM, k).decode('utf-8')) f_key.close() diff --git a/tests/clients/fake_dapr_server.py b/tests/clients/fake_dapr_server.py index 7e2d87b8..255249f6 100644 --- a/tests/clients/fake_dapr_server.py +++ b/tests/clients/fake_dapr_server.py @@ -50,17 +50,17 @@ def __init__(self): self.metadata: Dict[str, str] = {} def start(self, port: int = 8080): - self._server.add_insecure_port(f"[::]:{port}") + self._server.add_insecure_port(f'[::]:{port}') self._server.start() def start_secure(self, port: int = 4443): create_certificates() - private_key_file = open(PRIVATE_KEY_PATH, "rb") + private_key_file = open(PRIVATE_KEY_PATH, 'rb') private_key_content = private_key_file.read() private_key_file.close() - certificate_chain_file = open(CERTIFICATE_CHAIN_PATH, "rb") + certificate_chain_file = open(CERTIFICATE_CHAIN_PATH, 'rb') certificate_chain_content = certificate_chain_file.read() certificate_chain_file.close() @@ -68,7 +68,7 @@ def start_secure(self, port: int = 4443): [(private_key_content, certificate_chain_content)] ) - self._server.add_secure_port(f"[::]:{port}", credentials) + self._server.add_secure_port(f'[::]:{port}', credentials) self._server.start() def stop(self): @@ -83,13 +83,13 @@ def InvokeService(self, request, context) -> common_v1.InvokeResponse: trailers = () for k, v in context.invocation_metadata(): - headers = headers + (("h" + k, v),) - trailers = trailers + (("t" + k, v),) + headers = headers + (('h' + k, v),) + trailers = trailers + (('t' + k, v),) resp = GrpcAny() - content_type = "" + content_type = '' - if request.message.method == "bytes": + if request.message.method == 'bytes': resp.value = request.message.data.value content_type = request.message.content_type else: @@ -105,13 +105,13 @@ def InvokeBinding(self, request, context) -> api_v1.InvokeBindingResponse: trailers = () for k, v in request.metadata.items(): - headers = headers + (("h" + k, v),) - trailers = trailers + (("t" + k, v),) + headers = headers + (('h' + k, v),) + trailers = trailers + (('t' + k, v),) - resp_data = b"INVALID" + resp_data = b'INVALID' metadata = {} - if request.operation == "create": + if request.operation == 'create': resp_data = request.data metadata = request.metadata @@ -124,18 +124,18 @@ def PublishEvent(self, request, context): headers = () trailers = () if request.topic: - headers = headers + (("htopic", request.topic),) - trailers = trailers + (("ttopic", request.topic),) + headers = headers + (('htopic', request.topic),) + trailers = trailers + (('ttopic', request.topic),) if request.data: - headers = headers + (("hdata", request.data),) - trailers = trailers + (("hdata", request.data),) + headers = headers + (('hdata', request.data),) + trailers = trailers + (('hdata', request.data),) if request.data_content_type: - headers = headers + (("data_content_type", request.data_content_type),) - trailers = trailers + (("data_content_type", request.data_content_type),) - if request.metadata["rawPayload"]: - headers = headers + (("metadata_raw_payload", request.metadata["rawPayload"]),) - if request.metadata["ttlInSeconds"]: - headers = headers + (("metadata_ttl_in_seconds", request.metadata["ttlInSeconds"]),) + headers = headers + (('data_content_type', request.data_content_type),) + trailers = trailers + (('data_content_type', request.data_content_type),) + if request.metadata['rawPayload']: + headers = headers + (('metadata_raw_payload', request.metadata['rawPayload']),) + if request.metadata['ttlInSeconds']: + headers = headers + (('metadata_ttl_in_seconds', request.metadata['ttlInSeconds']),) context.send_initial_metadata(headers) context.set_trailing_metadata(trailers) @@ -146,12 +146,12 @@ def SaveState(self, request, context): trailers = () for state in request.states: data = state.value - if state.metadata["capitalize"]: - data = to_bytes(data.decode("utf-8").capitalize()) - if state.HasField("etag"): + if state.metadata['capitalize']: + data = to_bytes(data.decode('utf-8').capitalize()) + if state.HasField('etag'): self.store[state.key] = (data, state.etag.value) else: - self.store[state.key] = (data, "ETAG_WAS_NONE") + self.store[state.key] = (data, 'ETAG_WAS_NONE') context.send_initial_metadata(headers) context.set_trailing_metadata(trailers) @@ -161,11 +161,11 @@ def ExecuteStateTransaction(self, request, context): headers = () trailers = () for operation in request.operations: - if operation.operationType == "delete": + if operation.operationType == 'delete': del self.store[operation.request.key] else: - etag = "ETAG_WAS_NONE" - if operation.request.HasField("etag"): + etag = 'ETAG_WAS_NONE' + if operation.request.HasField('etag'): etag = operation.request.etag.value self.store[operation.request.key] = (operation.request.value, etag) @@ -179,8 +179,8 @@ def GetState(self, request, context): return empty_pb2.Empty() else: data, etag = self.store[key] - if request.metadata["upper"]: - data = to_bytes(data.decode("utf-8").upper()) + if request.metadata['upper']: + data = to_bytes(data.decode('utf-8').upper()) return api_v1.GetStateResponse(data=data, etag=etag) def GetBulkState(self, request, context): @@ -190,8 +190,8 @@ def GetBulkState(self, request, context): res = self.GetState(req, context) data = res.data etag = res.etag - if request.metadata["upper"]: - data = to_bytes(data.decode("utf-8").upper()) + if request.metadata['upper']: + data = to_bytes(data.decode('utf-8').upper()) items.append(api_v1.BulkStateItem(key=key, etag=etag, data=data)) return api_v1.GetBulkStateResponse(items=items) @@ -202,8 +202,8 @@ def DeleteState(self, request, context): if key in self.store: del self.store[key] else: - if request.metadata["must_delete"]: - raise ValueError("delete failed") + if request.metadata['must_delete']: + raise ValueError('delete failed') context.send_initial_metadata(headers) context.set_trailing_metadata(trailers) @@ -215,10 +215,10 @@ def GetSecret(self, request, context) -> api_v1.GetSecretResponse: key = request.key - headers = headers + (("keyh", key),) - trailers = trailers + (("keyt", key),) + headers = headers + (('keyh', key),) + trailers = trailers + (('keyt', key),) - resp = {key: "val"} + resp = {key: 'val'} context.send_initial_metadata(headers) context.set_trailing_metadata(trailers) @@ -229,10 +229,10 @@ def GetBulkSecret(self, request, context) -> api_v1.GetBulkSecretResponse: headers = () trailers = () - headers = headers + (("keyh", "bulk"),) - trailers = trailers + (("keyt", "bulk"),) + headers = headers + (('keyh', 'bulk'),) + trailers = trailers + (('keyt', 'bulk'),) - resp = {"keya": api_v1.SecretResponse(secrets={"keyb": "val"})} + resp = {'keya': api_v1.SecretResponse(secrets={'keyb': 'val'})} context.send_initial_metadata(headers) context.set_trailing_metadata(trailers) @@ -242,13 +242,13 @@ def GetBulkSecret(self, request, context) -> api_v1.GetBulkSecretResponse: def GetConfiguration(self, request, context): items = dict() for key in request.keys: - items[str(key)] = ConfigurationItem(value="value", version="1.5.0") + items[str(key)] = ConfigurationItem(value='value', version='1.5.0') return api_v1.GetConfigurationResponse(items=items) def SubscribeConfiguration(self, request, context): items = [] for key in request.keys: - item = {"key": key, "value": "value", "version": "1.5.0", "metadata": {}} + item = {'key': key, 'value': 'value', 'version': '1.5.0', 'metadata': {}} items.append(item) response = {items: items} responses = [] @@ -260,19 +260,19 @@ def UnsubscribeConfiguration(self, request, context): def QueryStateAlpha1(self, request, context): items = [ - QueryStateItem(key=str(key), data=bytes("value of " + str(key), "UTF-8")) + QueryStateItem(key=str(key), data=bytes('value of ' + str(key), 'UTF-8')) for key in range(1, 11) ] query = json.loads(request.query) tokenIndex = 1 - if "page" in query: - if "token" in query["page"]: + if 'page' in query: + if 'token' in query['page']: # For testing purposes, we return a token that is the same as the key - tokenIndex = int(query["page"]["token"]) + tokenIndex = int(query['page']['token']) items = items[tokenIndex - 1 :] - if "limit" in query["page"]: - limit = int(query["page"]["limit"]) + if 'limit' in query['page']: + limit = int(query['page']['limit']) if len(items) > limit: items = items[:limit] tokenIndex = tokenIndex + len(items) @@ -308,16 +308,16 @@ def StartWorkflowBeta1(self, request: StartWorkflowRequest, context): return StartWorkflowResponse(instance_id=instance_id) else: # workflow already running - raise Exception("Unable to start insance of the workflow") + raise Exception('Unable to start insance of the workflow') def GetWorkflowBeta1(self, request: GetWorkflowRequest, context): instance_id = request.instance_id if instance_id in self.workflow_status: - status = str(self.workflow_status[instance_id])[len("WorkflowRuntimeStatus.") :] + status = str(self.workflow_status[instance_id])[len('WorkflowRuntimeStatus.') :] return GetWorkflowResponse( instance_id=instance_id, - workflow_name="example", + workflow_name='example', created_at=None, last_updated_at=None, runtime_status=status, @@ -325,7 +325,7 @@ def GetWorkflowBeta1(self, request: GetWorkflowRequest, context): ) else: # workflow non-existent - raise Exception("Workflow instance does not exist") + raise Exception('Workflow instance does not exist') def PauseWorkflowBeta1(self, request: PauseWorkflowRequest, context): instance_id = request.instance_id @@ -335,7 +335,7 @@ def PauseWorkflowBeta1(self, request: PauseWorkflowRequest, context): return empty_pb2.Empty() else: # workflow non-existent - raise Exception("Workflow instance could not be paused") + raise Exception('Workflow instance could not be paused') def ResumeWorkflowBeta1(self, request: ResumeWorkflowRequest, context): instance_id = request.instance_id @@ -345,7 +345,7 @@ def ResumeWorkflowBeta1(self, request: ResumeWorkflowRequest, context): return empty_pb2.Empty() else: # workflow non-existent - raise Exception("Workflow instance could not be resumed") + raise Exception('Workflow instance could not be resumed') def TerminateWorkflowBeta1(self, request: TerminateWorkflowRequest, context): instance_id = request.instance_id @@ -355,7 +355,7 @@ def TerminateWorkflowBeta1(self, request: TerminateWorkflowRequest, context): return empty_pb2.Empty() else: # workflow non-existent - raise Exception("Workflow instance could not be terminated") + raise Exception('Workflow instance could not be terminated') def PurgeWorkflowBeta1(self, request: PurgeWorkflowRequest, context): instance_id = request.instance_id @@ -365,7 +365,7 @@ def PurgeWorkflowBeta1(self, request: PurgeWorkflowRequest, context): return empty_pb2.Empty() else: # workflow non-existent - raise Exception("Workflow instance could not be purged") + raise Exception('Workflow instance could not be purged') def RaiseEventWorkflowBeta1(self, request: RaiseEventWorkflowRequest, context): instance_id = request.instance_id @@ -374,35 +374,35 @@ def RaiseEventWorkflowBeta1(self, request: RaiseEventWorkflowRequest, context): self.workflow_options[instance_id] = request.event_data return empty_pb2.Empty() else: - raise Exception("Unable to raise event on workflow instance") + raise Exception('Unable to raise event on workflow instance') def GetMetadata(self, request, context): return GetMetadataResponse( - id="myapp", + id='myapp', active_actors_count=[ ActiveActorsCount( - type="Nichelle Nichols", + type='Nichelle Nichols', count=1, ), ], registered_components=[ RegisteredComponents( - name="lockstore", - type="lock.redis", - version="", + name='lockstore', + type='lock.redis', + version='', # Missing capabilities definition, ), RegisteredComponents( - name="pubsub", type="pubsub.redis", version="v1", capabilities=[] + name='pubsub', type='pubsub.redis', version='v1', capabilities=[] ), RegisteredComponents( - name="statestore", - type="state.redis", - version="v1", + name='statestore', + type='state.redis', + version='v1', capabilities=[ - "ETAG", - "TRANSACTIONAL", - "ACTOR", + 'ETAG', + 'TRANSACTIONAL', + 'ACTOR', ], ), ], diff --git a/tests/clients/fake_http_server.py b/tests/clients/fake_http_server.py index a84248bb..e019b3ff 100644 --- a/tests/clients/fake_http_server.py +++ b/tests/clients/fake_http_server.py @@ -13,7 +13,7 @@ class DaprHandler(BaseHTTPRequestHandler): - protocol_version = "HTTP/1.1" + protocol_version = 'HTTP/1.1' def serve_forever(self): while not self.running: @@ -24,15 +24,15 @@ def do_request(self, verb): time.sleep(self.server.sleep_time) self.received_verb = verb self.server.request_headers = self.headers - if "Content-Length" in self.headers: - content_length = int(self.headers["Content-Length"]) + if 'Content-Length' in self.headers: + content_length = int(self.headers['Content-Length']) self.server.request_body += self.rfile.read(content_length) self.send_response(self.server.response_code) for key, value in self.server.response_header_list: self.send_header(key, value) - self.send_header("Content-Length", str(len(self.server.response_body))) + self.send_header('Content-Length', str(len(self.server.response_body))) self.end_headers() self.server.path = self.path @@ -40,16 +40,16 @@ def do_request(self, verb): self.wfile.write(self.server.response_body) def do_GET(self): - self.do_request("GET") + self.do_request('GET') def do_POST(self): - self.do_request("POST") + self.do_request('POST') def do_PUT(self): - self.do_request("PUT") + self.do_request('PUT') def do_DELETE(self): - self.do_request("DELETE") + self.do_request('DELETE') class FakeHttpServer(Thread): @@ -58,18 +58,18 @@ def __init__(self, secure=False): self.secure = secure self.port = 4443 if secure else 8080 - self.server = HTTPServer(("localhost", self.port), DaprHandler) + self.server = HTTPServer(('localhost', self.port), DaprHandler) if self.secure: - create_certificates("http") + create_certificates('http') ssl_context = SSLContext(PROTOCOL_TLS_SERVER) ssl_context.load_cert_chain(CERTIFICATE_CHAIN_PATH, PRIVATE_KEY_PATH) self.server.socket = ssl_context.wrap_socket(self.server.socket, server_side=True) - self.server.response_body = b"" + self.server.response_body = b'' self.server.response_code = 200 self.server.response_header_list = [] - self.server.request_body = b"" + self.server.request_body = b'' self.server.sleep_time = None def get_port(self): diff --git a/tests/clients/test_client_interceptor.py b/tests/clients/test_client_interceptor.py index 8f694534..da654151 100644 --- a/tests/clients/test_client_interceptor.py +++ b/tests/clients/test_client_interceptor.py @@ -20,29 +20,29 @@ class DaprClientInterceptorTests(unittest.TestCase): def setUp(self): - self._fake_request = "fake request" + self._fake_request = 'fake request' def fake_continuation(self, call_details, request): return call_details def test_intercept_unary_unary_single_header(self): - interceptor = DaprClientInterceptor([("api-token", "test-token")]) - call_details = _ClientCallDetails("method1", 10, None, None, None, None) + interceptor = DaprClientInterceptor([('api-token', 'test-token')]) + call_details = _ClientCallDetails('method1', 10, None, None, None, None) response = interceptor.intercept_unary_unary( self.fake_continuation, call_details, self._fake_request ) self.assertIsNotNone(response) self.assertEqual(1, len(response.metadata)) - self.assertEqual([("api-token", "test-token")], response.metadata) + self.assertEqual([('api-token', 'test-token')], response.metadata) def test_intercept_unary_unary_existing_metadata(self): - interceptor = DaprClientInterceptor([("api-token", "test-token")]) - call_details = _ClientCallDetails("method1", 10, [("header", "value")], None, None, None) + interceptor = DaprClientInterceptor([('api-token', 'test-token')]) + call_details = _ClientCallDetails('method1', 10, [('header', 'value')], None, None, None) response = interceptor.intercept_unary_unary( self.fake_continuation, call_details, self._fake_request ) self.assertIsNotNone(response) self.assertEqual(2, len(response.metadata)) - self.assertEqual([("header", "value"), ("api-token", "test-token")], response.metadata) + self.assertEqual([('header', 'value'), ('api-token', 'test-token')], response.metadata) diff --git a/tests/clients/test_dapr_async_grpc_client.py b/tests/clients/test_dapr_async_grpc_client.py index 5374ab6c..f0539f76 100644 --- a/tests/clients/test_dapr_async_grpc_client.py +++ b/tests/clients/test_dapr_async_grpc_client.py @@ -38,7 +38,7 @@ class DaprGrpcClientAsyncTests(unittest.IsolatedAsyncioTestCase): server_port = 8080 - scheme = "" + scheme = '' def setUp(self): self._fake_dapr_server = FakeDaprSidecar() @@ -48,286 +48,286 @@ def tearDown(self): self._fake_dapr_server.stop() async def test_http_extension(self): - dapr = DaprGrpcClientAsync(f"{self.scheme}localhost:{self.server_port}") + dapr = DaprGrpcClientAsync(f'{self.scheme}localhost:{self.server_port}') # Test POST verb without querystring - ext = dapr._get_http_extension("POST") + ext = dapr._get_http_extension('POST') self.assertEqual(common_v1.HTTPExtension.Verb.POST, ext.verb) # Test Non-supported http verb with self.assertRaises(ValueError): - ext = dapr._get_http_extension("") + ext = dapr._get_http_extension('') # Test POST verb with querystring qs = ( - ("query1", "string1"), - ("query2", "string2"), - ("query1", "string 3"), + ('query1', 'string1'), + ('query2', 'string2'), + ('query1', 'string 3'), ) - ext = dapr._get_http_extension("POST", qs) + ext = dapr._get_http_extension('POST', qs) self.assertEqual(common_v1.HTTPExtension.Verb.POST, ext.verb) - self.assertEqual("query1=string1&query2=string2&query1=string+3", ext.querystring) + self.assertEqual('query1=string1&query2=string2&query1=string+3', ext.querystring) async def test_invoke_method_bytes_data(self): - dapr = DaprGrpcClientAsync(f"{self.scheme}localhost:{self.server_port}") + dapr = DaprGrpcClientAsync(f'{self.scheme}localhost:{self.server_port}') resp = await dapr.invoke_method( - app_id="targetId", - method_name="bytes", - data=b"haha", - content_type="text/plain", + app_id='targetId', + method_name='bytes', + data=b'haha', + content_type='text/plain', metadata=( - ("key1", "value1"), - ("key2", "value2"), + ('key1', 'value1'), + ('key2', 'value2'), ), - http_verb="PUT", + http_verb='PUT', ) - self.assertEqual(b"haha", resp.data) - self.assertEqual("text/plain", resp.content_type) + self.assertEqual(b'haha', resp.data) + self.assertEqual('text/plain', resp.content_type) self.assertEqual(3, len(resp.headers)) - self.assertEqual(["value1"], resp.headers["hkey1"]) + self.assertEqual(['value1'], resp.headers['hkey1']) async def test_invoke_method_no_data(self): - dapr = DaprGrpcClientAsync(f"{self.scheme}localhost:{self.server_port}") + dapr = DaprGrpcClientAsync(f'{self.scheme}localhost:{self.server_port}') resp = await dapr.invoke_method( - app_id="targetId", - method_name="bytes", - content_type="text/plain", + app_id='targetId', + method_name='bytes', + content_type='text/plain', metadata=( - ("key1", "value1"), - ("key2", "value2"), + ('key1', 'value1'), + ('key2', 'value2'), ), - http_verb="PUT", + http_verb='PUT', ) - self.assertEqual(b"", resp.data) - self.assertEqual("text/plain", resp.content_type) + self.assertEqual(b'', resp.data) + self.assertEqual('text/plain', resp.content_type) self.assertEqual(3, len(resp.headers)) - self.assertEqual(["value1"], resp.headers["hkey1"]) + self.assertEqual(['value1'], resp.headers['hkey1']) async def test_invoke_method_with_dapr_client(self): - dapr = DaprClient(f"{self.scheme}localhost:{self.server_port}") + dapr = DaprClient(f'{self.scheme}localhost:{self.server_port}') dapr.invocation_client = None # force to use grpc client resp = await dapr.invoke_method( - app_id="targetId", - method_name="bytes", - data=b"haha", - content_type="text/plain", + app_id='targetId', + method_name='bytes', + data=b'haha', + content_type='text/plain', metadata=( - ("key1", "value1"), - ("key2", "value2"), + ('key1', 'value1'), + ('key2', 'value2'), ), - http_verb="PUT", + http_verb='PUT', ) - self.assertEqual(b"haha", resp.data) - self.assertEqual("text/plain", resp.content_type) + self.assertEqual(b'haha', resp.data) + self.assertEqual('text/plain', resp.content_type) self.assertEqual(3, len(resp.headers)) - self.assertEqual(["value1"], resp.headers["hkey1"]) + self.assertEqual(['value1'], resp.headers['hkey1']) async def test_invoke_method_proto_data(self): - dapr = DaprGrpcClientAsync(f"{self.scheme}localhost:{self.server_port}") - req = common_v1.StateItem(key="test") + dapr = DaprGrpcClientAsync(f'{self.scheme}localhost:{self.server_port}') + req = common_v1.StateItem(key='test') resp = await dapr.invoke_method( - app_id="targetId", - method_name="proto", + app_id='targetId', + method_name='proto', data=req, metadata=( - ("key1", "value1"), - ("key2", "value2"), + ('key1', 'value1'), + ('key2', 'value2'), ), ) self.assertEqual(3, len(resp.headers)) - self.assertEqual(["value1"], resp.headers["hkey1"]) + self.assertEqual(['value1'], resp.headers['hkey1']) self.assertTrue(resp.is_proto()) # unpack to new protobuf object new_resp = common_v1.StateItem() resp.unpack(new_resp) - self.assertEqual("test", new_resp.key) + self.assertEqual('test', new_resp.key) async def test_invoke_binding_bytes_data(self): - dapr = DaprGrpcClientAsync(f"{self.scheme}localhost:{self.server_port}") + dapr = DaprGrpcClientAsync(f'{self.scheme}localhost:{self.server_port}') resp = await dapr.invoke_binding( - binding_name="binding", - operation="create", - data=b"haha", + binding_name='binding', + operation='create', + data=b'haha', binding_metadata={ - "key1": "value1", - "key2": "value2", + 'key1': 'value1', + 'key2': 'value2', }, ) - self.assertEqual(b"haha", resp.data) - self.assertEqual({"key1": "value1", "key2": "value2"}, resp.binding_metadata) + self.assertEqual(b'haha', resp.data) + self.assertEqual({'key1': 'value1', 'key2': 'value2'}, resp.binding_metadata) self.assertEqual(2, len(resp.headers)) - self.assertEqual(["value1"], resp.headers["hkey1"]) + self.assertEqual(['value1'], resp.headers['hkey1']) async def test_invoke_binding_no_metadata(self): - dapr = DaprGrpcClientAsync(f"{self.scheme}localhost:{self.server_port}") + dapr = DaprGrpcClientAsync(f'{self.scheme}localhost:{self.server_port}') resp = await dapr.invoke_binding( - binding_name="binding", - operation="create", - data=b"haha", + binding_name='binding', + operation='create', + data=b'haha', ) - self.assertEqual(b"haha", resp.data) + self.assertEqual(b'haha', resp.data) self.assertEqual({}, resp.binding_metadata) self.assertEqual(0, len(resp.headers)) async def test_invoke_binding_no_data(self): - dapr = DaprGrpcClientAsync(f"{self.scheme}localhost:{self.server_port}") + dapr = DaprGrpcClientAsync(f'{self.scheme}localhost:{self.server_port}') resp = await dapr.invoke_binding( - binding_name="binding", - operation="create", + binding_name='binding', + operation='create', ) - self.assertEqual(b"", resp.data) + self.assertEqual(b'', resp.data) self.assertEqual({}, resp.binding_metadata) self.assertEqual(0, len(resp.headers)) async def test_invoke_binding_no_create(self): - dapr = DaprGrpcClientAsync(f"{self.scheme}localhost:{self.server_port}") + dapr = DaprGrpcClientAsync(f'{self.scheme}localhost:{self.server_port}') resp = await dapr.invoke_binding( - binding_name="binding", - operation="delete", - data=b"haha", + binding_name='binding', + operation='delete', + data=b'haha', ) - self.assertEqual(b"INVALID", resp.data) + self.assertEqual(b'INVALID', resp.data) self.assertEqual({}, resp.binding_metadata) self.assertEqual(0, len(resp.headers)) async def test_publish_event(self): - dapr = DaprGrpcClientAsync(f"{self.scheme}localhost:{self.server_port}") - resp = await dapr.publish_event(pubsub_name="pubsub", topic_name="example", data=b"haha") + dapr = DaprGrpcClientAsync(f'{self.scheme}localhost:{self.server_port}') + resp = await dapr.publish_event(pubsub_name='pubsub', topic_name='example', data=b'haha') self.assertEqual(2, len(resp.headers)) - self.assertEqual(["haha"], resp.headers["hdata"]) + self.assertEqual(['haha'], resp.headers['hdata']) async def test_publish_event_with_content_type(self): - dapr = DaprGrpcClientAsync(f"{self.scheme}localhost:{self.server_port}") + dapr = DaprGrpcClientAsync(f'{self.scheme}localhost:{self.server_port}') resp = await dapr.publish_event( - pubsub_name="pubsub", - topic_name="example", + pubsub_name='pubsub', + topic_name='example', data=b'{"foo": "bar"}', - data_content_type="application/json", + data_content_type='application/json', ) self.assertEqual(3, len(resp.headers)) - self.assertEqual(['{"foo": "bar"}'], resp.headers["hdata"]) - self.assertEqual(["application/json"], resp.headers["data_content_type"]) + self.assertEqual(['{"foo": "bar"}'], resp.headers['hdata']) + self.assertEqual(['application/json'], resp.headers['data_content_type']) async def test_publish_event_with_metadata(self): - dapr = DaprGrpcClientAsync(f"{self.scheme}localhost:{self.server_port}") + dapr = DaprGrpcClientAsync(f'{self.scheme}localhost:{self.server_port}') resp = await dapr.publish_event( - pubsub_name="pubsub", - topic_name="example", + pubsub_name='pubsub', + topic_name='example', data=b'{"foo": "bar"}', - publish_metadata={"ttlInSeconds": "100", "rawPayload": "false"}, + publish_metadata={'ttlInSeconds': '100', 'rawPayload': 'false'}, ) print(resp.headers) - self.assertEqual(['{"foo": "bar"}'], resp.headers["hdata"]) - self.assertEqual(["false"], resp.headers["metadata_raw_payload"]) - self.assertEqual(["100"], resp.headers["metadata_ttl_in_seconds"]) + self.assertEqual(['{"foo": "bar"}'], resp.headers['hdata']) + self.assertEqual(['false'], resp.headers['metadata_raw_payload']) + self.assertEqual(['100'], resp.headers['metadata_ttl_in_seconds']) async def test_publish_error(self): - dapr = DaprGrpcClientAsync(f"{self.scheme}localhost:{self.server_port}") + dapr = DaprGrpcClientAsync(f'{self.scheme}localhost:{self.server_port}') with self.assertRaisesRegex(ValueError, "invalid type for data "): await dapr.publish_event( - pubsub_name="pubsub", - topic_name="example", + pubsub_name='pubsub', + topic_name='example', data=111, ) - @patch.object(settings, "DAPR_API_TOKEN", "test-token") + @patch.object(settings, 'DAPR_API_TOKEN', 'test-token') async def test_dapr_api_token_insertion(self): - dapr = DaprGrpcClientAsync(f"{self.scheme}localhost:{self.server_port}") + dapr = DaprGrpcClientAsync(f'{self.scheme}localhost:{self.server_port}') resp = await dapr.invoke_method( - app_id="targetId", - method_name="bytes", - data=b"haha", - content_type="text/plain", + app_id='targetId', + method_name='bytes', + data=b'haha', + content_type='text/plain', metadata=( - ("key1", "value1"), - ("key2", "value2"), + ('key1', 'value1'), + ('key2', 'value2'), ), ) - self.assertEqual(b"haha", resp.data) - self.assertEqual("text/plain", resp.content_type) + self.assertEqual(b'haha', resp.data) + self.assertEqual('text/plain', resp.content_type) self.assertEqual(4, len(resp.headers)) - self.assertEqual(["value1"], resp.headers["hkey1"]) - self.assertEqual(["test-token"], resp.headers["hdapr-api-token"]) + self.assertEqual(['value1'], resp.headers['hkey1']) + self.assertEqual(['test-token'], resp.headers['hdapr-api-token']) async def test_get_save_delete_state(self): - dapr = DaprGrpcClientAsync(f"{self.scheme}localhost:{self.server_port}") - key = "key_1" - value = "value_1" + dapr = DaprGrpcClientAsync(f'{self.scheme}localhost:{self.server_port}') + key = 'key_1' + value = 'value_1' options = StateOptions( consistency=Consistency.eventual, concurrency=Concurrency.first_write, ) await dapr.save_state( - store_name="statestore", + store_name='statestore', key=key, value=value, - etag="fake_etag", + etag='fake_etag', options=options, - state_metadata={"capitalize": "1"}, + state_metadata={'capitalize': '1'}, ) - resp = await dapr.get_state(store_name="statestore", key=key) + resp = await dapr.get_state(store_name='statestore', key=key) self.assertEqual(resp.data, to_bytes(value.capitalize())) - self.assertEqual(resp.etag, "fake_etag") + self.assertEqual(resp.etag, 'fake_etag') - resp = await dapr.get_state(store_name="statestore", key=key, state_metadata={"upper": "1"}) + resp = await dapr.get_state(store_name='statestore', key=key, state_metadata={'upper': '1'}) self.assertEqual(resp.data, to_bytes(value.upper())) - self.assertEqual(resp.etag, "fake_etag") + self.assertEqual(resp.etag, 'fake_etag') - resp = await dapr.get_state(store_name="statestore", key="NotValidKey") - self.assertEqual(resp.data, b"") - self.assertEqual(resp.etag, "") + resp = await dapr.get_state(store_name='statestore', key='NotValidKey') + self.assertEqual(resp.data, b'') + self.assertEqual(resp.etag, '') - await dapr.delete_state(store_name="statestore", key=key) - resp = await dapr.get_state(store_name="statestore", key=key) - self.assertEqual(resp.data, b"") - self.assertEqual(resp.etag, "") + await dapr.delete_state(store_name='statestore', key=key) + resp = await dapr.get_state(store_name='statestore', key=key) + self.assertEqual(resp.data, b'') + self.assertEqual(resp.etag, '') with self.assertRaises(Exception) as context: await dapr.delete_state( - store_name="statestore", key=key, state_metadata={"must_delete": "1"} + store_name='statestore', key=key, state_metadata={'must_delete': '1'} ) print(context.exception) - self.assertTrue("delete failed" in str(context.exception)) + self.assertTrue('delete failed' in str(context.exception)) async def test_get_save_state_etag_none(self): - dapr = DaprGrpcClientAsync(f"{self.scheme}localhost:{self.server_port}") + dapr = DaprGrpcClientAsync(f'{self.scheme}localhost:{self.server_port}') - value = "test" - no_etag_key = "no_etag" - empty_etag_key = "empty_etag" + value = 'test' + no_etag_key = 'no_etag' + empty_etag_key = 'empty_etag' await dapr.save_state( - store_name="statestore", + store_name='statestore', key=no_etag_key, value=value, ) - await dapr.save_state(store_name="statestore", key=empty_etag_key, value=value, etag="") + await dapr.save_state(store_name='statestore', key=empty_etag_key, value=value, etag='') - resp = await dapr.get_state(store_name="statestore", key=no_etag_key) + resp = await dapr.get_state(store_name='statestore', key=no_etag_key) self.assertEqual(resp.data, to_bytes(value)) - self.assertEqual(resp.etag, "ETAG_WAS_NONE") + self.assertEqual(resp.etag, 'ETAG_WAS_NONE') - resp = await dapr.get_state(store_name="statestore", key=empty_etag_key) + resp = await dapr.get_state(store_name='statestore', key=empty_etag_key) self.assertEqual(resp.data, to_bytes(value)) - self.assertEqual(resp.etag, "") + self.assertEqual(resp.etag, '') async def test_transaction_then_get_states(self): - dapr = DaprGrpcClientAsync(f"{self.scheme}localhost:{self.server_port}") + dapr = DaprGrpcClientAsync(f'{self.scheme}localhost:{self.server_port}') key = str(uuid.uuid4()) value = str(uuid.uuid4()) @@ -335,24 +335,24 @@ async def test_transaction_then_get_states(self): another_value = str(uuid.uuid4()) await dapr.execute_state_transaction( - store_name="statestore", + store_name='statestore', operations=[ - TransactionalStateOperation(key=key, data=value, etag="foo"), + TransactionalStateOperation(key=key, data=value, etag='foo'), TransactionalStateOperation(key=another_key, data=another_value), ], - transactional_metadata={"metakey": "metavalue"}, + transactional_metadata={'metakey': 'metavalue'}, ) - resp = await dapr.get_bulk_state(store_name="statestore", keys=[key, another_key]) + resp = await dapr.get_bulk_state(store_name='statestore', keys=[key, another_key]) self.assertEqual(resp.items[0].key, key) self.assertEqual(resp.items[0].data, to_bytes(value)) - self.assertEqual(resp.items[0].etag, "foo") + self.assertEqual(resp.items[0].etag, 'foo') self.assertEqual(resp.items[1].key, another_key) self.assertEqual(resp.items[1].data, to_bytes(another_value)) - self.assertEqual(resp.items[1].etag, "ETAG_WAS_NONE") + self.assertEqual(resp.items[1].etag, 'ETAG_WAS_NONE') resp = await dapr.get_bulk_state( - store_name="statestore", keys=[key, another_key], states_metadata={"upper": "1"} + store_name='statestore', keys=[key, another_key], states_metadata={'upper': '1'} ) self.assertEqual(resp.items[0].key, key) self.assertEqual(resp.items[0].data, to_bytes(value.upper())) @@ -360,7 +360,7 @@ async def test_transaction_then_get_states(self): self.assertEqual(resp.items[1].data, to_bytes(another_value.upper())) async def test_save_then_get_states(self): - dapr = DaprGrpcClientAsync(f"{self.scheme}localhost:{self.server_port}") + dapr = DaprGrpcClientAsync(f'{self.scheme}localhost:{self.server_port}') key = str(uuid.uuid4()) value = str(uuid.uuid4()) @@ -368,90 +368,90 @@ async def test_save_then_get_states(self): another_value = str(uuid.uuid4()) await dapr.save_bulk_state( - store_name="statestore", + store_name='statestore', states=[ - StateItem(key=key, value=value, metadata={"capitalize": "1"}), - StateItem(key=another_key, value=another_value, etag="1"), + StateItem(key=key, value=value, metadata={'capitalize': '1'}), + StateItem(key=another_key, value=another_value, etag='1'), ], - metadata=(("metakey", "metavalue"),), + metadata=(('metakey', 'metavalue'),), ) - resp = await dapr.get_bulk_state(store_name="statestore", keys=[key, another_key]) + resp = await dapr.get_bulk_state(store_name='statestore', keys=[key, another_key]) self.assertEqual(resp.items[0].key, key) - self.assertEqual(resp.items[0].etag, "ETAG_WAS_NONE") + self.assertEqual(resp.items[0].etag, 'ETAG_WAS_NONE') self.assertEqual(resp.items[0].data, to_bytes(value.capitalize())) self.assertEqual(resp.items[1].key, another_key) self.assertEqual(resp.items[1].data, to_bytes(another_value)) - self.assertEqual(resp.items[1].etag, "1") + self.assertEqual(resp.items[1].etag, '1') resp = await dapr.get_bulk_state( - store_name="statestore", keys=[key, another_key], states_metadata={"upper": "1"} + store_name='statestore', keys=[key, another_key], states_metadata={'upper': '1'} ) self.assertEqual(resp.items[0].key, key) - self.assertEqual(resp.items[0].etag, "ETAG_WAS_NONE") + self.assertEqual(resp.items[0].etag, 'ETAG_WAS_NONE') self.assertEqual(resp.items[0].data, to_bytes(value.upper())) self.assertEqual(resp.items[1].key, another_key) - self.assertEqual(resp.items[1].etag, "1") + self.assertEqual(resp.items[1].etag, '1') self.assertEqual(resp.items[1].data, to_bytes(another_value.upper())) async def test_get_secret(self): - dapr = DaprGrpcClientAsync(f"{self.scheme}localhost:{self.server_port}") - key1 = "key_1" + dapr = DaprGrpcClientAsync(f'{self.scheme}localhost:{self.server_port}') + key1 = 'key_1' resp = await dapr.get_secret( - store_name="store_1", + store_name='store_1', key=key1, metadata=( - ("key1", "value1"), - ("key2", "value2"), + ('key1', 'value1'), + ('key2', 'value2'), ), ) self.assertEqual(1, len(resp.headers)) - self.assertEqual([key1], resp.headers["keyh"]) - self.assertEqual({key1: "val"}, resp._secret) + self.assertEqual([key1], resp.headers['keyh']) + self.assertEqual({key1: 'val'}, resp._secret) async def test_get_secret_metadata_absent(self): - dapr = DaprGrpcClientAsync(f"{self.scheme}localhost:{self.server_port}") - key1 = "key_1" + dapr = DaprGrpcClientAsync(f'{self.scheme}localhost:{self.server_port}') + key1 = 'key_1' resp = await dapr.get_secret( - store_name="store_1", + store_name='store_1', key=key1, ) self.assertEqual(1, len(resp.headers)) - self.assertEqual([key1], resp.headers["keyh"]) - self.assertEqual({key1: "val"}, resp._secret) + self.assertEqual([key1], resp.headers['keyh']) + self.assertEqual({key1: 'val'}, resp._secret) async def test_get_bulk_secret(self): - dapr = DaprGrpcClientAsync(f"{self.scheme}localhost:{self.server_port}") + dapr = DaprGrpcClientAsync(f'{self.scheme}localhost:{self.server_port}') resp = await dapr.get_bulk_secret( - store_name="store_1", + store_name='store_1', metadata=( - ("key1", "value1"), - ("key2", "value2"), + ('key1', 'value1'), + ('key2', 'value2'), ), ) self.assertEqual(1, len(resp.headers)) - self.assertEqual(["bulk"], resp.headers["keyh"]) - self.assertEqual({"keya": {"keyb": "val"}}, resp._secrets) + self.assertEqual(['bulk'], resp.headers['keyh']) + self.assertEqual({'keya': {'keyb': 'val'}}, resp._secrets) async def test_get_bulk_secret_metadata_absent(self): - dapr = DaprGrpcClientAsync(f"{self.scheme}localhost:{self.server_port}") - resp = await dapr.get_bulk_secret(store_name="store_1") + dapr = DaprGrpcClientAsync(f'{self.scheme}localhost:{self.server_port}') + resp = await dapr.get_bulk_secret(store_name='store_1') self.assertEqual(1, len(resp.headers)) - self.assertEqual(["bulk"], resp.headers["keyh"]) - self.assertEqual({"keya": {"keyb": "val"}}, resp._secrets) + self.assertEqual(['bulk'], resp.headers['keyh']) + self.assertEqual({'keya': {'keyb': 'val'}}, resp._secrets) async def test_get_configuration(self): - dapr = DaprGrpcClientAsync(f"{self.scheme}localhost:{self.server_port}") - keys = ["k", "k1"] - value = "value" - version = "1.5.0" + dapr = DaprGrpcClientAsync(f'{self.scheme}localhost:{self.server_port}') + keys = ['k', 'k1'] + value = 'value' + version = '1.5.0' metadata = {} - resp = await dapr.get_configuration(store_name="configurationstore", keys=keys) + resp = await dapr.get_configuration(store_name='configurationstore', keys=keys) self.assertEqual(len(resp.items), len(keys)) self.assertIn(keys[0], resp.items) item = resp.items[keys[0]] @@ -460,7 +460,7 @@ async def test_get_configuration(self): self.assertEqual(item.metadata, metadata) resp = await dapr.get_configuration( - store_name="configurationstore", keys=keys, config_metadata=metadata + store_name='configurationstore', keys=keys, config_metadata=metadata ) self.assertEqual(len(resp.items), len(keys)) self.assertIn(keys[0], resp.items) @@ -470,72 +470,72 @@ async def test_get_configuration(self): self.assertEqual(item.metadata, metadata) async def test_subscribe_configuration(self): - dapr = DaprGrpcClientAsync(f"{self.scheme}localhost:{self.server_port}") + dapr = DaprGrpcClientAsync(f'{self.scheme}localhost:{self.server_port}') def mock_watch(self, stub, store_name, keys, handler, config_metadata): handler( - "id", + 'id', ConfigurationResponse( - items={"k": ConfigurationItem(value="test", version="1.7.0")} + items={'k': ConfigurationItem(value='test', version='1.7.0')} ), ) - return "id" + return 'id' def handler(id: str, resp: ConfigurationResponse): - self.assertEqual(resp.items["k"].value, "test") - self.assertEqual(resp.items["k"].version, "1.7.0") + self.assertEqual(resp.items['k'].value, 'test') + self.assertEqual(resp.items['k'].version, '1.7.0') - with patch.object(ConfigurationWatcher, "watch_configuration", mock_watch): + with patch.object(ConfigurationWatcher, 'watch_configuration', mock_watch): await dapr.subscribe_configuration( - store_name="configurationstore", keys=["k"], handler=handler + store_name='configurationstore', keys=['k'], handler=handler ) async def test_unsubscribe_configuration(self): - dapr = DaprGrpcClientAsync(f"{self.scheme}localhost:{self.server_port}") - res = await dapr.unsubscribe_configuration(store_name="configurationstore", id="k") + dapr = DaprGrpcClientAsync(f'{self.scheme}localhost:{self.server_port}') + res = await dapr.unsubscribe_configuration(store_name='configurationstore', id='k') self.assertTrue(res) async def test_query_state(self): - dapr = DaprGrpcClientAsync(f"{self.scheme}localhost:{self.server_port}") + dapr = DaprGrpcClientAsync(f'{self.scheme}localhost:{self.server_port}') resp = await dapr.query_state( - store_name="statestore", - query=json.dumps({"filter": {}, "page": {"limit": 2}}), + store_name='statestore', + query=json.dumps({'filter': {}, 'page': {'limit': 2}}), ) - self.assertEqual(resp.results[0].key, "1") + self.assertEqual(resp.results[0].key, '1') self.assertEqual(len(resp.results), 2) resp = await dapr.query_state( - store_name="statestore", - query=json.dumps({"filter": {}, "page": {"limit": 3, "token": "3"}}), + store_name='statestore', + query=json.dumps({'filter': {}, 'page': {'limit': 3, 'token': '3'}}), ) - self.assertEqual(resp.results[0].key, "3") + self.assertEqual(resp.results[0].key, '3') self.assertEqual(len(resp.results), 3) async def test_shutdown(self): - dapr = DaprGrpcClientAsync(f"{self.scheme}localhost:{self.server_port}") + dapr = DaprGrpcClientAsync(f'{self.scheme}localhost:{self.server_port}') await dapr.shutdown() self.assertTrue(self._fake_dapr_server.shutdown_received) async def test_wait_ok(self): - dapr = DaprGrpcClientAsync(f"{self.scheme}localhost:{self.server_port}") + dapr = DaprGrpcClientAsync(f'{self.scheme}localhost:{self.server_port}') await dapr.wait(0.1) async def test_wait_timeout(self): # First, pick an unused port port = 0 with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s: - s.bind(("", 0)) + s.bind(('', 0)) port = s.getsockname()[1] - dapr = DaprGrpcClientAsync(f"{self.scheme}localhost:{port}") + dapr = DaprGrpcClientAsync(f'{self.scheme}localhost:{port}') with self.assertRaises(Exception) as context: await dapr.wait(0.1) - self.assertTrue("Connection refused" in str(context.exception)) + self.assertTrue('Connection refused' in str(context.exception)) async def test_lock_acquire_success(self): - dapr = DaprGrpcClientAsync(f"{self.scheme}localhost:{self.server_port}") + dapr = DaprGrpcClientAsync(f'{self.scheme}localhost:{self.server_port}') # Lock parameters - store_name = "lockstore" + store_name = 'lockstore' resource_id = str(uuid.uuid4()) lock_owner = str(uuid.uuid4()) expiry_in_seconds = 60 @@ -546,9 +546,9 @@ async def test_lock_acquire_success(self): self.assertEqual(UnlockResponseStatus.success, unlock_response.status) async def test_lock_release_twice_fails(self): - dapr = DaprGrpcClientAsync(f"{self.scheme}localhost:{self.server_port}") + dapr = DaprGrpcClientAsync(f'{self.scheme}localhost:{self.server_port}') # Lock parameters - store_name = "lockstore" + store_name = 'lockstore' resource_id = str(uuid.uuid4()) lock_owner = str(uuid.uuid4()) expiry_in_seconds = 60 @@ -562,9 +562,9 @@ async def test_lock_release_twice_fails(self): self.assertEqual(UnlockResponseStatus.lock_does_not_exist, unlock_response.status) async def test_lock_conflict(self): - dapr = DaprGrpcClientAsync(f"{self.scheme}localhost:{self.server_port}") + dapr = DaprGrpcClientAsync(f'{self.scheme}localhost:{self.server_port}') # Lock parameters - store_name = "lockstore" + store_name = 'lockstore' resource_id = str(uuid.uuid4()) first_client_id = str(uuid.uuid4()) second_client_id = str(uuid.uuid4()) @@ -584,16 +584,16 @@ async def test_lock_conflict(self): self.assertEqual(UnlockResponseStatus.success, unlock_response.status) async def test_lock_not_previously_acquired(self): - dapr = DaprGrpcClientAsync(f"{self.scheme}localhost:{self.server_port}") + dapr = DaprGrpcClientAsync(f'{self.scheme}localhost:{self.server_port}') unlock_response = await dapr.unlock( - store_name="lockstore", resource_id=str(uuid.uuid4()), lock_owner=str(uuid.uuid4()) + store_name='lockstore', resource_id=str(uuid.uuid4()), lock_owner=str(uuid.uuid4()) ) self.assertEqual(UnlockResponseStatus.lock_does_not_exist, unlock_response.status) async def test_lock_release_twice_fails_with_context_manager(self): - dapr = DaprGrpcClientAsync(f"{self.scheme}localhost:{self.server_port}") + dapr = DaprGrpcClientAsync(f'{self.scheme}localhost:{self.server_port}') # Lock parameters - store_name = "lockstore" + store_name = 'lockstore' resource_id = str(uuid.uuid4()) first_client_id = str(uuid.uuid4()) second_client_id = str(uuid.uuid4()) @@ -614,9 +614,9 @@ async def test_lock_release_twice_fails_with_context_manager(self): self.assertEqual(UnlockResponseStatus.lock_does_not_exist, unlock_response.status) async def test_lock_are_not_reentrant(self): - dapr = DaprGrpcClientAsync(f"{self.scheme}localhost:{self.server_port}") + dapr = DaprGrpcClientAsync(f'{self.scheme}localhost:{self.server_port}') # Lock parameters - store_name = "lockstore" + store_name = 'lockstore' resource_id = str(uuid.uuid4()) client_id = str(uuid.uuid4()) expiry_in_s = 60 @@ -632,14 +632,14 @@ async def test_lock_are_not_reentrant(self): self.assertFalse(second_attempt.success) async def test_lock_input_validation(self): - dapr = DaprGrpcClientAsync(f"{self.scheme}localhost:{self.server_port}") + dapr = DaprGrpcClientAsync(f'{self.scheme}localhost:{self.server_port}') # Sane parameters - store_name = "lockstore" + store_name = 'lockstore' resource_id = str(uuid.uuid4()) client_id = str(uuid.uuid4()) expiry_in_s = 60 # Invalid inputs for string arguments - for invalid_input in [None, "", " "]: + for invalid_input in [None, '', ' ']: # store_name with self.assertRaises(ValueError): async with await dapr.try_lock( @@ -667,13 +667,13 @@ async def test_lock_input_validation(self): self.assertTrue(res.success) async def test_unlock_input_validation(self): - dapr = DaprGrpcClientAsync(f"{self.scheme}localhost:{self.server_port}") + dapr = DaprGrpcClientAsync(f'{self.scheme}localhost:{self.server_port}') # Sane parameters - store_name = "lockstore" + store_name = 'lockstore' resource_id = str(uuid.uuid4()) client_id = str(uuid.uuid4()) # Invalid inputs for string arguments - for invalid_input in [None, "", " "]: + for invalid_input in [None, '', ' ']: # store_name with self.assertRaises(ValueError): await dapr.unlock(invalid_input, resource_id, client_id) @@ -689,12 +689,12 @@ async def test_unlock_input_validation(self): # async def test_get_metadata(self): - async with DaprGrpcClientAsync(f"{self.scheme}localhost:{self.server_port}") as dapr: + async with DaprGrpcClientAsync(f'{self.scheme}localhost:{self.server_port}') as dapr: response = await dapr.get_metadata() self.assertIsNotNone(response) - self.assertEqual(response.application_id, "myapp") + self.assertEqual(response.application_id, 'myapp') actors = response.active_actors_count self.assertIsNotNone(actors) @@ -713,13 +713,13 @@ async def test_get_metadata(self): self.assertTrue(c.type) self.assertIsNotNone(c.version) self.assertIsNotNone(c.capabilities) - self.assertTrue("ETAG" in components["statestore"].capabilities) + self.assertTrue('ETAG' in components['statestore'].capabilities) self.assertIsNotNone(response.extended_metadata) async def test_set_metadata(self): - metadata_key = "test_set_metadata_attempt" - async with DaprGrpcClientAsync(f"{self.scheme}localhost:{self.server_port}") as dapr: + metadata_key = 'test_set_metadata_attempt' + async with DaprGrpcClientAsync(f'{self.scheme}localhost:{self.server_port}') as dapr: for metadata_value in [str(i) for i in range(10)]: await dapr.set_metadata(attributeName=metadata_key, attributeValue=metadata_value) response = await dapr.get_metadata() @@ -728,7 +728,7 @@ async def test_set_metadata(self): self.assertEqual(response.extended_metadata[metadata_key], metadata_value) # Empty string and blank strings should be accepted just fine # by this API - for metadata_value in ["", " "]: + for metadata_value in ['', ' ']: await dapr.set_metadata(attributeName=metadata_key, attributeValue=metadata_value) response = await dapr.get_metadata() self.assertIsNotNone(response) @@ -736,12 +736,12 @@ async def test_set_metadata(self): self.assertEqual(response.extended_metadata[metadata_key], metadata_value) async def test_set_metadata_input_validation(self): - dapr = DaprGrpcClientAsync(f"{self.scheme}localhost:{self.server_port}") - valid_attr_name = "attribute name" - valid_attr_value = "attribute value" + dapr = DaprGrpcClientAsync(f'{self.scheme}localhost:{self.server_port}') + valid_attr_name = 'attribute name' + valid_attr_value = 'attribute value' # Invalid inputs for string arguments - async with DaprGrpcClientAsync(f"{self.scheme}localhost:{self.server_port}") as dapr: - for invalid_attr_name in [None, "", " "]: + async with DaprGrpcClientAsync(f'{self.scheme}localhost:{self.server_port}') as dapr: + for invalid_attr_name in [None, '', ' ']: with self.assertRaises(ValueError): await dapr.set_metadata(invalid_attr_name, valid_attr_value) # We are less strict with attribute values - we just cannot accept None @@ -750,5 +750,5 @@ async def test_set_metadata_input_validation(self): await dapr.set_metadata(valid_attr_name, invalid_attr_value) -if __name__ == "__main__": +if __name__ == '__main__': unittest.main() diff --git a/tests/clients/test_dapr_grpc_client.py b/tests/clients/test_dapr_grpc_client.py index 43a9ad6e..10c9084e 100644 --- a/tests/clients/test_dapr_grpc_client.py +++ b/tests/clients/test_dapr_grpc_client.py @@ -39,7 +39,7 @@ class DaprGrpcClientTests(unittest.TestCase): server_port = 8080 - scheme = "" + scheme = '' def setUp(self): self._fake_dapr_server = FakeDaprSidecar() @@ -49,284 +49,284 @@ def tearDown(self): self._fake_dapr_server.stop() def test_http_extension(self): - dapr = DaprGrpcClient(f"{self.scheme}localhost:{self.server_port}") + dapr = DaprGrpcClient(f'{self.scheme}localhost:{self.server_port}') # Test POST verb without querystring - ext = dapr._get_http_extension("POST") + ext = dapr._get_http_extension('POST') self.assertEqual(common_v1.HTTPExtension.Verb.POST, ext.verb) # Test Non-supported http verb with self.assertRaises(ValueError): - ext = dapr._get_http_extension("") + ext = dapr._get_http_extension('') # Test POST verb with querystring qs = ( - ("query1", "string1"), - ("query2", "string2"), - ("query1", "string 3"), + ('query1', 'string1'), + ('query2', 'string2'), + ('query1', 'string 3'), ) - ext = dapr._get_http_extension("POST", qs) + ext = dapr._get_http_extension('POST', qs) self.assertEqual(common_v1.HTTPExtension.Verb.POST, ext.verb) - self.assertEqual("query1=string1&query2=string2&query1=string+3", ext.querystring) + self.assertEqual('query1=string1&query2=string2&query1=string+3', ext.querystring) def test_invoke_method_bytes_data(self): - dapr = DaprGrpcClient(f"{self.scheme}localhost:{self.server_port}") + dapr = DaprGrpcClient(f'{self.scheme}localhost:{self.server_port}') resp = dapr.invoke_method( - app_id="targetId", - method_name="bytes", - data=b"haha", - content_type="text/plain", + app_id='targetId', + method_name='bytes', + data=b'haha', + content_type='text/plain', metadata=( - ("key1", "value1"), - ("key2", "value2"), + ('key1', 'value1'), + ('key2', 'value2'), ), - http_verb="PUT", + http_verb='PUT', ) - self.assertEqual(b"haha", resp.data) - self.assertEqual("text/plain", resp.content_type) + self.assertEqual(b'haha', resp.data) + self.assertEqual('text/plain', resp.content_type) self.assertEqual(3, len(resp.headers)) - self.assertEqual(["value1"], resp.headers["hkey1"]) + self.assertEqual(['value1'], resp.headers['hkey1']) def test_invoke_method_no_data(self): - dapr = DaprGrpcClient(f"{self.scheme}localhost:{self.server_port}") + dapr = DaprGrpcClient(f'{self.scheme}localhost:{self.server_port}') resp = dapr.invoke_method( - app_id="targetId", - method_name="bytes", - content_type="text/plain", + app_id='targetId', + method_name='bytes', + content_type='text/plain', metadata=( - ("key1", "value1"), - ("key2", "value2"), + ('key1', 'value1'), + ('key2', 'value2'), ), - http_verb="PUT", + http_verb='PUT', ) - self.assertEqual(b"", resp.data) - self.assertEqual("text/plain", resp.content_type) + self.assertEqual(b'', resp.data) + self.assertEqual('text/plain', resp.content_type) self.assertEqual(3, len(resp.headers)) - self.assertEqual(["value1"], resp.headers["hkey1"]) + self.assertEqual(['value1'], resp.headers['hkey1']) def test_invoke_method_async(self): - dapr = DaprClient(f"{self.scheme}localhost:{self.server_port}") + dapr = DaprClient(f'{self.scheme}localhost:{self.server_port}') dapr.invocation_client = None # force to use grpc client with self.assertRaises(NotImplementedError): loop = asyncio.new_event_loop() loop.run_until_complete( dapr.invoke_method_async( - app_id="targetId", - method_name="bytes", - data=b"haha", - content_type="text/plain", + app_id='targetId', + method_name='bytes', + data=b'haha', + content_type='text/plain', metadata=( - ("key1", "value1"), - ("key2", "value2"), + ('key1', 'value1'), + ('key2', 'value2'), ), - http_verb="PUT", + http_verb='PUT', ) ) def test_invoke_method_proto_data(self): - dapr = DaprGrpcClient(f"{self.scheme}localhost:{self.server_port}") - req = common_v1.StateItem(key="test") + dapr = DaprGrpcClient(f'{self.scheme}localhost:{self.server_port}') + req = common_v1.StateItem(key='test') resp = dapr.invoke_method( - app_id="targetId", - method_name="proto", + app_id='targetId', + method_name='proto', data=req, metadata=( - ("key1", "value1"), - ("key2", "value2"), + ('key1', 'value1'), + ('key2', 'value2'), ), ) self.assertEqual(3, len(resp.headers)) - self.assertEqual(["value1"], resp.headers["hkey1"]) + self.assertEqual(['value1'], resp.headers['hkey1']) self.assertTrue(resp.is_proto()) # unpack to new protobuf object new_resp = common_v1.StateItem() resp.unpack(new_resp) - self.assertEqual("test", new_resp.key) + self.assertEqual('test', new_resp.key) def test_invoke_binding_bytes_data(self): - dapr = DaprGrpcClient(f"{self.scheme}localhost:{self.server_port}") + dapr = DaprGrpcClient(f'{self.scheme}localhost:{self.server_port}') resp = dapr.invoke_binding( - binding_name="binding", - operation="create", - data=b"haha", + binding_name='binding', + operation='create', + data=b'haha', binding_metadata={ - "key1": "value1", - "key2": "value2", + 'key1': 'value1', + 'key2': 'value2', }, ) - self.assertEqual(b"haha", resp.data) - self.assertEqual({"key1": "value1", "key2": "value2"}, resp.binding_metadata) + self.assertEqual(b'haha', resp.data) + self.assertEqual({'key1': 'value1', 'key2': 'value2'}, resp.binding_metadata) self.assertEqual(2, len(resp.headers)) - self.assertEqual(["value1"], resp.headers["hkey1"]) + self.assertEqual(['value1'], resp.headers['hkey1']) def test_invoke_binding_no_metadata(self): - dapr = DaprGrpcClient(f"{self.scheme}localhost:{self.server_port}") + dapr = DaprGrpcClient(f'{self.scheme}localhost:{self.server_port}') resp = dapr.invoke_binding( - binding_name="binding", - operation="create", - data=b"haha", + binding_name='binding', + operation='create', + data=b'haha', ) - self.assertEqual(b"haha", resp.data) + self.assertEqual(b'haha', resp.data) self.assertEqual({}, resp.binding_metadata) self.assertEqual(0, len(resp.headers)) def test_invoke_binding_no_data(self): - dapr = DaprGrpcClient(f"{self.scheme}localhost:{self.server_port}") + dapr = DaprGrpcClient(f'{self.scheme}localhost:{self.server_port}') resp = dapr.invoke_binding( - binding_name="binding", - operation="create", + binding_name='binding', + operation='create', ) - self.assertEqual(b"", resp.data) + self.assertEqual(b'', resp.data) self.assertEqual({}, resp.binding_metadata) self.assertEqual(0, len(resp.headers)) def test_invoke_binding_no_create(self): - dapr = DaprGrpcClient(f"{self.scheme}localhost:{self.server_port}") + dapr = DaprGrpcClient(f'{self.scheme}localhost:{self.server_port}') resp = dapr.invoke_binding( - binding_name="binding", - operation="delete", - data=b"haha", + binding_name='binding', + operation='delete', + data=b'haha', ) - self.assertEqual(b"INVALID", resp.data) + self.assertEqual(b'INVALID', resp.data) self.assertEqual({}, resp.binding_metadata) self.assertEqual(0, len(resp.headers)) def test_publish_event(self): - dapr = DaprGrpcClient(f"{self.scheme}localhost:{self.server_port}") - resp = dapr.publish_event(pubsub_name="pubsub", topic_name="example", data=b"haha") + dapr = DaprGrpcClient(f'{self.scheme}localhost:{self.server_port}') + resp = dapr.publish_event(pubsub_name='pubsub', topic_name='example', data=b'haha') self.assertEqual(2, len(resp.headers)) - self.assertEqual(["haha"], resp.headers["hdata"]) + self.assertEqual(['haha'], resp.headers['hdata']) def test_publish_event_with_content_type(self): - dapr = DaprGrpcClient(f"{self.scheme}localhost:{self.server_port}") + dapr = DaprGrpcClient(f'{self.scheme}localhost:{self.server_port}') resp = dapr.publish_event( - pubsub_name="pubsub", - topic_name="example", + pubsub_name='pubsub', + topic_name='example', data=b'{"foo": "bar"}', - data_content_type="application/json", + data_content_type='application/json', ) self.assertEqual(3, len(resp.headers)) - self.assertEqual(['{"foo": "bar"}'], resp.headers["hdata"]) - self.assertEqual(["application/json"], resp.headers["data_content_type"]) + self.assertEqual(['{"foo": "bar"}'], resp.headers['hdata']) + self.assertEqual(['application/json'], resp.headers['data_content_type']) def test_publish_event_with_metadata(self): - dapr = DaprGrpcClient(f"{self.scheme}localhost:{self.server_port}") + dapr = DaprGrpcClient(f'{self.scheme}localhost:{self.server_port}') resp = dapr.publish_event( - pubsub_name="pubsub", - topic_name="example", + pubsub_name='pubsub', + topic_name='example', data=b'{"foo": "bar"}', - publish_metadata={"ttlInSeconds": "100", "rawPayload": "false"}, + publish_metadata={'ttlInSeconds': '100', 'rawPayload': 'false'}, ) print(resp.headers) - self.assertEqual(['{"foo": "bar"}'], resp.headers["hdata"]) - self.assertEqual(["false"], resp.headers["metadata_raw_payload"]) - self.assertEqual(["100"], resp.headers["metadata_ttl_in_seconds"]) + self.assertEqual(['{"foo": "bar"}'], resp.headers['hdata']) + self.assertEqual(['false'], resp.headers['metadata_raw_payload']) + self.assertEqual(['100'], resp.headers['metadata_ttl_in_seconds']) def test_publish_error(self): - dapr = DaprGrpcClient(f"{self.scheme}localhost:{self.server_port}") + dapr = DaprGrpcClient(f'{self.scheme}localhost:{self.server_port}') with self.assertRaisesRegex(ValueError, "invalid type for data "): dapr.publish_event( - pubsub_name="pubsub", - topic_name="example", + pubsub_name='pubsub', + topic_name='example', data=111, ) - @patch.object(settings, "DAPR_API_TOKEN", "test-token") + @patch.object(settings, 'DAPR_API_TOKEN', 'test-token') def test_dapr_api_token_insertion(self): - dapr = DaprGrpcClient(f"{self.scheme}localhost:{self.server_port}") + dapr = DaprGrpcClient(f'{self.scheme}localhost:{self.server_port}') resp = dapr.invoke_method( - app_id="targetId", - method_name="bytes", - data=b"haha", - content_type="text/plain", + app_id='targetId', + method_name='bytes', + data=b'haha', + content_type='text/plain', metadata=( - ("key1", "value1"), - ("key2", "value2"), + ('key1', 'value1'), + ('key2', 'value2'), ), ) - self.assertEqual(b"haha", resp.data) - self.assertEqual("text/plain", resp.content_type) + self.assertEqual(b'haha', resp.data) + self.assertEqual('text/plain', resp.content_type) self.assertEqual(4, len(resp.headers)) - self.assertEqual(["value1"], resp.headers["hkey1"]) - self.assertEqual(["test-token"], resp.headers["hdapr-api-token"]) + self.assertEqual(['value1'], resp.headers['hkey1']) + self.assertEqual(['test-token'], resp.headers['hdapr-api-token']) def test_get_save_delete_state(self): - dapr = DaprGrpcClient(f"{self.scheme}localhost:{self.server_port}") - key = "key_1" - value = "value_1" + dapr = DaprGrpcClient(f'{self.scheme}localhost:{self.server_port}') + key = 'key_1' + value = 'value_1' options = StateOptions( consistency=Consistency.eventual, concurrency=Concurrency.first_write, ) dapr.save_state( - store_name="statestore", + store_name='statestore', key=key, value=value, - etag="fake_etag", + etag='fake_etag', options=options, - state_metadata={"capitalize": "1"}, + state_metadata={'capitalize': '1'}, ) - resp = dapr.get_state(store_name="statestore", key=key) + resp = dapr.get_state(store_name='statestore', key=key) self.assertEqual(resp.data, to_bytes(value.capitalize())) - self.assertEqual(resp.etag, "fake_etag") + self.assertEqual(resp.etag, 'fake_etag') - resp = dapr.get_state(store_name="statestore", key=key, state_metadata={"upper": "1"}) + resp = dapr.get_state(store_name='statestore', key=key, state_metadata={'upper': '1'}) self.assertEqual(resp.data, to_bytes(value.upper())) - self.assertEqual(resp.etag, "fake_etag") + self.assertEqual(resp.etag, 'fake_etag') - resp = dapr.get_state(store_name="statestore", key="NotValidKey") - self.assertEqual(resp.data, b"") - self.assertEqual(resp.etag, "") + resp = dapr.get_state(store_name='statestore', key='NotValidKey') + self.assertEqual(resp.data, b'') + self.assertEqual(resp.etag, '') - dapr.delete_state(store_name="statestore", key=key) - resp = dapr.get_state(store_name="statestore", key=key) - self.assertEqual(resp.data, b"") - self.assertEqual(resp.etag, "") + dapr.delete_state(store_name='statestore', key=key) + resp = dapr.get_state(store_name='statestore', key=key) + self.assertEqual(resp.data, b'') + self.assertEqual(resp.etag, '') with self.assertRaises(Exception) as context: - dapr.delete_state(store_name="statestore", key=key, state_metadata={"must_delete": "1"}) + dapr.delete_state(store_name='statestore', key=key, state_metadata={'must_delete': '1'}) print(context.exception) - self.assertTrue("delete failed" in str(context.exception)) + self.assertTrue('delete failed' in str(context.exception)) def test_get_save_state_etag_none(self): - dapr = DaprGrpcClient(f"{self.scheme}localhost:{self.server_port}") + dapr = DaprGrpcClient(f'{self.scheme}localhost:{self.server_port}') - value = "test" - no_etag_key = "no_etag" - empty_etag_key = "empty_etag" + value = 'test' + no_etag_key = 'no_etag' + empty_etag_key = 'empty_etag' dapr.save_state( - store_name="statestore", + store_name='statestore', key=no_etag_key, value=value, ) - dapr.save_state(store_name="statestore", key=empty_etag_key, value=value, etag="") + dapr.save_state(store_name='statestore', key=empty_etag_key, value=value, etag='') - resp = dapr.get_state(store_name="statestore", key=no_etag_key) + resp = dapr.get_state(store_name='statestore', key=no_etag_key) self.assertEqual(resp.data, to_bytes(value)) - self.assertEqual(resp.etag, "ETAG_WAS_NONE") + self.assertEqual(resp.etag, 'ETAG_WAS_NONE') - resp = dapr.get_state(store_name="statestore", key=empty_etag_key) + resp = dapr.get_state(store_name='statestore', key=empty_etag_key) self.assertEqual(resp.data, to_bytes(value)) - self.assertEqual(resp.etag, "") + self.assertEqual(resp.etag, '') def test_transaction_then_get_states(self): - dapr = DaprGrpcClient(f"{self.scheme}localhost:{self.server_port}") + dapr = DaprGrpcClient(f'{self.scheme}localhost:{self.server_port}') key = str(uuid.uuid4()) value = str(uuid.uuid4()) @@ -334,24 +334,24 @@ def test_transaction_then_get_states(self): another_value = str(uuid.uuid4()) dapr.execute_state_transaction( - store_name="statestore", + store_name='statestore', operations=[ - TransactionalStateOperation(key=key, data=value, etag="foo"), + TransactionalStateOperation(key=key, data=value, etag='foo'), TransactionalStateOperation(key=another_key, data=another_value), ], - transactional_metadata={"metakey": "metavalue"}, + transactional_metadata={'metakey': 'metavalue'}, ) - resp = dapr.get_bulk_state(store_name="statestore", keys=[key, another_key]) + resp = dapr.get_bulk_state(store_name='statestore', keys=[key, another_key]) self.assertEqual(resp.items[0].key, key) self.assertEqual(resp.items[0].data, to_bytes(value)) - self.assertEqual(resp.items[0].etag, "foo") + self.assertEqual(resp.items[0].etag, 'foo') self.assertEqual(resp.items[1].key, another_key) self.assertEqual(resp.items[1].data, to_bytes(another_value)) - self.assertEqual(resp.items[1].etag, "ETAG_WAS_NONE") + self.assertEqual(resp.items[1].etag, 'ETAG_WAS_NONE') resp = dapr.get_bulk_state( - store_name="statestore", keys=[key, another_key], states_metadata={"upper": "1"} + store_name='statestore', keys=[key, another_key], states_metadata={'upper': '1'} ) self.assertEqual(resp.items[0].key, key) self.assertEqual(resp.items[0].data, to_bytes(value.upper())) @@ -359,7 +359,7 @@ def test_transaction_then_get_states(self): self.assertEqual(resp.items[1].data, to_bytes(another_value.upper())) def test_save_then_get_states(self): - dapr = DaprGrpcClient(f"{self.scheme}localhost:{self.server_port}") + dapr = DaprGrpcClient(f'{self.scheme}localhost:{self.server_port}') key = str(uuid.uuid4()) value = str(uuid.uuid4()) @@ -367,90 +367,90 @@ def test_save_then_get_states(self): another_value = str(uuid.uuid4()) dapr.save_bulk_state( - store_name="statestore", + store_name='statestore', states=[ - StateItem(key=key, value=value, metadata={"capitalize": "1"}), - StateItem(key=another_key, value=another_value, etag="1"), + StateItem(key=key, value=value, metadata={'capitalize': '1'}), + StateItem(key=another_key, value=another_value, etag='1'), ], - metadata=(("metakey", "metavalue"),), + metadata=(('metakey', 'metavalue'),), ) - resp = dapr.get_bulk_state(store_name="statestore", keys=[key, another_key]) + resp = dapr.get_bulk_state(store_name='statestore', keys=[key, another_key]) self.assertEqual(resp.items[0].key, key) - self.assertEqual(resp.items[0].etag, "ETAG_WAS_NONE") + self.assertEqual(resp.items[0].etag, 'ETAG_WAS_NONE') self.assertEqual(resp.items[0].data, to_bytes(value.capitalize())) self.assertEqual(resp.items[1].key, another_key) self.assertEqual(resp.items[1].data, to_bytes(another_value)) - self.assertEqual(resp.items[1].etag, "1") + self.assertEqual(resp.items[1].etag, '1') resp = dapr.get_bulk_state( - store_name="statestore", keys=[key, another_key], states_metadata={"upper": "1"} + store_name='statestore', keys=[key, another_key], states_metadata={'upper': '1'} ) self.assertEqual(resp.items[0].key, key) - self.assertEqual(resp.items[0].etag, "ETAG_WAS_NONE") + self.assertEqual(resp.items[0].etag, 'ETAG_WAS_NONE') self.assertEqual(resp.items[0].data, to_bytes(value.upper())) self.assertEqual(resp.items[1].key, another_key) - self.assertEqual(resp.items[1].etag, "1") + self.assertEqual(resp.items[1].etag, '1') self.assertEqual(resp.items[1].data, to_bytes(another_value.upper())) def test_get_secret(self): - dapr = DaprGrpcClient(f"{self.scheme}localhost:{self.server_port}") - key1 = "key_1" + dapr = DaprGrpcClient(f'{self.scheme}localhost:{self.server_port}') + key1 = 'key_1' resp = dapr.get_secret( - store_name="store_1", + store_name='store_1', key=key1, metadata=( - ("key1", "value1"), - ("key2", "value2"), + ('key1', 'value1'), + ('key2', 'value2'), ), ) self.assertEqual(1, len(resp.headers)) - self.assertEqual([key1], resp.headers["keyh"]) - self.assertEqual({key1: "val"}, resp._secret) + self.assertEqual([key1], resp.headers['keyh']) + self.assertEqual({key1: 'val'}, resp._secret) def test_get_secret_metadata_absent(self): - dapr = DaprGrpcClient(f"{self.scheme}localhost:{self.server_port}") - key1 = "key_1" + dapr = DaprGrpcClient(f'{self.scheme}localhost:{self.server_port}') + key1 = 'key_1' resp = dapr.get_secret( - store_name="store_1", + store_name='store_1', key=key1, ) self.assertEqual(1, len(resp.headers)) - self.assertEqual([key1], resp.headers["keyh"]) - self.assertEqual({key1: "val"}, resp._secret) + self.assertEqual([key1], resp.headers['keyh']) + self.assertEqual({key1: 'val'}, resp._secret) def test_get_bulk_secret(self): - dapr = DaprGrpcClient(f"{self.scheme}localhost:{self.server_port}") + dapr = DaprGrpcClient(f'{self.scheme}localhost:{self.server_port}') resp = dapr.get_bulk_secret( - store_name="store_1", + store_name='store_1', metadata=( - ("key1", "value1"), - ("key2", "value2"), + ('key1', 'value1'), + ('key2', 'value2'), ), ) self.assertEqual(1, len(resp.headers)) - self.assertEqual(["bulk"], resp.headers["keyh"]) - self.assertEqual({"keya": {"keyb": "val"}}, resp._secrets) + self.assertEqual(['bulk'], resp.headers['keyh']) + self.assertEqual({'keya': {'keyb': 'val'}}, resp._secrets) def test_get_bulk_secret_metadata_absent(self): - dapr = DaprGrpcClient(f"{self.scheme}localhost:{self.server_port}") - resp = dapr.get_bulk_secret(store_name="store_1") + dapr = DaprGrpcClient(f'{self.scheme}localhost:{self.server_port}') + resp = dapr.get_bulk_secret(store_name='store_1') self.assertEqual(1, len(resp.headers)) - self.assertEqual(["bulk"], resp.headers["keyh"]) - self.assertEqual({"keya": {"keyb": "val"}}, resp._secrets) + self.assertEqual(['bulk'], resp.headers['keyh']) + self.assertEqual({'keya': {'keyb': 'val'}}, resp._secrets) def test_get_configuration(self): - dapr = DaprGrpcClient(f"{self.scheme}localhost:{self.server_port}") - keys = ["k", "k1"] - value = "value" - version = "1.5.0" + dapr = DaprGrpcClient(f'{self.scheme}localhost:{self.server_port}') + keys = ['k', 'k1'] + value = 'value' + version = '1.5.0' metadata = {} - resp = dapr.get_configuration(store_name="configurationstore", keys=keys) + resp = dapr.get_configuration(store_name='configurationstore', keys=keys) self.assertEqual(len(resp.items), len(keys)) self.assertIn(keys[0], resp.items) item = resp.items[keys[0]] @@ -459,7 +459,7 @@ def test_get_configuration(self): self.assertEqual(item.metadata, metadata) resp = dapr.get_configuration( - store_name="configurationstore", keys=keys, config_metadata=metadata + store_name='configurationstore', keys=keys, config_metadata=metadata ) self.assertEqual(len(resp.items), len(keys)) self.assertIn(keys[0], resp.items) @@ -469,72 +469,72 @@ def test_get_configuration(self): self.assertEqual(item.metadata, metadata) def test_subscribe_configuration(self): - dapr = DaprGrpcClient(f"{self.scheme}localhost:{self.server_port}") + dapr = DaprGrpcClient(f'{self.scheme}localhost:{self.server_port}') def mock_watch(self, stub, store_name, keys, handler, config_metadata): handler( - "id", + 'id', ConfigurationResponse( - items={"k": ConfigurationItem(value="test", version="1.7.0")} + items={'k': ConfigurationItem(value='test', version='1.7.0')} ), ) - return "id" + return 'id' def handler(id: str, resp: ConfigurationResponse): - self.assertEqual(resp.items["k"].value, "test") - self.assertEqual(resp.items["k"].version, "1.7.0") + self.assertEqual(resp.items['k'].value, 'test') + self.assertEqual(resp.items['k'].version, '1.7.0') - with patch.object(ConfigurationWatcher, "watch_configuration", mock_watch): + with patch.object(ConfigurationWatcher, 'watch_configuration', mock_watch): dapr.subscribe_configuration( - store_name="configurationstore", keys=["k"], handler=handler + store_name='configurationstore', keys=['k'], handler=handler ) def test_unsubscribe_configuration(self): - dapr = DaprGrpcClient(f"{self.scheme}localhost:{self.server_port}") - res = dapr.unsubscribe_configuration(store_name="configurationstore", id="k") + dapr = DaprGrpcClient(f'{self.scheme}localhost:{self.server_port}') + res = dapr.unsubscribe_configuration(store_name='configurationstore', id='k') self.assertTrue(res) def test_query_state(self): - dapr = DaprGrpcClient(f"{self.scheme}localhost:{self.server_port}") + dapr = DaprGrpcClient(f'{self.scheme}localhost:{self.server_port}') resp = dapr.query_state( - store_name="statestore", - query=json.dumps({"filter": {}, "page": {"limit": 2}}), + store_name='statestore', + query=json.dumps({'filter': {}, 'page': {'limit': 2}}), ) - self.assertEqual(resp.results[0].key, "1") + self.assertEqual(resp.results[0].key, '1') self.assertEqual(len(resp.results), 2) resp = dapr.query_state( - store_name="statestore", - query=json.dumps({"filter": {}, "page": {"limit": 3, "token": "3"}}), + store_name='statestore', + query=json.dumps({'filter': {}, 'page': {'limit': 3, 'token': '3'}}), ) - self.assertEqual(resp.results[0].key, "3") + self.assertEqual(resp.results[0].key, '3') self.assertEqual(len(resp.results), 3) def test_shutdown(self): - dapr = DaprGrpcClient(f"{self.scheme}localhost:{self.server_port}") + dapr = DaprGrpcClient(f'{self.scheme}localhost:{self.server_port}') dapr.shutdown() self.assertTrue(self._fake_dapr_server.shutdown_received) def test_wait_ok(self): - dapr = DaprGrpcClient(f"{self.scheme}localhost:{self.server_port}") + dapr = DaprGrpcClient(f'{self.scheme}localhost:{self.server_port}') dapr.wait(0.1) def test_wait_timeout(self): # First, pick an unused port port = 0 with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s: - s.bind(("", 0)) + s.bind(('', 0)) port = s.getsockname()[1] - dapr = DaprGrpcClient(f"localhost:{port}") + dapr = DaprGrpcClient(f'localhost:{port}') with self.assertRaises(Exception) as context: dapr.wait(0.1) - self.assertTrue("Connection refused" in str(context.exception)) + self.assertTrue('Connection refused' in str(context.exception)) def test_lock_acquire_success(self): - dapr = DaprGrpcClient(f"{self.scheme}localhost:{self.server_port}") + dapr = DaprGrpcClient(f'{self.scheme}localhost:{self.server_port}') # Lock parameters - store_name = "lockstore" + store_name = 'lockstore' resource_id = str(uuid.uuid4()) lock_owner = str(uuid.uuid4()) expiry_in_seconds = 60 @@ -545,9 +545,9 @@ def test_lock_acquire_success(self): self.assertEqual(UnlockResponseStatus.success, unlock_response.status) def test_lock_release_twice_fails(self): - dapr = DaprGrpcClient(f"{self.scheme}localhost:{self.server_port}") + dapr = DaprGrpcClient(f'{self.scheme}localhost:{self.server_port}') # Lock parameters - store_name = "lockstore" + store_name = 'lockstore' resource_id = str(uuid.uuid4()) lock_owner = str(uuid.uuid4()) expiry_in_seconds = 60 @@ -561,9 +561,9 @@ def test_lock_release_twice_fails(self): self.assertEqual(UnlockResponseStatus.lock_does_not_exist, unlock_response.status) def test_lock_conflict(self): - dapr = DaprGrpcClient(f"{self.scheme}localhost:{self.server_port}") + dapr = DaprGrpcClient(f'{self.scheme}localhost:{self.server_port}') # Lock parameters - store_name = "lockstore" + store_name = 'lockstore' resource_id = str(uuid.uuid4()) first_client_id = str(uuid.uuid4()) second_client_id = str(uuid.uuid4()) @@ -583,16 +583,16 @@ def test_lock_conflict(self): self.assertEqual(UnlockResponseStatus.success, unlock_response.status) def test_lock_not_previously_acquired(self): - dapr = DaprGrpcClient(f"{self.scheme}localhost:{self.server_port}") + dapr = DaprGrpcClient(f'{self.scheme}localhost:{self.server_port}') unlock_response = dapr.unlock( - store_name="lockstore", resource_id=str(uuid.uuid4()), lock_owner=str(uuid.uuid4()) + store_name='lockstore', resource_id=str(uuid.uuid4()), lock_owner=str(uuid.uuid4()) ) self.assertEqual(UnlockResponseStatus.lock_does_not_exist, unlock_response.status) def test_lock_release_twice_fails_with_context_manager(self): - dapr = DaprGrpcClient(f"{self.scheme}localhost:{self.server_port}") + dapr = DaprGrpcClient(f'{self.scheme}localhost:{self.server_port}') # Lock parameters - store_name = "lockstore" + store_name = 'lockstore' resource_id = str(uuid.uuid4()) first_client_id = str(uuid.uuid4()) second_client_id = str(uuid.uuid4()) @@ -609,9 +609,9 @@ def test_lock_release_twice_fails_with_context_manager(self): self.assertEqual(UnlockResponseStatus.lock_does_not_exist, unlock_response.status) def test_lock_are_not_reentrant(self): - dapr = DaprGrpcClient(f"{self.scheme}localhost:{self.server_port}") + dapr = DaprGrpcClient(f'{self.scheme}localhost:{self.server_port}') # Lock parameters - store_name = "lockstore" + store_name = 'lockstore' resource_id = str(uuid.uuid4()) client_id = str(uuid.uuid4()) expiry_in_s = 60 @@ -623,14 +623,14 @@ def test_lock_are_not_reentrant(self): self.assertFalse(second_attempt.success) def test_lock_input_validation(self): - dapr = DaprGrpcClient(f"{self.scheme}localhost:{self.server_port}") + dapr = DaprGrpcClient(f'{self.scheme}localhost:{self.server_port}') # Sane parameters - store_name = "lockstore" + store_name = 'lockstore' resource_id = str(uuid.uuid4()) client_id = str(uuid.uuid4()) expiry_in_s = 60 # Invalid inputs for string arguments - for invalid_input in [None, "", " "]: + for invalid_input in [None, '', ' ']: # store_name with self.assertRaises(ValueError): with dapr.try_lock(invalid_input, resource_id, client_id, expiry_in_s) as res: @@ -650,13 +650,13 @@ def test_lock_input_validation(self): self.assertTrue(res.success) def test_unlock_input_validation(self): - dapr = DaprGrpcClient(f"{self.scheme}localhost:{self.server_port}") + dapr = DaprGrpcClient(f'{self.scheme}localhost:{self.server_port}') # Sane parameters - store_name = "lockstore" + store_name = 'lockstore' resource_id = str(uuid.uuid4()) client_id = str(uuid.uuid4()) # Invalid inputs for string arguments - for invalid_input in [None, "", " "]: + for invalid_input in [None, '', ' ']: # store_name with self.assertRaises(ValueError): dapr.unlock(invalid_input, resource_id, client_id) @@ -672,14 +672,14 @@ def test_unlock_input_validation(self): # def test_workflow(self): - dapr = DaprGrpcClient(f"{self.scheme}localhost:{self.server_port}") + dapr = DaprGrpcClient(f'{self.scheme}localhost:{self.server_port}') # Sane parameters - workflow_name = "test_workflow" - event_name = "eventName" + workflow_name = 'test_workflow' + event_name = 'eventName' instance_id = str(uuid.uuid4()) - workflow_component = "dapr" - input = "paperclips" - event_data = "cars" + workflow_component = 'dapr' + input = 'paperclips' + event_data = 'cars' # Start the workflow start_response = dapr.start_workflow( @@ -730,19 +730,19 @@ def test_workflow(self): try: get_response = dapr.get_workflow(instance_id, workflow_component) except Exception as err: - self.assertIn("Workflow instance does not exist", str(err)) + self.assertIn('Workflow instance does not exist', str(err)) # # Tests for Metadata API # def test_get_metadata(self): - with DaprGrpcClient(f"{self.scheme}localhost:{self.server_port}") as dapr: + with DaprGrpcClient(f'{self.scheme}localhost:{self.server_port}') as dapr: response = dapr.get_metadata() self.assertIsNotNone(response) - self.assertEqual(response.application_id, "myapp") + self.assertEqual(response.application_id, 'myapp') actors = response.active_actors_count self.assertIsNotNone(actors) @@ -761,13 +761,13 @@ def test_get_metadata(self): self.assertTrue(c.type) self.assertIsNotNone(c.version) self.assertIsNotNone(c.capabilities) - self.assertTrue("ETAG" in components["statestore"].capabilities) + self.assertTrue('ETAG' in components['statestore'].capabilities) self.assertIsNotNone(response.extended_metadata) def test_set_metadata(self): - metadata_key = "test_set_metadata_attempt" - with DaprGrpcClient(f"{self.scheme}localhost:{self.server_port}") as dapr: + metadata_key = 'test_set_metadata_attempt' + with DaprGrpcClient(f'{self.scheme}localhost:{self.server_port}') as dapr: for metadata_value in [str(i) for i in range(10)]: dapr.set_metadata(attributeName=metadata_key, attributeValue=metadata_value) response = dapr.get_metadata() @@ -776,7 +776,7 @@ def test_set_metadata(self): self.assertEqual(response.extended_metadata[metadata_key], metadata_value) # Empty string and blank strings should be accepted just fine # by this API - for metadata_value in ["", " "]: + for metadata_value in ['', ' ']: dapr.set_metadata(attributeName=metadata_key, attributeValue=metadata_value) response = dapr.get_metadata() self.assertIsNotNone(response) @@ -784,12 +784,12 @@ def test_set_metadata(self): self.assertEqual(response.extended_metadata[metadata_key], metadata_value) def test_set_metadata_input_validation(self): - dapr = DaprGrpcClient(f"{self.scheme}localhost:{self.server_port}") - valid_attr_name = "attribute name" - valid_attr_value = "attribute value" + dapr = DaprGrpcClient(f'{self.scheme}localhost:{self.server_port}') + valid_attr_name = 'attribute name' + valid_attr_value = 'attribute value' # Invalid inputs for string arguments - with DaprGrpcClient(f"{self.scheme}localhost:{self.server_port}") as dapr: - for invalid_attr_name in [None, "", " "]: + with DaprGrpcClient(f'{self.scheme}localhost:{self.server_port}') as dapr: + for invalid_attr_name in [None, '', ' ']: with self.assertRaises(ValueError): dapr.set_metadata(invalid_attr_name, valid_attr_value) # We are less strict with attribute values - we just cannot accept None @@ -798,5 +798,5 @@ def test_set_metadata_input_validation(self): dapr.set_metadata(valid_attr_name, invalid_attr_value) -if __name__ == "__main__": +if __name__ == '__main__': unittest.main() diff --git a/tests/clients/test_dapr_grpc_request.py b/tests/clients/test_dapr_grpc_request.py index ce689cc1..113925cf 100644 --- a/tests/clients/test_dapr_grpc_request.py +++ b/tests/clients/test_dapr_grpc_request.py @@ -22,15 +22,15 @@ class InvokeMethodRequestTests(unittest.TestCase): def test_bytes_data(self): # act - req = InvokeMethodRequest(data=b"hello dapr") + req = InvokeMethodRequest(data=b'hello dapr') # arrange - self.assertEqual(b"hello dapr", req.data) - self.assertEqual("application/json; charset=utf-8", req.content_type) + self.assertEqual(b'hello dapr', req.data) + self.assertEqual('application/json; charset=utf-8', req.content_type) def test_proto_message_data(self): # arrange - fake_req = common_v1.InvokeRequest(method="test") + fake_req = common_v1.InvokeRequest(method='test') # act req = InvokeMethodRequest(data=fake_req) @@ -38,7 +38,7 @@ def test_proto_message_data(self): # assert self.assertIsNotNone(req.proto) self.assertEqual( - "type.googleapis.com/dapr.proto.common.v1.InvokeRequest", req.proto.type_url + 'type.googleapis.com/dapr.proto.common.v1.InvokeRequest', req.proto.type_url ) self.assertIsNotNone(req.proto.value) self.assertIsNone(req.content_type) @@ -46,34 +46,34 @@ def test_proto_message_data(self): def test_invalid_data(self): with self.assertRaises(ValueError): data = InvokeMethodRequest(data=123) - self.assertIsNone(data, "This should not be reached.") + self.assertIsNone(data, 'This should not be reached.') class InvokeBindingRequestDataTests(unittest.TestCase): def test_bytes_data(self): # act - data = BindingRequest(data=b"hello dapr") + data = BindingRequest(data=b'hello dapr') # arrange - self.assertEqual(b"hello dapr", data.data) + self.assertEqual(b'hello dapr', data.data) self.assertEqual({}, data.metadata) def test_str_data(self): # act - data = BindingRequest(data="hello dapr") + data = BindingRequest(data='hello dapr') # arrange - self.assertEqual(b"hello dapr", data.data) + self.assertEqual(b'hello dapr', data.data) self.assertEqual({}, data.metadata) def test_non_empty_metadata(self): # act - data = BindingRequest(data="hello dapr", binding_metadata={"ttlInSeconds": "1000"}) + data = BindingRequest(data='hello dapr', binding_metadata={'ttlInSeconds': '1000'}) # arrange - self.assertEqual(b"hello dapr", data.data) - self.assertEqual({"ttlInSeconds": "1000"}, data.binding_metadata) + self.assertEqual(b'hello dapr', data.data) + self.assertEqual({'ttlInSeconds': '1000'}, data.binding_metadata) -if __name__ == "__main__": +if __name__ == '__main__': unittest.main() diff --git a/tests/clients/test_dapr_grpc_response.py b/tests/clients/test_dapr_grpc_response.py index 01bd64dd..5cb9ce3b 100644 --- a/tests/clients/test_dapr_grpc_response.py +++ b/tests/clients/test_dapr_grpc_response.py @@ -30,9 +30,9 @@ class DaprResponseTests(unittest.TestCase): test_headers = ( - ("key1", "value1"), - ("key2", "value2"), - ("key3", "value3"), + ('key1', 'value1'), + ('key2', 'value2'), + ('key3', 'value3'), ) def test_convert_metadata(self): @@ -49,39 +49,39 @@ class InvokeMethodResponseTests(unittest.TestCase): def test_non_protobuf_message(self): with self.assertRaises(ValueError): resp = InvokeMethodResponse(data=123) - self.assertIsNone(resp, "This should not be reached.") + self.assertIsNone(resp, 'This should not be reached.') def test_is_proto_for_non_protobuf(self): - test_data = GrpcAny(value=b"hello dapr") - resp = InvokeMethodResponse(data=test_data, content_type="application/json") + test_data = GrpcAny(value=b'hello dapr') + resp = InvokeMethodResponse(data=test_data, content_type='application/json') self.assertFalse(resp.is_proto()) def test_is_proto_for_protobuf(self): - fake_req = common_v1.InvokeRequest(method="test") + fake_req = common_v1.InvokeRequest(method='test') test_data = GrpcAny() test_data.Pack(fake_req) resp = InvokeMethodResponse(data=test_data) self.assertTrue(resp.is_proto()) def test_proto(self): - fake_req = common_v1.InvokeRequest(method="test") + fake_req = common_v1.InvokeRequest(method='test') resp = InvokeMethodResponse(data=fake_req) self.assertIsNotNone(resp.proto) def test_data(self): - test_data = GrpcAny(value=b"hello dapr") - resp = InvokeMethodResponse(data=test_data, content_type="application/json") - self.assertEqual(b"hello dapr", resp.data) - self.assertEqual("hello dapr", resp.text()) - self.assertEqual("application/json", resp.content_type) + test_data = GrpcAny(value=b'hello dapr') + resp = InvokeMethodResponse(data=test_data, content_type='application/json') + self.assertEqual(b'hello dapr', resp.data) + self.assertEqual('hello dapr', resp.text()) + self.assertEqual('application/json', resp.content_type) def test_json_data(self): - resp = InvokeMethodResponse(data=b'{ "status": "ok" }', content_type="application/json") - self.assertEqual({"status": "ok"}, resp.json()) + resp = InvokeMethodResponse(data=b'{ "status": "ok" }', content_type='application/json') + self.assertEqual({'status': 'ok'}, resp.json()) def test_unpack(self): # arrange - fake_req = common_v1.InvokeRequest(method="test") + fake_req = common_v1.InvokeRequest(method='test') # act resp = InvokeMethodResponse(data=fake_req) @@ -89,43 +89,43 @@ def test_unpack(self): resp.unpack(resp_proto) # assert - self.assertEqual("test", resp_proto.method) + self.assertEqual('test', resp_proto.method) class InvokeBindingResponseTests(unittest.TestCase): def test_bytes_message(self): - resp = BindingResponse(data=b"data", binding_metadata={}) + resp = BindingResponse(data=b'data', binding_metadata={}) self.assertEqual({}, resp.binding_metadata) - self.assertEqual(b"data", resp.data) - self.assertEqual("data", resp.text()) + self.assertEqual(b'data', resp.data) + self.assertEqual('data', resp.text()) def test_json_data(self): resp = BindingResponse(data=b'{"status": "ok"}', binding_metadata={}) - self.assertEqual({"status": "ok"}, resp.json()) + self.assertEqual({'status': 'ok'}, resp.json()) def test_metadata(self): - resp = BindingResponse(data=b"data", binding_metadata={"status": "ok"}) - self.assertEqual({"status": "ok"}, resp.binding_metadata) - self.assertEqual(b"data", resp.data) - self.assertEqual("data", resp.text()) + resp = BindingResponse(data=b'data', binding_metadata={'status': 'ok'}) + self.assertEqual({'status': 'ok'}, resp.binding_metadata) + self.assertEqual(b'data', resp.data) + self.assertEqual('data', resp.text()) class StateResponseTests(unittest.TestCase): def test_data(self): - resp = StateResponse(data=b"hello dapr") - self.assertEqual("hello dapr", resp.text()) - self.assertEqual(b"hello dapr", resp.data) + resp = StateResponse(data=b'hello dapr') + self.assertEqual('hello dapr', resp.text()) + self.assertEqual(b'hello dapr', resp.data) def test_json_data(self): resp = StateResponse(data=b'{"status": "ok"}') - self.assertEqual({"status": "ok"}, resp.json()) + self.assertEqual({'status': 'ok'}, resp.json()) class BulkStateItemTests(unittest.TestCase): def test_data(self): - item = BulkStateItem(key="item1", data=b'{ "status": "ok" }') - self.assertEqual({"status": "ok"}, item.json()) + item = BulkStateItem(key='item1', data=b'{ "status": "ok" }') + self.assertEqual({'status': 'ok'}, item.json()) -if __name__ == "__main__": +if __name__ == '__main__': unittest.main() diff --git a/tests/clients/test_http_service_invocation_client.py b/tests/clients/test_http_service_invocation_client.py index 039b55c7..bd0d59f5 100644 --- a/tests/clients/test_http_service_invocation_client.py +++ b/tests/clients/test_http_service_invocation_client.py @@ -33,186 +33,186 @@ def setUp(self): self.server_port = self.server.get_port() self.server.start() settings.DAPR_HTTP_PORT = self.server_port - settings.DAPR_API_METHOD_INVOCATION_PROTOCOL = "http" + settings.DAPR_API_METHOD_INVOCATION_PROTOCOL = 'http' self.client = DaprClient() - self.app_id = "fakeapp" - self.method_name = "fakemethod" - self.invoke_url = f"/v1.0/invoke/{self.app_id}/method/{self.method_name}" + self.app_id = 'fakeapp' + self.method_name = 'fakemethod' + self.invoke_url = f'/v1.0/invoke/{self.app_id}/method/{self.method_name}' def tearDown(self): self.server.shutdown_server() settings.DAPR_API_TOKEN = None - settings.DAPR_API_METHOD_INVOCATION_PROTOCOL = "http" + settings.DAPR_API_METHOD_INVOCATION_PROTOCOL = 'http' def test_get_api_url_default(self): client = DaprClient() self.assertEqual( - "http://{}:{}/{}".format( + 'http://{}:{}/{}'.format( settings.DAPR_RUNTIME_HOST, settings.DAPR_HTTP_PORT, settings.DAPR_API_VERSION ), client.invocation_client._client.get_api_url(), ) def test_get_api_url_endpoint_as_argument(self): - client = DaprClient("http://localhost:5000") + client = DaprClient('http://localhost:5000') self.assertEqual( - "http://localhost:5000/{}".format(settings.DAPR_API_VERSION), + 'http://localhost:5000/{}'.format(settings.DAPR_API_VERSION), client.invocation_client._client.get_api_url(), ) - @patch.object(settings, "DAPR_HTTP_ENDPOINT", "https://domain1.com:5000") + @patch.object(settings, 'DAPR_HTTP_ENDPOINT', 'https://domain1.com:5000') def test_get_api_url_endpoint_as_env_variable(self): client = DaprClient() self.assertEqual( - "https://domain1.com:5000/{}".format(settings.DAPR_API_VERSION), + 'https://domain1.com:5000/{}'.format(settings.DAPR_API_VERSION), client.invocation_client._client.get_api_url(), ) def test_basic_invoke(self): - self.server.set_response(b"STRING_BODY") + self.server.set_response(b'STRING_BODY') - response = self.client.invoke_method(self.app_id, self.method_name, "") + response = self.client.invoke_method(self.app_id, self.method_name, '') - self.assertEqual(b"STRING_BODY", response.data) + self.assertEqual(b'STRING_BODY', response.data) self.assertEqual(self.invoke_url, self.server.request_path()) def test_coroutine_basic_invoke(self): - self.server.set_response(b"STRING_BODY") + self.server.set_response(b'STRING_BODY') import asyncio loop = asyncio.new_event_loop() response = loop.run_until_complete( - self.client.invoke_method_async(self.app_id, self.method_name, "") + self.client.invoke_method_async(self.app_id, self.method_name, '') ) - self.assertEqual(b"STRING_BODY", response.data) + self.assertEqual(b'STRING_BODY', response.data) self.assertEqual(self.invoke_url, self.server.request_path()) def test_invoke_PUT_with_body(self): - self.server.set_response(b"STRING_BODY") + self.server.set_response(b'STRING_BODY') - response = self.client.invoke_method(self.app_id, self.method_name, b"FOO", http_verb="PUT") + response = self.client.invoke_method(self.app_id, self.method_name, b'FOO', http_verb='PUT') - self.assertEqual(b"STRING_BODY", response.data) + self.assertEqual(b'STRING_BODY', response.data) self.assertEqual(self.invoke_url, self.server.request_path()) - self.assertEqual(b"FOO", self.server.get_request_body()) + self.assertEqual(b'FOO', self.server.get_request_body()) def test_invoke_PUT_with_bytes_body(self): - self.server.set_response(b"STRING_BODY") + self.server.set_response(b'STRING_BODY') - response = self.client.invoke_method(self.app_id, self.method_name, b"FOO", http_verb="PUT") + response = self.client.invoke_method(self.app_id, self.method_name, b'FOO', http_verb='PUT') - self.assertEqual(b"STRING_BODY", response.data) + self.assertEqual(b'STRING_BODY', response.data) self.assertEqual(self.invoke_url, self.server.request_path()) - self.assertEqual(b"FOO", self.server.get_request_body()) + self.assertEqual(b'FOO', self.server.get_request_body()) def test_invoke_GET_with_query_params(self): - self.server.set_response(b"STRING_BODY") - query_params = (("key1", "value1"), ("key2", "value2")) + self.server.set_response(b'STRING_BODY') + query_params = (('key1', 'value1'), ('key2', 'value2')) response = self.client.invoke_method( - self.app_id, self.method_name, "", http_querystring=query_params + self.app_id, self.method_name, '', http_querystring=query_params ) - self.assertEqual(b"STRING_BODY", response.data) - self.assertEqual(f"{self.invoke_url}?key1=value1&key2=value2", self.server.request_path()) + self.assertEqual(b'STRING_BODY', response.data) + self.assertEqual(f'{self.invoke_url}?key1=value1&key2=value2', self.server.request_path()) def test_invoke_GET_with_duplicate_query_params(self): - self.server.set_response(b"STRING_BODY") - query_params = (("key1", "value1"), ("key1", "value2")) + self.server.set_response(b'STRING_BODY') + query_params = (('key1', 'value1'), ('key1', 'value2')) response = self.client.invoke_method( - self.app_id, self.method_name, "", http_querystring=query_params + self.app_id, self.method_name, '', http_querystring=query_params ) - self.assertEqual(b"STRING_BODY", response.data) - self.assertEqual(f"{self.invoke_url}?key1=value1&key1=value2", self.server.request_path()) + self.assertEqual(b'STRING_BODY', response.data) + self.assertEqual(f'{self.invoke_url}?key1=value1&key1=value2', self.server.request_path()) def test_invoke_PUT_with_content_type(self): - self.server.set_response(b"STRING_BODY") + self.server.set_response(b'STRING_BODY') - sample_object = {"foo": ["val1", "val2"]} + sample_object = {'foo': ['val1', 'val2']} response = self.client.invoke_method( self.app_id, self.method_name, json.dumps(sample_object), - content_type="application/json", + content_type='application/json', ) - self.assertEqual(b"STRING_BODY", response.data) + self.assertEqual(b'STRING_BODY', response.data) self.assertEqual(b'{"foo": ["val1", "val2"]}', self.server.get_request_body()) def test_invoke_method_proto_data(self): - self.server.set_response(b"\x0a\x04resp") - self.server.reply_header("Content-Type", "application/x-protobuf") + self.server.set_response(b'\x0a\x04resp') + self.server.reply_header('Content-Type', 'application/x-protobuf') - req = common_v1.StateItem(key="test") - resp = self.client.invoke_method(self.app_id, self.method_name, http_verb="PUT", data=req) + req = common_v1.StateItem(key='test') + resp = self.client.invoke_method(self.app_id, self.method_name, http_verb='PUT', data=req) - self.assertEqual(b"\x0a\x04test", self.server.get_request_body()) + self.assertEqual(b'\x0a\x04test', self.server.get_request_body()) # unpack to new protobuf object new_resp = common_v1.StateItem() - self.assertEqual(resp.headers["Content-Type"], ["application/x-protobuf"]) + self.assertEqual(resp.headers['Content-Type'], ['application/x-protobuf']) resp.unpack(new_resp) - self.assertEqual("resp", new_resp.key) + self.assertEqual('resp', new_resp.key) def test_invoke_method_metadata(self): - self.server.set_response(b"FOO") + self.server.set_response(b'FOO') - req = common_v1.StateItem(key="test") + req = common_v1.StateItem(key='test') resp = self.client.invoke_method( self.app_id, self.method_name, - http_verb="PUT", + http_verb='PUT', data=req, - metadata=(("header1", "value1"), ("header2", "value2")), + metadata=(('header1', 'value1'), ('header2', 'value2')), ) request_headers = self.server.get_request_headers() - self.assertEqual(b"FOO", resp.data) + self.assertEqual(b'FOO', resp.data) - self.assertEqual("value1", request_headers["header1"]) - self.assertEqual("value2", request_headers["header2"]) + self.assertEqual('value1', request_headers['header1']) + self.assertEqual('value2', request_headers['header2']) def test_invoke_method_protobuf_response_with_suffix(self): - self.server.set_response(b"\x0a\x04resp") - self.server.reply_header("Content-Type", "application/x-protobuf; gzip") + self.server.set_response(b'\x0a\x04resp') + self.server.reply_header('Content-Type', 'application/x-protobuf; gzip') - req = common_v1.StateItem(key="test") + req = common_v1.StateItem(key='test') resp = self.client.invoke_method( self.app_id, self.method_name, - http_verb="PUT", + http_verb='PUT', data=req, - metadata=(("header1", "value1"), ("header2", "value2")), + metadata=(('header1', 'value1'), ('header2', 'value2')), ) - self.assertEqual(b"\x0a\x04test", self.server.get_request_body()) + self.assertEqual(b'\x0a\x04test', self.server.get_request_body()) # unpack to new protobuf object new_resp = common_v1.StateItem() resp.unpack(new_resp) - self.assertEqual("resp", new_resp.key) + self.assertEqual('resp', new_resp.key) def test_invoke_method_protobuf_response_case_insensitive(self): - self.server.set_response(b"\x0a\x04resp") - self.server.reply_header("Content-Type", "apPlicaTion/x-protobuf; gzip") + self.server.set_response(b'\x0a\x04resp') + self.server.reply_header('Content-Type', 'apPlicaTion/x-protobuf; gzip') - req = common_v1.StateItem(key="test") + req = common_v1.StateItem(key='test') resp = self.client.invoke_method( self.app_id, self.method_name, - http_verb="PUT", + http_verb='PUT', data=req, - metadata=(("header1", "value1"), ("header2", "value2")), + metadata=(('header1', 'value1'), ('header2', 'value2')), ) - self.assertEqual(b"\x0a\x04test", self.server.get_request_body()) + self.assertEqual(b'\x0a\x04test', self.server.get_request_body()) # unpack to new protobuf object new_resp = common_v1.StateItem() resp.unpack(new_resp) - self.assertEqual("resp", new_resp.key) + self.assertEqual('resp', new_resp.key) def test_invoke_method_error_returned(self): error_response = b'{"errorCode":"ERR_DIRECT_INVOKE","message":"Something bad happend"}' @@ -224,62 +224,62 @@ def test_invoke_method_error_returned(self): self.client.invoke_method( self.app_id, self.method_name, - http_verb="PUT", - data="FOO", + http_verb='PUT', + data='FOO', ) self.assertEqual(expected_msg, str(ctx.exception)) def test_invoke_method_non_dapr_error(self): - error_response = b"UNPARSABLE_ERROR" + error_response = b'UNPARSABLE_ERROR' self.server.set_response(error_response, 500) - expected_msg = "Unknown Dapr Error. HTTP status code: 500" + expected_msg = 'Unknown Dapr Error. HTTP status code: 500' with self.assertRaises(DaprInternalError) as ctx: self.client.invoke_method( self.app_id, self.method_name, - http_verb="PUT", - data="FOO", + http_verb='PUT', + data='FOO', ) self.assertEqual(expected_msg, str(ctx.exception)) def test_generic_client_unknown_protocol(self): - settings.DAPR_API_METHOD_INVOCATION_PROTOCOL = "unknown" + settings.DAPR_API_METHOD_INVOCATION_PROTOCOL = 'unknown' - expected_msg = "Unknown value for DAPR_API_METHOD_INVOCATION_PROTOCOL: UNKNOWN" + expected_msg = 'Unknown value for DAPR_API_METHOD_INVOCATION_PROTOCOL: UNKNOWN' with self.assertRaises(DaprInternalError) as ctx: client = DaprClient() self.assertEqual(expected_msg, str(ctx.exception)) - settings.DAPR_API_METHOD_INVOCATION_PROTOCOL = "grpc" + settings.DAPR_API_METHOD_INVOCATION_PROTOCOL = 'grpc' client = DaprClient() self.assertIsNotNone(client) - settings.DAPR_API_METHOD_INVOCATION_PROTOCOL = "http" + settings.DAPR_API_METHOD_INVOCATION_PROTOCOL = 'http' client = DaprClient() self.assertIsNotNone(client) def test_invoke_method_with_api_token(self): - self.server.set_response(b"FOO") - settings.DAPR_API_TOKEN = "c29saSBkZW8gZ2xvcmlhCg==" + self.server.set_response(b'FOO') + settings.DAPR_API_TOKEN = 'c29saSBkZW8gZ2xvcmlhCg==' - req = common_v1.StateItem(key="test") + req = common_v1.StateItem(key='test') resp = self.client.invoke_method( self.app_id, self.method_name, - http_verb="PUT", + http_verb='PUT', data=req, ) request_headers = self.server.get_request_headers() - self.assertEqual("c29saSBkZW8gZ2xvcmlhCg==", request_headers["dapr-api-token"]) - self.assertEqual(b"FOO", resp.data) + self.assertEqual('c29saSBkZW8gZ2xvcmlhCg==', request_headers['dapr-api-token']) + self.assertEqual(b'FOO', resp.data) def test_invoke_method_with_tracer(self): tracer = Tracer(sampler=samplers.AlwaysOnSampler(), exporter=print_exporter.PrintExporter()) @@ -287,27 +287,27 @@ def test_invoke_method_with_tracer(self): self.client = DaprClient( headers_callback=lambda: tracer.propagator.to_headers(tracer.span_context) ) - self.server.set_response(b"FOO") + self.server.set_response(b'FOO') - with tracer.span(name="test"): - req = common_v1.StateItem(key="test") + with tracer.span(name='test'): + req = common_v1.StateItem(key='test') resp = self.client.invoke_method( self.app_id, self.method_name, - http_verb="PUT", + http_verb='PUT', data=req, ) request_headers = self.server.get_request_headers() - self.assertIn("Traceparent", request_headers) - self.assertEqual(b"FOO", resp.data) + self.assertIn('Traceparent', request_headers) + self.assertEqual(b'FOO', resp.data) def test_timeout_exception_thrown_when_timeout_reached(self): new_client = DaprClient(http_timeout_seconds=1) self.server.set_server_delay(1.5) with self.assertRaises(TimeoutError): - new_client.invoke_method(self.app_id, self.method_name, "") + new_client.invoke_method(self.app_id, self.method_name, '') def test_global_timeout_setting_is_honored(self): previous_timeout = settings.DAPR_HTTP_TIMEOUT_SECONDS @@ -315,6 +315,6 @@ def test_global_timeout_setting_is_honored(self): new_client = DaprClient() self.server.set_server_delay(1.5) with self.assertRaises(TimeoutError): - new_client.invoke_method(self.app_id, self.method_name, "") + new_client.invoke_method(self.app_id, self.method_name, '') settings.DAPR_HTTP_TIMEOUT_SECONDS = previous_timeout diff --git a/tests/clients/test_secure_dapr_async_grpc_client.py b/tests/clients/test_secure_dapr_async_grpc_client.py index f054a968..37a4e7c0 100644 --- a/tests/clients/test_secure_dapr_async_grpc_client.py +++ b/tests/clients/test_secure_dapr_async_grpc_client.py @@ -29,7 +29,7 @@ # Used temporarily, so we can trust self-signed certificates in unit tests # until they get their own environment variable def replacement_get_credentials_func(a): - f = open(os.path.join(os.path.dirname(__file__), "selfsigned.pem"), "rb") + f = open(os.path.join(os.path.dirname(__file__), 'selfsigned.pem'), 'rb') creds = grpc.ssl_channel_credentials(f.read()) f.close() @@ -41,7 +41,7 @@ def replacement_get_credentials_func(a): class DaprSecureGrpcClientAsyncTests(DaprGrpcClientAsyncTests): server_port = 4443 - scheme = "https://" + scheme = 'https://' def setUp(self): self._fake_dapr_server = FakeDaprSidecar() @@ -50,32 +50,32 @@ def setUp(self): def tearDown(self): self._fake_dapr_server.stop_secure() - @patch.object(settings, "DAPR_GRPC_ENDPOINT", "https://domain1.com:5000") + @patch.object(settings, 'DAPR_GRPC_ENDPOINT', 'https://domain1.com:5000') def test_init_with_DAPR_GRPC_ENDPOINT(self): dapr = DaprGrpcClientAsync() - self.assertEqual("dns:domain1.com:5000", dapr._uri.endpoint) + self.assertEqual('dns:domain1.com:5000', dapr._uri.endpoint) - @patch.object(settings, "DAPR_GRPC_ENDPOINT", "https://domain1.com:5000") + @patch.object(settings, 'DAPR_GRPC_ENDPOINT', 'https://domain1.com:5000') def test_init_with_DAPR_GRPC_ENDPOINT_and_argument(self): - dapr = DaprGrpcClientAsync("https://domain2.com:5002") - self.assertEqual("dns:domain2.com:5002", dapr._uri.endpoint) + dapr = DaprGrpcClientAsync('https://domain2.com:5002') + self.assertEqual('dns:domain2.com:5002', dapr._uri.endpoint) - @patch.object(settings, "DAPR_GRPC_ENDPOINT", "https://domain1.com:5000") - @patch.object(settings, "DAPR_RUNTIME_HOST", "domain2.com") - @patch.object(settings, "DAPR_GRPC_PORT", "5002") + @patch.object(settings, 'DAPR_GRPC_ENDPOINT', 'https://domain1.com:5000') + @patch.object(settings, 'DAPR_RUNTIME_HOST', 'domain2.com') + @patch.object(settings, 'DAPR_GRPC_PORT', '5002') def test_init_with_DAPR_GRPC_ENDPOINT_and_DAPR_RUNTIME_HOST(self): dapr = DaprGrpcClientAsync() - self.assertEqual("dns:domain1.com:5000", dapr._uri.endpoint) + self.assertEqual('dns:domain1.com:5000', dapr._uri.endpoint) - @patch.object(settings, "DAPR_RUNTIME_HOST", "domain1.com") - @patch.object(settings, "DAPR_GRPC_PORT", "5000") + @patch.object(settings, 'DAPR_RUNTIME_HOST', 'domain1.com') + @patch.object(settings, 'DAPR_GRPC_PORT', '5000') def test_init_with_argument_and_DAPR_GRPC_ENDPOINT_and_DAPR_RUNTIME_HOST(self): - dapr = DaprGrpcClientAsync("https://domain2.com:5002") - self.assertEqual("dns:domain2.com:5002", dapr._uri.endpoint) + dapr = DaprGrpcClientAsync('https://domain2.com:5002') + self.assertEqual('dns:domain2.com:5002', dapr._uri.endpoint) async def test_dapr_api_token_insertion(self): pass -if __name__ == "__main__": +if __name__ == '__main__': unittest.main() diff --git a/tests/clients/test_secure_dapr_grpc_client.py b/tests/clients/test_secure_dapr_grpc_client.py index 2a9bdee6..07a128ea 100644 --- a/tests/clients/test_secure_dapr_grpc_client.py +++ b/tests/clients/test_secure_dapr_grpc_client.py @@ -27,7 +27,7 @@ # Used temporarily, so we can trust self-signed certificates in unit tests # until they get their own environment variable def replacement_get_credentials_func(a): - f = open(os.path.join(os.path.dirname(__file__), "selfsigned.pem"), "rb") + f = open(os.path.join(os.path.dirname(__file__), 'selfsigned.pem'), 'rb') creds = grpc.ssl_channel_credentials(f.read()) f.close() @@ -39,7 +39,7 @@ def replacement_get_credentials_func(a): class DaprSecureGrpcClientTests(DaprGrpcClientTests): server_port = 4443 - scheme = "https://" + scheme = 'https://' def setUp(self): self._fake_dapr_server = FakeDaprSidecar() @@ -48,29 +48,29 @@ def setUp(self): def tearDown(self): self._fake_dapr_server.stop_secure() - @patch.object(settings, "DAPR_GRPC_ENDPOINT", "https://domain1.com:5000") + @patch.object(settings, 'DAPR_GRPC_ENDPOINT', 'https://domain1.com:5000') def test_init_with_DAPR_GRPC_ENDPOINT(self): dapr = DaprGrpcClient() - self.assertEqual("dns:domain1.com:5000", dapr._uri.endpoint) + self.assertEqual('dns:domain1.com:5000', dapr._uri.endpoint) - @patch.object(settings, "DAPR_GRPC_ENDPOINT", "https://domain1.com:5000") + @patch.object(settings, 'DAPR_GRPC_ENDPOINT', 'https://domain1.com:5000') def test_init_with_DAPR_GRPC_ENDPOINT_and_argument(self): - dapr = DaprGrpcClient("https://domain2.com:5002") - self.assertEqual("dns:domain2.com:5002", dapr._uri.endpoint) + dapr = DaprGrpcClient('https://domain2.com:5002') + self.assertEqual('dns:domain2.com:5002', dapr._uri.endpoint) - @patch.object(settings, "DAPR_GRPC_ENDPOINT", "https://domain1.com:5000") - @patch.object(settings, "DAPR_RUNTIME_HOST", "domain2.com") - @patch.object(settings, "DAPR_GRPC_PORT", "5002") + @patch.object(settings, 'DAPR_GRPC_ENDPOINT', 'https://domain1.com:5000') + @patch.object(settings, 'DAPR_RUNTIME_HOST', 'domain2.com') + @patch.object(settings, 'DAPR_GRPC_PORT', '5002') def test_init_with_DAPR_GRPC_ENDPOINT_and_DAPR_RUNTIME_HOST(self): dapr = DaprGrpcClient() - self.assertEqual("dns:domain1.com:5000", dapr._uri.endpoint) + self.assertEqual('dns:domain1.com:5000', dapr._uri.endpoint) - @patch.object(settings, "DAPR_RUNTIME_HOST", "domain1.com") - @patch.object(settings, "DAPR_GRPC_PORT", "5000") + @patch.object(settings, 'DAPR_RUNTIME_HOST', 'domain1.com') + @patch.object(settings, 'DAPR_GRPC_PORT', '5000') def test_init_with_argument_and_DAPR_GRPC_ENDPOINT_and_DAPR_RUNTIME_HOST(self): - dapr = DaprGrpcClient("https://domain2.com:5002") - self.assertEqual("dns:domain2.com:5002", dapr._uri.endpoint) + dapr = DaprGrpcClient('https://domain2.com:5002') + self.assertEqual('dns:domain2.com:5002', dapr._uri.endpoint) -if __name__ == "__main__": +if __name__ == '__main__': unittest.main() diff --git a/tests/clients/test_secure_http_service_invocation_client.py b/tests/clients/test_secure_http_service_invocation_client.py index 5a5455bd..6efb4d07 100644 --- a/tests/clients/test_secure_http_service_invocation_client.py +++ b/tests/clients/test_secure_http_service_invocation_client.py @@ -44,24 +44,24 @@ def setUp(self): self.server_port = self.server.get_port() self.server.start() settings.DAPR_HTTP_PORT = self.server_port - settings.DAPR_API_METHOD_INVOCATION_PROTOCOL = "http" - self.client = DaprClient("https://localhost:{}".format(self.server_port)) - self.app_id = "fakeapp" - self.method_name = "fakemethod" - self.invoke_url = f"/v1.0/invoke/{self.app_id}/method/{self.method_name}" + settings.DAPR_API_METHOD_INVOCATION_PROTOCOL = 'http' + self.client = DaprClient('https://localhost:{}'.format(self.server_port)) + self.app_id = 'fakeapp' + self.method_name = 'fakemethod' + self.invoke_url = f'/v1.0/invoke/{self.app_id}/method/{self.method_name}' def tearDown(self): self.server.shutdown_server() settings.DAPR_API_TOKEN = None - settings.DAPR_API_METHOD_INVOCATION_PROTOCOL = "http" + settings.DAPR_API_METHOD_INVOCATION_PROTOCOL = 'http' def test_global_timeout_setting_is_honored(self): previous_timeout = settings.DAPR_HTTP_TIMEOUT_SECONDS settings.DAPR_HTTP_TIMEOUT_SECONDS = 1 - new_client = DaprClient("https://localhost:{}".format(self.server_port)) + new_client = DaprClient('https://localhost:{}'.format(self.server_port)) self.server.set_server_delay(1.5) with self.assertRaises(TimeoutError): - new_client.invoke_method(self.app_id, self.method_name, "") + new_client.invoke_method(self.app_id, self.method_name, '') settings.DAPR_HTTP_TIMEOUT_SECONDS = previous_timeout @@ -69,29 +69,29 @@ def test_invoke_method_with_tracer(self): tracer = Tracer(sampler=samplers.AlwaysOnSampler(), exporter=print_exporter.PrintExporter()) self.client = DaprClient( - "https://localhost:{}".format(self.server_port), + 'https://localhost:{}'.format(self.server_port), headers_callback=lambda: tracer.propagator.to_headers(tracer.span_context), ) - self.server.set_response(b"FOO") + self.server.set_response(b'FOO') - with tracer.span(name="test"): - req = common_v1.StateItem(key="test") + with tracer.span(name='test'): + req = common_v1.StateItem(key='test') resp = self.client.invoke_method( self.app_id, self.method_name, - http_verb="PUT", + http_verb='PUT', data=req, ) request_headers = self.server.get_request_headers() - self.assertIn("Traceparent", request_headers) - self.assertEqual(b"FOO", resp.data) + self.assertIn('Traceparent', request_headers) + self.assertEqual(b'FOO', resp.data) def test_timeout_exception_thrown_when_timeout_reached(self): new_client = DaprClient( - "https://localhost:{}".format(self.server_port), http_timeout_seconds=1 + 'https://localhost:{}'.format(self.server_port), http_timeout_seconds=1 ) self.server.set_server_delay(1.5) with self.assertRaises(TimeoutError): - new_client.invoke_method(self.app_id, self.method_name, "") + new_client.invoke_method(self.app_id, self.method_name, '') diff --git a/tests/conf/helpers_test.py b/tests/conf/helpers_test.py index 456f40d7..d09eb3d9 100644 --- a/tests/conf/helpers_test.py +++ b/tests/conf/helpers_test.py @@ -8,354 +8,354 @@ def test_parse_grpc_endpoint(self): testcases = [ # Port only { - "url": ":5000", - "error": False, - "secure": False, - "scheme": "", - "host": "localhost", - "port": 5000, - "endpoint": "dns:localhost:5000", - }, - { - "url": ":5000?tls=false", - "error": False, - "secure": False, - "scheme": "", - "host": "localhost", - "port": 5000, - "endpoint": "dns:localhost:5000", - }, - { - "url": ":5000?tls=true", - "error": False, - "secure": True, - "scheme": "", - "host": "localhost", - "port": 5000, - "endpoint": "dns:localhost:5000", + 'url': ':5000', + 'error': False, + 'secure': False, + 'scheme': '', + 'host': 'localhost', + 'port': 5000, + 'endpoint': 'dns:localhost:5000', + }, + { + 'url': ':5000?tls=false', + 'error': False, + 'secure': False, + 'scheme': '', + 'host': 'localhost', + 'port': 5000, + 'endpoint': 'dns:localhost:5000', + }, + { + 'url': ':5000?tls=true', + 'error': False, + 'secure': True, + 'scheme': '', + 'host': 'localhost', + 'port': 5000, + 'endpoint': 'dns:localhost:5000', }, # Host only { - "url": "myhost", - "error": False, - "secure": False, - "scheme": "", - "host": "myhost", - "port": 443, - "endpoint": "dns:myhost:443", + 'url': 'myhost', + 'error': False, + 'secure': False, + 'scheme': '', + 'host': 'myhost', + 'port': 443, + 'endpoint': 'dns:myhost:443', }, { - "url": "myhost?tls=false", - "error": False, - "secure": False, - "scheme": "", - "host": "myhost", - "port": 443, - "endpoint": "dns:myhost:443", + 'url': 'myhost?tls=false', + 'error': False, + 'secure': False, + 'scheme': '', + 'host': 'myhost', + 'port': 443, + 'endpoint': 'dns:myhost:443', }, { - "url": "myhost?tls=true", - "error": False, - "secure": True, - "scheme": "", - "host": "myhost", - "port": 443, - "endpoint": "dns:myhost:443", + 'url': 'myhost?tls=true', + 'error': False, + 'secure': True, + 'scheme': '', + 'host': 'myhost', + 'port': 443, + 'endpoint': 'dns:myhost:443', }, # Host and port { - "url": "myhost:443", - "error": False, - "secure": False, - "scheme": "", - "host": "myhost", - "port": 443, - "endpoint": "dns:myhost:443", + 'url': 'myhost:443', + 'error': False, + 'secure': False, + 'scheme': '', + 'host': 'myhost', + 'port': 443, + 'endpoint': 'dns:myhost:443', }, { - "url": "myhost:443?tls=false", - "error": False, - "secure": False, - "scheme": "", - "host": "myhost", - "port": 443, - "endpoint": "dns:myhost:443", + 'url': 'myhost:443?tls=false', + 'error': False, + 'secure': False, + 'scheme': '', + 'host': 'myhost', + 'port': 443, + 'endpoint': 'dns:myhost:443', }, { - "url": "myhost:443?tls=true", - "error": False, - "secure": True, - "scheme": "", - "host": "myhost", - "port": 443, - "endpoint": "dns:myhost:443", + 'url': 'myhost:443?tls=true', + 'error': False, + 'secure': True, + 'scheme': '', + 'host': 'myhost', + 'port': 443, + 'endpoint': 'dns:myhost:443', }, # Scheme, host and port { - "url": "http://myhost", - "error": False, - "secure": False, - "scheme": "", - "host": "myhost", - "port": 443, - "endpoint": "dns:myhost:443", + 'url': 'http://myhost', + 'error': False, + 'secure': False, + 'scheme': '', + 'host': 'myhost', + 'port': 443, + 'endpoint': 'dns:myhost:443', }, - {"url": "http://myhost?tls=false", "error": True}, + {'url': 'http://myhost?tls=false', 'error': True}, # We can't have both http/https and the tls query parameter - {"url": "http://myhost?tls=true", "error": True}, + {'url': 'http://myhost?tls=true', 'error': True}, # We can't have both http/https and the tls query parameter { - "url": "http://myhost:443", - "error": False, - "secure": False, - "scheme": "", - "host": "myhost", - "port": 443, - "endpoint": "dns:myhost:443", + 'url': 'http://myhost:443', + 'error': False, + 'secure': False, + 'scheme': '', + 'host': 'myhost', + 'port': 443, + 'endpoint': 'dns:myhost:443', }, - {"url": "http://myhost:443?tls=false", "error": True}, + {'url': 'http://myhost:443?tls=false', 'error': True}, # We can't have both http/https and the tls query parameter - {"url": "http://myhost:443?tls=true", "error": True}, + {'url': 'http://myhost:443?tls=true', 'error': True}, # We can't have both http/https and the tls query parameter { - "url": "http://myhost:5000", - "error": False, - "secure": False, - "scheme": "", - "host": "myhost", - "port": 5000, - "endpoint": "dns:myhost:5000", + 'url': 'http://myhost:5000', + 'error': False, + 'secure': False, + 'scheme': '', + 'host': 'myhost', + 'port': 5000, + 'endpoint': 'dns:myhost:5000', }, - {"url": "http://myhost:5000?tls=false", "error": True}, + {'url': 'http://myhost:5000?tls=false', 'error': True}, # We can't have both http/https and the tls query parameter - {"url": "http://myhost:5000?tls=true", "error": True}, + {'url': 'http://myhost:5000?tls=true', 'error': True}, # We can't have both http/https and the tls query parameter { - "url": "https://myhost:443", - "error": False, - "secure": True, - "scheme": "", - "host": "myhost", - "port": 443, - "endpoint": "dns:myhost:443", + 'url': 'https://myhost:443', + 'error': False, + 'secure': True, + 'scheme': '', + 'host': 'myhost', + 'port': 443, + 'endpoint': 'dns:myhost:443', }, - {"url": "https://myhost:443?tls=false", "error": True}, - {"url": "https://myhost:443?tls=true", "error": True}, + {'url': 'https://myhost:443?tls=false', 'error': True}, + {'url': 'https://myhost:443?tls=true', 'error': True}, # Scheme = dns { - "url": "dns:myhost", - "error": False, - "secure": False, - "scheme": "dns", - "host": "myhost", - "port": 443, - "endpoint": "dns:myhost:443", + 'url': 'dns:myhost', + 'error': False, + 'secure': False, + 'scheme': 'dns', + 'host': 'myhost', + 'port': 443, + 'endpoint': 'dns:myhost:443', }, { - "url": "dns:myhost?tls=false", - "error": False, - "secure": False, - "scheme": "dns", - "host": "myhost", - "port": 443, - "endpoint": "dns:myhost:443", + 'url': 'dns:myhost?tls=false', + 'error': False, + 'secure': False, + 'scheme': 'dns', + 'host': 'myhost', + 'port': 443, + 'endpoint': 'dns:myhost:443', }, { - "url": "dns:myhost?tls=true", - "error": False, - "secure": True, - "scheme": "dns", - "host": "myhost", - "port": 443, - "endpoint": "dns:myhost:443", + 'url': 'dns:myhost?tls=true', + 'error': False, + 'secure': True, + 'scheme': 'dns', + 'host': 'myhost', + 'port': 443, + 'endpoint': 'dns:myhost:443', }, # Scheme = dns with authority { - "url": "dns://myauthority:53/myhost", - "error": False, - "secure": False, - "scheme": "dns", - "host": "myhost", - "port": 443, - "endpoint": "dns://myauthority:53/myhost:443", - }, - { - "url": "dns://myauthority:53/myhost?tls=false", - "error": False, - "secure": False, - "scheme": "dns", - "host": "myhost", - "port": 443, - "endpoint": "dns://myauthority:53/myhost:443", - }, - { - "url": "dns://myauthority:53/myhost?tls=true", - "error": False, - "secure": True, - "scheme": "dns", - "host": "myhost", - "port": 443, - "endpoint": "dns://myauthority:53/myhost:443", - }, - {"url": "dns://myhost", "error": True}, + 'url': 'dns://myauthority:53/myhost', + 'error': False, + 'secure': False, + 'scheme': 'dns', + 'host': 'myhost', + 'port': 443, + 'endpoint': 'dns://myauthority:53/myhost:443', + }, + { + 'url': 'dns://myauthority:53/myhost?tls=false', + 'error': False, + 'secure': False, + 'scheme': 'dns', + 'host': 'myhost', + 'port': 443, + 'endpoint': 'dns://myauthority:53/myhost:443', + }, + { + 'url': 'dns://myauthority:53/myhost?tls=true', + 'error': False, + 'secure': True, + 'scheme': 'dns', + 'host': 'myhost', + 'port': 443, + 'endpoint': 'dns://myauthority:53/myhost:443', + }, + {'url': 'dns://myhost', 'error': True}, # Unix sockets { - "url": "unix:my.sock", - "error": False, - "secure": False, - "scheme": "unix", - "host": "my.sock", - "port": "", - "endpoint": "unix:my.sock", + 'url': 'unix:my.sock', + 'error': False, + 'secure': False, + 'scheme': 'unix', + 'host': 'my.sock', + 'port': '', + 'endpoint': 'unix:my.sock', }, { - "url": "unix:my.sock?tls=true", - "error": False, - "secure": True, - "scheme": "unix", - "host": "my.sock", - "port": "", - "endpoint": "unix:my.sock", + 'url': 'unix:my.sock?tls=true', + 'error': False, + 'secure': True, + 'scheme': 'unix', + 'host': 'my.sock', + 'port': '', + 'endpoint': 'unix:my.sock', }, # Unix sockets with absolute path { - "url": "unix://my.sock", - "error": False, - "secure": False, - "scheme": "unix", - "host": "my.sock", - "port": "", - "endpoint": "unix://my.sock", + 'url': 'unix://my.sock', + 'error': False, + 'secure': False, + 'scheme': 'unix', + 'host': 'my.sock', + 'port': '', + 'endpoint': 'unix://my.sock', }, { - "url": "unix://my.sock?tls=true", - "error": False, - "secure": True, - "scheme": "unix", - "host": "my.sock", - "port": "", - "endpoint": "unix://my.sock", + 'url': 'unix://my.sock?tls=true', + 'error': False, + 'secure': True, + 'scheme': 'unix', + 'host': 'my.sock', + 'port': '', + 'endpoint': 'unix://my.sock', }, # Unix abstract sockets { - "url": "unix-abstract:my.sock", - "error": False, - "secure": False, - "scheme": "unix", - "host": "my.sock", - "port": "", - "endpoint": "unix-abstract:my.sock", + 'url': 'unix-abstract:my.sock', + 'error': False, + 'secure': False, + 'scheme': 'unix', + 'host': 'my.sock', + 'port': '', + 'endpoint': 'unix-abstract:my.sock', }, { - "url": "unix-abstract:my.sock?tls=true", - "error": False, - "secure": True, - "scheme": "unix", - "host": "my.sock", - "port": "", - "endpoint": "unix-abstract:my.sock", + 'url': 'unix-abstract:my.sock?tls=true', + 'error': False, + 'secure': True, + 'scheme': 'unix', + 'host': 'my.sock', + 'port': '', + 'endpoint': 'unix-abstract:my.sock', }, # Vsock { - "url": "vsock:mycid", - "error": False, - "secure": False, - "scheme": "vsock", - "host": "mycid", - "port": "443", - "endpoint": "vsock:mycid:443", + 'url': 'vsock:mycid', + 'error': False, + 'secure': False, + 'scheme': 'vsock', + 'host': 'mycid', + 'port': '443', + 'endpoint': 'vsock:mycid:443', }, { - "url": "vsock:mycid:5000", - "error": False, - "secure": False, - "scheme": "vsock", - "host": "mycid", - "port": 5000, - "endpoint": "vsock:mycid:5000", + 'url': 'vsock:mycid:5000', + 'error': False, + 'secure': False, + 'scheme': 'vsock', + 'host': 'mycid', + 'port': 5000, + 'endpoint': 'vsock:mycid:5000', }, { - "url": "vsock:mycid:5000?tls=true", - "error": False, - "secure": True, - "scheme": "vsock", - "host": "mycid", - "port": 5000, - "endpoint": "vsock:mycid:5000", + 'url': 'vsock:mycid:5000?tls=true', + 'error': False, + 'secure': True, + 'scheme': 'vsock', + 'host': 'mycid', + 'port': 5000, + 'endpoint': 'vsock:mycid:5000', }, # IPv6 addresses with dns scheme { - "url": "[2001:db8:1f70::999:de8:7648:6e8]", - "error": False, - "secure": False, - "scheme": "", - "host": "[2001:db8:1f70::999:de8:7648:6e8]", - "port": 443, - "endpoint": "dns:[2001:db8:1f70::999:de8:7648:6e8]:443", - }, - { - "url": "dns:[2001:db8:1f70::999:de8:7648:6e8]", - "error": False, - "secure": False, - "scheme": "", - "host": "[2001:db8:1f70::999:de8:7648:6e8]", - "port": 443, - "endpoint": "dns:[2001:db8:1f70::999:de8:7648:6e8]:443", - }, - { - "url": "dns:[2001:db8:1f70::999:de8:7648:6e8]:5000", - "error": False, - "secure": False, - "scheme": "", - "host": "[2001:db8:1f70::999:de8:7648:6e8]", - "port": 5000, - "endpoint": "dns:[2001:db8:1f70::999:de8:7648:6e8]:5000", - }, - {"url": "dns:[2001:db8:1f70::999:de8:7648:6e8]:5000?abc=[]", "error": True}, + 'url': '[2001:db8:1f70::999:de8:7648:6e8]', + 'error': False, + 'secure': False, + 'scheme': '', + 'host': '[2001:db8:1f70::999:de8:7648:6e8]', + 'port': 443, + 'endpoint': 'dns:[2001:db8:1f70::999:de8:7648:6e8]:443', + }, + { + 'url': 'dns:[2001:db8:1f70::999:de8:7648:6e8]', + 'error': False, + 'secure': False, + 'scheme': '', + 'host': '[2001:db8:1f70::999:de8:7648:6e8]', + 'port': 443, + 'endpoint': 'dns:[2001:db8:1f70::999:de8:7648:6e8]:443', + }, + { + 'url': 'dns:[2001:db8:1f70::999:de8:7648:6e8]:5000', + 'error': False, + 'secure': False, + 'scheme': '', + 'host': '[2001:db8:1f70::999:de8:7648:6e8]', + 'port': 5000, + 'endpoint': 'dns:[2001:db8:1f70::999:de8:7648:6e8]:5000', + }, + {'url': 'dns:[2001:db8:1f70::999:de8:7648:6e8]:5000?abc=[]', 'error': True}, # IPv6 addresses with dns scheme and authority { - "url": "dns://myauthority:53/[2001:db8:1f70::999:de8:7648:6e8]", - "error": False, - "secure": False, - "scheme": "dns", - "host": "[2001:db8:1f70::999:de8:7648:6e8]", - "port": 443, - "endpoint": "dns://myauthority:53/[2001:db8:1f70::999:de8:7648:6e8]:443", + 'url': 'dns://myauthority:53/[2001:db8:1f70::999:de8:7648:6e8]', + 'error': False, + 'secure': False, + 'scheme': 'dns', + 'host': '[2001:db8:1f70::999:de8:7648:6e8]', + 'port': 443, + 'endpoint': 'dns://myauthority:53/[2001:db8:1f70::999:de8:7648:6e8]:443', }, # IPv6 addresses with https scheme { - "url": "https://[2001:db8:1f70::999:de8:7648:6e8]", - "error": False, - "secure": True, - "scheme": "", - "host": "[2001:db8:1f70::999:de8:7648:6e8]", - "port": 443, - "endpoint": "dns:[2001:db8:1f70::999:de8:7648:6e8]:443", + 'url': 'https://[2001:db8:1f70::999:de8:7648:6e8]', + 'error': False, + 'secure': True, + 'scheme': '', + 'host': '[2001:db8:1f70::999:de8:7648:6e8]', + 'port': 443, + 'endpoint': 'dns:[2001:db8:1f70::999:de8:7648:6e8]:443', }, { - "url": "https://[2001:db8:1f70::999:de8:7648:6e8]:5000", - "error": False, - "secure": True, - "scheme": "", - "host": "[2001:db8:1f70::999:de8:7648:6e8]", - "port": 5000, - "endpoint": "dns:[2001:db8:1f70::999:de8:7648:6e8]:5000", + 'url': 'https://[2001:db8:1f70::999:de8:7648:6e8]:5000', + 'error': False, + 'secure': True, + 'scheme': '', + 'host': '[2001:db8:1f70::999:de8:7648:6e8]', + 'port': 5000, + 'endpoint': 'dns:[2001:db8:1f70::999:de8:7648:6e8]:5000', }, # Invalid addresses (with path and queries) - {"url": "host:5000/v1/dapr", "error": True}, # Paths are not allowed in grpc endpoints - {"url": "host:5000/?a=1", "error": True}, # Query params not allowed in grpc endpoints + {'url': 'host:5000/v1/dapr', 'error': True}, # Paths are not allowed in grpc endpoints + {'url': 'host:5000/?a=1', 'error': True}, # Query params not allowed in grpc endpoints # Invalid scheme - {"url": "inv-scheme://myhost", "error": True}, - {"url": "inv-scheme:myhost:5000", "error": True}, + {'url': 'inv-scheme://myhost', 'error': True}, + {'url': 'inv-scheme:myhost:5000', 'error': True}, ] for testcase in testcases: - if testcase["error"]: + if testcase['error']: with self.assertRaises(ValueError): - GrpcEndpoint(testcase["url"]) + GrpcEndpoint(testcase['url']) else: - url = GrpcEndpoint(testcase["url"]) - assert url.endpoint == testcase["endpoint"] - assert url.tls == testcase["secure"] - assert url.hostname == testcase["host"] - assert url.port == str(testcase["port"]) + url = GrpcEndpoint(testcase['url']) + assert url.endpoint == testcase['endpoint'] + assert url.tls == testcase['secure'] + assert url.hostname == testcase['host'] + assert url.port == str(testcase['port']) diff --git a/tests/serializers/test_default_json_serializer.py b/tests/serializers/test_default_json_serializer.py index fce99476..86e727ad 100644 --- a/tests/serializers/test_default_json_serializer.py +++ b/tests/serializers/test_default_json_serializer.py @@ -33,9 +33,9 @@ def test_serialize(self): tzinfo=datetime.timezone.utc, ) input_dict_obj = { - "propertyDecimal": 10, - "propertyStr": "StrValue", - "propertyDateTime": fakeDateTime, + 'propertyDecimal': 10, + 'propertyStr': 'StrValue', + 'propertyDateTime': fakeDateTime, } serialized = serializer.serialize(input_dict_obj) self.assertEqual( @@ -47,11 +47,11 @@ def test_serialize_bytes(self): serializer = DefaultJSONSerializer() # Serialize`bytes data - serialized = serializer.serialize(b"bytes_data") + serialized = serializer.serialize(b'bytes_data') self.assertEqual(b'"Ynl0ZXNfZGF0YQ=="', serialized) # Serialize`bytes property - input_dict_obj = {"propertyBytes": b"bytes_property"} + input_dict_obj = {'propertyBytes': b'bytes_property'} serialized = serializer.serialize(input_dict_obj) self.assertEqual(serialized, b'{"propertyBytes":"Ynl0ZXNfcHJvcGVydHk="}') @@ -60,11 +60,11 @@ def test_deserialize(self): payload = b'{"propertyDecimal":10,"propertyStr":"StrValue","propertyDateTime":"2020-01-01T01:00:00Z"}' # noqa: E501 obj = serializer.deserialize(payload) - self.assertEqual(obj["propertyDecimal"], 10) - self.assertEqual(obj["propertyStr"], "StrValue") - self.assertTrue(isinstance(obj["propertyDateTime"], datetime.datetime)) + self.assertEqual(obj['propertyDecimal'], 10) + self.assertEqual(obj['propertyStr'], 'StrValue') + self.assertTrue(isinstance(obj['propertyDateTime'], datetime.datetime)) self.assertEqual( - obj["propertyDateTime"], + obj['propertyDateTime'], datetime.datetime( year=2020, month=1, @@ -78,5 +78,5 @@ def test_deserialize(self): ) -if __name__ == "__main__": +if __name__ == '__main__': unittest.main() diff --git a/tests/serializers/test_util.py b/tests/serializers/test_util.py index aa9a2e96..9f3b9e02 100644 --- a/tests/serializers/test_util.py +++ b/tests/serializers/test_util.py @@ -26,54 +26,54 @@ def setUp(self): pass def test_convert_hour_mins_secs(self): - delta = convert_from_dapr_duration("4h15m40s") + delta = convert_from_dapr_duration('4h15m40s') self.assertEqual(delta.total_seconds(), 15340.0) def test_convert_mins_secs(self): - delta = convert_from_dapr_duration("15m40s") + delta = convert_from_dapr_duration('15m40s') self.assertEqual(delta.total_seconds(), 940.0) def test_convert_secs(self): - delta = convert_from_dapr_duration("40s") + delta = convert_from_dapr_duration('40s') self.assertEqual(delta.total_seconds(), 40.0) def test_convert_millisecs(self): - delta = convert_from_dapr_duration("123ms") + delta = convert_from_dapr_duration('123ms') self.assertEqual(delta.total_seconds(), 0.123) def test_convert_microsecs_μs(self): - delta = convert_from_dapr_duration("123μs") + delta = convert_from_dapr_duration('123μs') self.assertEqual(delta.microseconds, 123) def test_convert_microsecs_us(self): - delta = convert_from_dapr_duration("345us") + delta = convert_from_dapr_duration('345us') self.assertEqual(delta.microseconds, 345) def test_convert_invalid_duration(self): with self.assertRaises(ValueError) as exeception_context: - convert_from_dapr_duration("invalid") + convert_from_dapr_duration('invalid') self.assertEqual( exeception_context.exception.args[0], - "Invalid Dapr Duration format: '{}'".format("invalid"), + "Invalid Dapr Duration format: '{}'".format('invalid'), ) def test_convert_timedelta_to_dapr_duration(self): duration = convert_to_dapr_duration( timedelta(hours=4, minutes=15, seconds=40, milliseconds=123, microseconds=35) ) - self.assertEqual(duration, "4h15m40s123ms35μs") + self.assertEqual(duration, '4h15m40s123ms35μs') def test_convert_invalid_duration_string(self): - TESTSTRING = "4h15m40s123ms35μshello" + TESTSTRING = '4h15m40s123ms35μshello' with self.assertRaises(ValueError) as exeception_context: convert_from_dapr_duration(TESTSTRING) self.assertEqual( exeception_context.exception.args[0], "Invalid Dapr Duration format: '{}'".format(TESTSTRING), ) - decoded = json.loads(json.dumps({"somevar": TESTSTRING}), cls=DaprJSONDecoder) - self.assertEqual(decoded["somevar"], TESTSTRING) + decoded = json.loads(json.dumps({'somevar': TESTSTRING}), cls=DaprJSONDecoder) + self.assertEqual(decoded['somevar'], TESTSTRING) -if __name__ == "__main__": +if __name__ == '__main__': unittest.main()