processcube-etw-library 2026.1.22.145211__py3-none-any.whl → 2026.1.29.71849b0__py3-none-any.whl

processcube_etw_library/processcube_client/core/api/helpers/application_info.py

@@ -0,0 +1,34 @@
+from dataclasses import dataclass
+from dataclasses_json import dataclass_json, LetterCase
+from typing import Callable
+
+from ..base_client import BaseClient
+
+
+@dataclass_json(letter_case=LetterCase.CAMEL)
+@dataclass
+class ApplicationInfo:
+    id: str
+    name: str
+    package_name: str
+    version: str
+    authority_url: str
+    allow_anonymous_root_access: str
+    extra_info: dict
+
+
+class ApplicationInfoHandler(BaseClient):
+    def __init__(self, url: str, identity: Callable = None, api_version: str = "v1"):
+        super(ApplicationInfoHandler, self).__init__(url, identity, api_version)
+
+    def info(self) -> ApplicationInfo:
+        json_data = self.do_get("info")
+
+        info = ApplicationInfo.from_dict(json_data)
+
+        return info
+
+    def authority(self) -> str:
+        json_data = self.do_get("authority")
+
+        return json_data

processcube_etw_library/processcube_client/core/api/helpers/data_object_instances.py

@@ -0,0 +1,61 @@
+from dataclasses import dataclass, field
+from dataclasses_json import dataclass_json, LetterCase, Undefined
+from dataclasses_json import CatchAll
+from typing import Any, Callable, Dict, List, Optional
+from urllib import parse
+
+from ..base_client import BaseClient
+
+
+@dataclass_json(letter_case=LetterCase.CAMEL)
+@dataclass
+class DataObjectInstancesQuery:
+    limit: int = None
+    offset: int = None
+    data_object_id: str = None
+    process_definition_id: str = None
+    process_model_id: str = None
+    process_instance_id: str = None
+    flow_node_instance_id: str = None
+
+
+@dataclass_json(letter_case=LetterCase.CAMEL, undefined=Undefined.INCLUDE)
+@dataclass
+class DataObjectInstanceResponse:
+    data_object_id: Optional[str] = None
+    flow_node_instance_id: Optional[str] = None
+    process_definition_id: Optional[str] = None
+    process_model_id: Optional[str] = None
+    process_instance_id: Optional[str] = None
+    value: Dict[str, Any] = field(default_factory=dict)
+    created_at: Optional[str] = None
+    updated_at: Optional[str] = None
+    place_holder: CatchAll = None
+
+
+class DataObjectInstanceHandler(BaseClient):
+    def __init__(self, url: str, identity: Callable = None, api_version: str = "v1"):
+        super(DataObjectInstanceHandler, self).__init__(url, identity, api_version)
+
+    def query(
+        self, request: DataObjectInstancesQuery, options: dict = {}
+    ) -> List[DataObjectInstanceResponse]:
+        query_dict = request.to_dict()
+
+        filtered_query = list(
+            filter(lambda dict_entry: dict_entry[1] is not None, query_dict.items())
+        )
+
+        query_str = parse.urlencode(filtered_query, doseq=False)
+
+        path = f"data_object_instances/query?{query_str}"
+
+        response_list_of_dict = self.do_get(path, options)
+
+        if response_list_of_dict.get("totalCount", 0) > 0:
+            json_data = response_list_of_dict["dataObjectInstances"]
+            response = DataObjectInstanceResponse.schema().load(json_data, many=True)
+        else:
+            response = []
+
+        return response

processcube_etw_library/processcube_client/core/api/helpers/empty_tasks.py

@@ -0,0 +1,86 @@
+from dataclasses import dataclass, field
+from dataclasses_json import dataclass_json, LetterCase, Undefined, config
+from dataclasses_json import CatchAll
+from typing import Callable, List
+from urllib import parse
+
+from ..base_client import BaseClient
+
+
+@dataclass_json(letter_case=LetterCase.CAMEL)
+@dataclass
+class EmptyTaskQuery:
+    limit: int = None
+    offset: int = None
+    empty_task_instance_id: str = field(
+        metadata=config(field_name="flowNodeInstanceId"), default=None
+    )
+    flow_node_id: str = None
+    flow_node_name: str = None
+    flow_node_lane: str = None
+    correlation_id: str = None
+    process_definition_id: str = None
+    process_model_id: str = None
+    process_instance_id: str = None
+    state: str = None
+
+
+@dataclass_json(letter_case=LetterCase.CAMEL, undefined=Undefined.EXCLUDE)
+# @dataclass_json(letter_case=LetterCase.CAMEL, undefined=Undefined.INCLUDE)
+@dataclass
+class EmptyTaskResponse:
+    empty_task_instance_id: str = field(
+        metadata=config(field_name="flowNodeInstanceId")
+    )
+    correlation_id: str
+    process_instance_id: str
+    process_model_id: str
+    # place_holder: CatchAll
+    flow_node_name: str = None
+    flow_node_id: str = None
+    owner_id: str = None
+    flow_node_lane: str = None
+    process_definition_id: str = None
+
+
+class EmptyTaskHandler(BaseClient):
+    BPMN_TYPE = "bpmn:Task"
+
+    def __init__(self, url: str, identity: Callable = None, api_version: str = "v1"):
+        super(EmptyTaskHandler, self).__init__(url, identity, api_version)
+
+    def query(
+        self, request: EmptyTaskQuery = EmptyTaskQuery(), options: dict = {}
+    ) -> List[EmptyTaskResponse]:
+        query_dict = request.to_dict()
+        query_dict.update(
+            {
+                "state": "suspended",
+                "flowNodeType": EmptyTaskHandler.BPMN_TYPE,
+            }
+        )
+
+        filtered_query = list(
+            filter(lambda dict_entry: dict_entry[1] is not None, query_dict.items())
+        )
+
+        query_str = parse.urlencode(filtered_query, doseq=False)
+
+        path = f"flow_node_instances?{query_str}"
+
+        response_list_of_dict = self.do_get(path, options)
+
+        if response_list_of_dict.get("totalCount", 0) > 0:
+            json_data = response_list_of_dict.get("flowNodeInstances", {})
+            response = EmptyTaskResponse.schema().load(json_data, many=True)
+        else:
+            response = []
+
+        return response
+
+    def finish(self, empty_task_instance_id: str, options: dict = {}) -> bool:
+        path = f"empty_activities/{empty_task_instance_id}/finish"
+
+        _ = self.do_put(path, {}, options)
+
+        return True

processcube_etw_library/processcube_client/core/api/helpers/events.py

@@ -0,0 +1,39 @@
+from dataclasses import dataclass
+from dataclasses_json import dataclass_json, LetterCase
+from typing import Callable
+
+from ..base_client import BaseClient
+
+
+@dataclass_json(letter_case=LetterCase.CAMEL)
+@dataclass
+class MessageTriggerRequest:
+    payload: dict
+
+
+class EventsHandler(BaseClient):
+    def __init__(self, url: str, identity: Callable = None, api_version: str = "v1"):
+        super(EventsHandler, self).__init__(url, identity, api_version)
+
+    def trigger_message(
+        self, event_name: str, request: MessageTriggerRequest, options: dict = {}
+    ) -> bool:
+        url = f"messages/{event_name}/trigger"
+
+        process_instance_id = options.get("process_instance_id", None)
+
+        if process_instance_id is not None:
+            url = f"{url}?process_instance_id={process_instance_id}"
+
+        payload = request.to_dict()
+
+        _ = self.do_post(url, payload, options)
+
+        return True
+
+    def trigger_signal(self, signal_name: str, options: dict = {}) -> bool:
+        url = f"signals/{signal_name}/trigger"
+
+        _ = self.do_post(url, {}, options)
+
+        return True

processcube_etw_library/processcube_client/core/api/helpers/external_tasks.py

@@ -0,0 +1,142 @@
+from dataclasses import dataclass, field
+from dataclasses_json import dataclass_json, LetterCase
+from typing import Callable, List, Optional
+
+from dataclasses_json.undefined import Undefined
+
+from ..base_client import BaseClient
+
+
+@dataclass_json(letter_case=LetterCase.CAMEL)
+@dataclass
+class FetchAndLockRequestPayload:
+    worker_id: str
+    topic_name: str
+    max_tasks: int = 10
+    long_polling_timeout: int = 10 * 1000
+    lock_duration: int = 100 * 1000
+    payload_filter: str = None
+
+
+@dataclass_json(letter_case=LetterCase.CAMEL, undefined=Undefined.EXCLUDE)
+@dataclass
+class ExternalTask:
+    id: str
+    worker_id: str
+    topic: str
+    flow_node_instance_id: str
+    correlation_id: str
+    process_definition_id: str
+    process_instance_id: str
+    owner_id: str = None
+    payload: dict = None
+    lock_expiration_time: str = None
+    state: str = None  # ExternalTaskStatestring(pending = pending, finished = finished)
+    created_at: str = None
+
+
+@dataclass_json(letter_case=LetterCase.CAMEL)
+@dataclass
+class ExtendLockRequest:
+    worker_id: str
+    additional_duration: int
+
+
+@dataclass_json(letter_case=LetterCase.CAMEL)
+@dataclass
+class FinishExternalTaskRequestPayload:
+    worker_id: str
+    result: dict
+
+
+@dataclass_json(letter_case=LetterCase.CAMEL)
+@dataclass
+class BpmnError:
+    error_code: str
+    error_message: str
+
+
+@dataclass_json(letter_case=LetterCase.CAMEL)
+@dataclass
+class BpmnErrorRequest:
+    worker_id: str
+    bpmn_error: BpmnError
+
+
+@dataclass_json(letter_case=LetterCase)
+@dataclass
+class ServiceError:
+    error_code: str
+    error_message: str
+    error_details: dict = None
+
+
+@dataclass_json(letter_case=LetterCase.CAMEL)
+@dataclass
+class ServiceErrorRequest:
+    worker_id: str
+    error: ServiceError
+
+
+class ExternalTaskHandler(BaseClient):
+    def __init__(self, url: str, identity: Callable = None, api_version: str = "v1"):
+        super(ExternalTaskHandler, self).__init__(url, identity, api_version)
+
+    def fetch_and_lock(
+        self, request: FetchAndLockRequestPayload, options: dict = {}
+    ) -> List[ExternalTask]:
+        path = "external_tasks/fetch_and_lock"
+
+        payload = request.to_dict()
+
+        response_list_of_dict = self.do_post(path, payload, options)
+
+        response = ExternalTask.schema().load(response_list_of_dict, many=True)
+
+        return response
+
+    def extend_lock(
+        self, external_task_id: str, request: ExtendLockRequest, options: dict = {}
+    ) -> bool:
+        path = f"external_tasks/{external_task_id}/extend_lock"
+
+        payload = request.to_dict()
+
+        _ = self.do_put(path, payload, options)
+
+        return True
+
+    def finish(
+        self,
+        external_task_id: str,
+        request: FinishExternalTaskRequestPayload,
+        options: dict = {},
+    ) -> bool:
+        path = f"external_tasks/{external_task_id}/finish"
+
+        payload = request.to_dict()
+
+        _ = self.do_put(path, payload, options)
+
+        return True
+
+    def handle_error(
+        self, external_task_id: str, request: ServiceErrorRequest, options: dict = {}
+    ) -> bool:
+        path = f"external_tasks/{external_task_id}/error"
+
+        payload = request.to_dict()
+
+        _ = self.do_put(path, payload, options)
+
+        return True
+
+    def handle_bpmn_error(
+        self, external_task_id: str, request: BpmnErrorRequest, options: dict = {}
+    ) -> bool:
+        return self.handle_error(external_task_id, request, options)
+
+    def handle_service_error(
+        self, external_task_id: str, request: ServiceErrorRequest, options: dict = {}
+    ) -> bool:
+        return self.handle_error(external_task_id, request, options)

processcube_etw_library/processcube_client/core/api/helpers/flow_node_instances.py

@@ -0,0 +1,80 @@
+from dataclasses import dataclass, field
+from dataclasses_json import dataclass_json, LetterCase, Undefined
+from dataclasses_json import CatchAll
+from typing import Any, Callable, List, Dict, Optional
+from urllib import parse
+
+from ..base_client import BaseClient
+
+
+@dataclass_json(letter_case=LetterCase.CAMEL)
+@dataclass
+class FlowNodeInstancesQuery:
+    limit: int = None
+    offset: int = None
+    flow_node_instance_id: Optional[str] = None
+    flow_node_id: Optional[str] = None
+    flow_node_name: Optional[str] = None
+    flow_node_lane: Optional[str] = None
+    flow_node_type: Optional[str] = None
+    event_type: Optional[str] = None
+    correlation_id: Optional[str] = None
+    process_definition_id: Optional[str] = None
+    process_model_id: Optional[str] = None
+    process_instance_id: Optional[str] = None
+    owner_id: Optional[str] = None
+    state: Optional[str] = None
+    previous_flow_node_instance_id: Optional[str] = None
+    parent_process_instance_id: Optional[str] = None
+
+
+@dataclass_json(letter_case=LetterCase.CAMEL, undefined=Undefined.INCLUDE)
+@dataclass
+class FlowNodeInstanceResponse:
+    flow_node_instance_id: Optional[str] = None
+    flow_node_id: Optional[str] = None
+    flow_node_name: Optional[str] = None
+    flow_node_lane: Optional[str] = None
+    flow_node_type: Optional[str] = None
+    event_type: Optional[str] = None
+    previous_flow_node_instance_id: Optional[str] = None
+    parent_process_instance_id: Optional[str] = None
+    state: Optional[str] = None
+    process_definition_id: Optional[str] = None
+    process_model_id: Optional[str] = None
+    process_instance_id: Optional[str] = None
+    correlation_id: Optional[str] = None
+    tokens: List[Dict[str, Any]] = field(default_factory=list)
+    end_token: Dict[str, Any] = field(default_factory=dict)
+    owner_id: str = None
+    error: Dict[str, Any] = field(default_factory=dict)
+    meta_info: List[Dict[str, Any]] = field(default_factory=list)
+    place_holder: CatchAll = None
+
+
+class FlowNodeInstanceHandler(BaseClient):
+    def __init__(self, url: str, identity: Callable = None, api_version: str = "v1"):
+        super(FlowNodeInstanceHandler, self).__init__(url, identity, api_version)
+
+    def query(
+        self, request: FlowNodeInstancesQuery, options: dict = {}
+    ) -> List[FlowNodeInstanceResponse]:
+        query_dict = request.to_dict()
+
+        filtered_query = list(
+            filter(lambda dict_entry: dict_entry[1] is not None, query_dict.items())
+        )
+
+        query_str = parse.urlencode(filtered_query, doseq=False)
+
+        path = f"flow_node_instances?{query_str}"
+
+        response_list_of_dict = self.do_get(path, options)
+
+        if response_list_of_dict.get("totalCount", 0) > 0:
+            json_data = response_list_of_dict.get("flowNodeInstances", {})
+            response = FlowNodeInstanceResponse.schema().load(json_data, many=True)
+        else:
+            response = []
+
+        return response

processcube_etw_library/processcube_client/core/api/helpers/manual_tasks.py

@@ -0,0 +1,87 @@
+from dataclasses import dataclass, field
+from dataclasses_json import dataclass_json, LetterCase, Undefined, config
+
+# from dataclasses_json import CatchAll
+from typing import Callable, List
+from urllib import parse
+
+from ..base_client import BaseClient
+
+
+@dataclass_json(letter_case=LetterCase.CAMEL)
+@dataclass
+class ManualTaskQuery:
+    limit: int = None
+    offset: int = None
+    manual_task_instance_id: str = field(
+        metadata=config(field_name="flowNodeInstanceId"), default=None
+    )
+    flow_node_id: str = None
+    flow_node_name: str = None
+    flow_node_lane: str = None
+    correlation_id: str = None
+    process_definition_id: str = None
+    process_model_id: str = None
+    process_instance_id: str = None
+    state: str = None
+
+
+@dataclass_json(letter_case=LetterCase.CAMEL, undefined=Undefined.EXCLUDE)
+# @dataclass_json(letter_case=LetterCase.CAMEL, undefined=Undefined.INCLUDE)
+@dataclass
+class ManualTaskResponse:
+    manual_task_instance_id: str = field(
+        metadata=config(field_name="flowNodeInstanceId")
+    )
+    correlation_id: str
+    process_instance_id: str
+    process_model_id: str
+    # place_holder: CatchAll
+    flow_node_name: str = None
+    flow_node_id: str = None
+    owner_id: str = None
+    flow_node_lane: str = None
+    process_definition_id: str = None
+
+
+class ManualTaskHandler(BaseClient):
+    BPMN_TYPE = "bpmn:ManualTask"
+
+    def __init__(self, url: str, identity: Callable = None, api_version: str = "v1"):
+        super(ManualTaskHandler, self).__init__(url, identity, api_version)
+
+    def query(
+        self, request: ManualTaskQuery = ManualTaskQuery(), options: dict = {}
+    ) -> List[ManualTaskResponse]:
+        query_dict = request.to_dict()
+        query_dict.update(
+            {
+                "state": "suspended",
+                "flowNodeType": ManualTaskHandler.BPMN_TYPE,
+            }
+        )
+
+        filtered_query = list(
+            filter(lambda dict_entry: dict_entry[1] is not None, query_dict.items())
+        )
+
+        query_str = parse.urlencode(filtered_query, doseq=False)
+
+        path = f"flow_node_instances?{query_str}"
+
+        response_list_of_dict = self.do_get(path, options)
+
+        if response_list_of_dict.get("totalCount", 0) > 0:
+            json_data = response_list_of_dict.get("flowNodeInstances", {})
+            response = ManualTaskResponse.schema().load(json_data, many=True)
+        else:
+            response = []
+
+        return response
+
+    def finish(self, manual_task_instance_id: str, options: dict = {}) -> bool:
+        path = f"manual_tasks/{manual_task_instance_id}/finish"
+
+        _ = self.do_put(path, {}, options)
+
+        return True

processcube_etw_library/processcube_client/core/api/helpers/process_definitions.py

@@ -0,0 +1,46 @@
+from dataclasses import dataclass
+from dataclasses_json import dataclass_json, LetterCase
+from enum import IntFlag
+from typing import Callable
+
+from ..base_client import BaseClient
+
+
+class StartCallbackType(IntFlag):
+    CallbackOnProcessInstanceCreated = 1
+    CallbackOnProcessInstanceFinished = 2
+    CallbackOnEndEventReached = 3
+
+
+@dataclass_json(letter_case=LetterCase.CAMEL)
+@dataclass
+class ProcessDefinitionUploadPayload:
+    xml: str
+    overwrite_existing: bool = False
+
+
+class ProcessDefinitionHandler(BaseClient):
+    def __init__(self, url: str, identity: Callable = None, api_version: str = "v1"):
+        super(ProcessDefinitionHandler, self).__init__(url, identity, api_version)
+
+    def upload(
+        self, request: ProcessDefinitionUploadPayload, options: dict = {}
+    ) -> None:
+        path = "process_definitions"
+
+        payload = request.to_dict()
+
+        self.do_post(path, payload, options)
+
+    def delete(
+        self,
+        process_definition_id: str,
+        delete_all_related_data: bool = False,
+        options: dict = {},
+    ) -> None:
+        path = f"process_definitions/{process_definition_id}"
+
+        if delete_all_related_data:
+            path = f"{path}?delete_all_related_data=true"
+
+        self.do_delete(path, options)

processcube_etw_library/processcube_client/core/api/helpers/process_instances.py

@@ -0,0 +1,96 @@
+from datetime import date
+from dataclasses import dataclass, field
+from dataclasses_json import dataclass_json, LetterCase, Undefined
+from typing import Callable, List, Optional
+from urllib.parse import urlencode
+
+from ..base_client import BaseClient
+
+
+@dataclass_json(letter_case=LetterCase.CAMEL)
+@dataclass
+class ProcessInstanceQueryRequest:
+    offset: int = 0
+    limit: int = -1
+    correlation_id: str = None
+    process_instance_id: str = None
+    process_definition_id: str = None
+    process_model_id: str = None
+    process_model_name: str = None
+    process_model_hash: str = None
+    owner_id: str = None
+    state: str = None
+    parent_process_instance_id: str = None
+    terminated_by_user_id: str = None
+    created_before: date = None
+    created_at: date = None
+    created_after: date = None
+    updated_before: date = None
+    updated_at: date = None
+    updated_after: date = None
+    finished_before: date = None
+    finished_at: date = None
+    finished_after: date = None
+    start_token: dict = None
+    end_token: dict = None
+
+
+@dataclass_json(letter_case=LetterCase.CAMEL, undefined=Undefined.EXCLUDE)
+@dataclass
+class ProcessInstanceQueryResponse:
+    correlation_id: Optional[str] = None
+    process_instance_id: Optional[str] = None
+    process_definition_id: Optional[str] = None
+    process_model_id: Optional[str] = None
+    process_model_name: Optional[str] = None
+    parent_process_instance_id: Optional[str] = None
+    hash: Optional[str] = None
+    xml: Optional[str] = None
+    state: Optional[str] = None
+    error: dict = field(default_factory=dict)
+    owner_id: Optional[str] = None
+    created_at: Optional[str] = None
+    finished_at: Optional[str] = None
+    terminated_by_user_id: Optional[str] = None
+    start_token: Optional[dict] = None
+    end_token: Optional[dict] = None
+    metadata: dict = field(default_factory=dict)
+    # correlation: Any = None
+
+
+class ProcessInstanceHandler(BaseClient):
+    def __init__(self, url: str, identity: Callable = None, api_version: str = "v1"):
+        super(ProcessInstanceHandler, self).__init__(url, identity, api_version)
+
+    def query(
+        self, request: ProcessInstanceQueryRequest, options: dict = {}
+    ) -> List[ProcessInstanceQueryResponse]:
+        path = "process_instances/query"
+
+        all_fields = request.to_dict()
+
+        query_fields = [
+            (key, value) for key, value in all_fields.items() if value is not None
+        ]
+
+        query = urlencode(query_fields)
+
+        if len(query) > 0:
+            path = f"{path}?{query}"
+
+        response_list_of_dict = self.do_get(path, options)
+
+        if response_list_of_dict.get("totalCount", 0) > 0:
+            json_data = response_list_of_dict["processInstances"]
+            response = ProcessInstanceQueryResponse.schema().load(json_data, many=True)
+        else:
+            response = []
+
+        return response
+
+    def terminate(self, process_instance_id: str, options: dict = {}) -> bool:
+        path = f"process_instances/{process_instance_id}/terminate"
+
+        _ = self.do_put(path, {}, options)
+
+        return True