zsynctech-studio-sdk 0.1.0__py3-none-any.whl

zsynctech_studio_sdk/__init__.py

@@ -0,0 +1,21 @@
+from zsynctech_studio_sdk.client import set_credentials
+from zsynctech_studio_sdk.models.config import Config
+from zsynctech_studio_sdk.start import StartService
+from zsynctech_studio_sdk.execution import Execution
+from zsynctech_studio_sdk.task import Task
+from zsynctech_studio_sdk.step import Step
+import tomllib
+
+with open("pyproject.toml", "rb") as f:
+    config = tomllib.load(f)
+
+__version__ = config.get("project").get("version")
+
+__all__ = [
+    "set_credentials",
+    "StartService",
+    "Execution",
+    "Task",
+    "Step",
+    "Config"
+]

zsynctech_studio_sdk/client.py

@@ -0,0 +1,39 @@
+import httpx
+
+_client = None
+_secret_key = None
+_instance_id = None
+_server = None
+
+
+def set_credentials(secret_key: str, instance_id: str, server: str):
+    global _client, _secret_key, _server, _instance_id
+    _secret_key = secret_key
+    _instance_id = instance_id
+    _server = str(server).rstrip("/")
+    _client = httpx.Client(
+        base_url=f"{_server}/automation-gateway/",
+        headers={
+            "Authorization": f"Bearer {_secret_key}::{_instance_id}"
+        }
+    )
+
+
+def request(method: str, endpoint: str, **kwargs) -> httpx.Response:
+    if _client is None:
+        raise RuntimeError("Credentials not set. Call set_credentials() first.")
+    response = _client.request(method, endpoint, **kwargs)
+    response.raise_for_status()
+    return response
+
+def get(endpoint: str, params: dict = None) -> httpx.Response:
+    return request("GET", endpoint, params=params)
+
+def post(endpoint: str, json: dict = None) -> httpx.Response:
+    return request("POST", endpoint, json=json)
+
+def put(endpoint: str, json: dict = None) -> httpx.Response:
+    return request("PUT", endpoint, json=json)
+
+def delete(endpoint: str) -> httpx.Response:
+    return request("DELETE", endpoint)

zsynctech_studio_sdk/enums/__init__.py

@@ -0,0 +1,10 @@
+from .execution import ExecutionStatus
+from .task import TaskStatus
+from .step import StepStatus
+
+
+__all__ = [
+    "ExecutionStatus",
+    "TaskStatus",
+    "StepStatus",
+]

zsynctech_studio_sdk/enums/execution.py

@@ -0,0 +1,11 @@
+from enum import StrEnum
+
+
+class ExecutionStatus(StrEnum):
+    WAITING = 'WAITING'
+    RUNNING = 'RUNNING'
+    FINISHED = 'FINISHED'
+    ERROR = 'ERROR'
+    SCHEDULED = 'SCHEDULED'
+    INTERRUPTED = 'INTERRUPTED'
+    OUT_OF_OPERATING_HOURS = 'OUT_OF_OPERATING_HOURS'

zsynctech_studio_sdk/enums/step.py

@@ -0,0 +1,8 @@
+from enum import StrEnum
+
+
+class StepStatus(StrEnum):
+    UNPROCESSED = 'UNPROCESSED'
+    RUNNING = 'RUNNING'
+    SUCCESS = 'SUCCESS'
+    FAIL = 'FAIL'

zsynctech_studio_sdk/enums/task.py

@@ -0,0 +1,9 @@
+from enum import StrEnum
+
+
+class TaskStatus(StrEnum):
+    UNPROCESSED = 'UNPROCESSED'
+    VALIDATION_ERROR = 'VALIDATION_ERROR'
+    SUCCESS = 'SUCCESS'
+    FAIL = 'FAIL'
+    RUNNING = 'RUNNING'

zsynctech_studio_sdk/execution.py

@@ -0,0 +1,156 @@
+from zsynctech_studio_sdk.models import ExecutionModel
+from zsynctech_studio_sdk.enums import ExecutionStatus
+from zsynctech_studio_sdk.utils import get_utc_now
+from zsynctech_studio_sdk import client
+from typing import Optional, Any
+
+EXECUTION_STATUS_COMPLETED = [
+    ExecutionStatus.ERROR,
+    ExecutionStatus.FINISHED,
+    ExecutionStatus.OUT_OF_OPERATING_HOURS,
+    ExecutionStatus.INTERRUPTED,
+]
+
+
+class Execution:
+    def __init__(self, execution_id: str):
+        self._current_execution = ExecutionModel(
+            id=execution_id
+        )
+        self._resource_path = "executions"
+
+    @property
+    def execution_id(self):
+        return self._current_execution.id
+    
+    def _update(
+            self,
+            status: Optional[ExecutionStatus] = None,
+            observation: Optional[str] = None,
+            total_task_count: Optional[int] = None,
+            current_task_count: Optional[int] = None,
+        ) -> dict:
+
+        if self._current_execution.status in EXECUTION_STATUS_COMPLETED:
+            return self._current_execution.model_dump()
+
+        if status in EXECUTION_STATUS_COMPLETED:
+            self._current_execution.endDate = get_utc_now()
+
+        if status is not None:
+            self._current_execution.status = status
+        
+        if observation is not None:
+            self._current_execution.observation = observation
+        
+        if total_task_count is not None:
+            self._current_execution.totalTaskCount = total_task_count
+    
+        if current_task_count is not None:
+            self._current_execution.currentTaskCount = current_task_count
+
+        client.post(
+            endpoint=self._resource_path,
+            json=self._current_execution.model_dump()
+        )
+
+        return self._current_execution.model_dump()
+
+    def set_total_task_count(self, total_task_count: int) -> dict[str, Any]:
+        """Update the total number of tasks to be processed 
+
+        Args:
+            total_task_count (int): total number of tasks to be processed.
+
+        Returns:
+            dict: Dictionary containing the information of the current execution
+        """
+        return self._update(total_task_count=total_task_count)
+
+    def update_current_task_count(self, current_task_count: int) -> dict[str, Any]:
+        """Update the number of tasks currently processed
+
+        Args:
+            current_task_count (int): Number of tasks processed.
+
+        Returns:
+            dict: Dictionary containing the information of the current execution
+        """
+        return self._update(current_task_count=current_task_count)
+
+    def update_observation(self, observation: str) -> dict[str, Any]:
+        """Updates the execution observation text
+
+        Args:
+            observation (str): Execution observation text.
+
+        Returns:
+            dict: Dictionary containing the information of the current execution
+        """
+        return self._update(observation=observation)
+
+    def start(self, observation: Optional[str] = None) -> dict:
+        """Updates the execution status to running
+
+        Args:
+            observation (Optional[str], optional): Execution observation text. Defaults to None.
+
+        Returns:
+            dict: Dictionary containing the information of the current execution
+        """
+        return self._update(ExecutionStatus.RUNNING, observation)
+
+    def error(self, observation: Optional[str] = None) -> dict:
+        """Updates the execution status to error
+
+        Args:
+            observation (Optional[str], optional): Execution observation text. Defaults to None.
+
+        Returns:
+            dict: Dictionary containing the information of the current execution
+        """
+        return self._update(ExecutionStatus.ERROR, observation=observation)
+
+    def waiting(self, observation: Optional[str] = None) -> dict:
+        """Updates the execution status to waiting
+
+        Args:
+            observation (Optional[str], optional): Execution observation text. Defaults to None.
+
+        Returns:
+            dict: Dictionary containing the information of the current execution
+        """
+        return self._update(ExecutionStatus.WAITING, observation=observation)
+
+    def out_of_operating_hours(self, observation: Optional[str] = None) -> dict:
+        """Updates the execution status to out_of_operating_hours
+
+        Args:
+            observation (Optional[str], optional): Execution observation text. Defaults to None.
+
+        Returns:
+            dict: Dictionary containing the information of the current execution
+        """
+        return self._update(ExecutionStatus.OUT_OF_OPERATING_HOURS, observation=observation)
+
+    def finished(self, observation: Optional[str] = None) -> dict:
+        """Updates the execution status to finished
+
+        Args:
+            observation (Optional[str], optional): Execution observation text. Defaults to None.
+
+        Returns:
+            dict: Dictionary containing the information of the current execution
+        """
+        return self._update(ExecutionStatus.FINISHED, observation=observation)
+
+    def interrupted(self, observation: Optional[str] = None) -> dict:
+        """Updates the execution status to finished
+
+        Args:
+            observation (Optional[str], optional): Execution observation text. Defaults to None.
+
+        Returns:
+            dict: Dictionary containing the information of the current execution
+        """
+        return self._update(ExecutionStatus.INTERRUPTED, observation=observation)

zsynctech_studio_sdk/models/__init__.py

@@ -0,0 +1,12 @@
+from .execution import ExecutionModel
+from .step import StepModel
+from .task import TaskModel
+from .config import Config
+
+
+__all__ = [
+    "ExecutionModel",
+    "StepModel",
+    "TaskModel",
+    "Config",
+]

zsynctech_studio_sdk/models/base.py

@@ -0,0 +1,47 @@
+from zsynctech_studio_sdk.enums.execution import ExecutionStatus
+from pydantic import BaseModel, Field, field_validator
+from zsynctech_studio_sdk.enums.step import StepStatus
+from zsynctech_studio_sdk.enums.task import TaskStatus
+from uuid_extensions.uuid7 import uuid7
+from typing import Optional, Union
+from datetime import datetime
+import re
+
+
+class BaseEntity(BaseModel):
+    id: str = Field(
+        default_factory=lambda: str(uuid7()),
+        min_length=1,
+        description="ID único da execução"
+    )
+    observation: Optional[str] = None
+    status: Optional[Union[ExecutionStatus, StepStatus, TaskStatus]] = None
+    endDate: Optional[str] = None
+
+    @field_validator('id')
+    @classmethod
+    def validate_id_format(cls, v):
+        if not re.match(r'^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$', v):
+            raise ValueError('ID deve ser um UUID válido')
+        version = int(v[14], 16)
+        if version != 7:
+            raise ValueError('ID deve ser um UUID7 válido')
+        return v
+
+    @field_validator('endDate')
+    @classmethod
+    def validate_end_date_format(cls, v):
+        if v is None:
+            return v
+        pattern = r'^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$'
+        if not re.match(pattern, v):
+            raise ValueError('endDate deve estar no formato ISO 8601 com Z')
+        try:
+            datetime.fromisoformat(v.replace('Z', '+00:00'))
+        except ValueError:
+            raise ValueError('endDate deve ser uma data válida')
+        return v
+
+    class Config:
+        extra = "forbid"
+        validate_assignment = True

zsynctech_studio_sdk/models/config.py

@@ -0,0 +1,32 @@
+from typing import Optional, List
+from pydantic import BaseModel
+from enum import StrEnum
+
+
+class InputOutputTypes(StrEnum):
+    FTP = 'FTP'
+    API = 'API'
+    FILA = 'FILA'
+
+
+class Credential(BaseModel):
+    key: str
+    value: str
+    encrypted: bool
+
+
+class Config(BaseModel):
+    instanceId: str
+    executionId: str
+    automationName: Optional[str] = "System"
+    clientId: Optional[str] = None
+    userId: Optional[str] = "System"
+    outputPath: Optional[str] = None
+    inputPath: Optional[str] = None
+    inputMetaData: Optional[dict] = None
+    inputType: Optional[InputOutputTypes] = InputOutputTypes.FTP
+    outputType: Optional[InputOutputTypes] = InputOutputTypes.FTP
+    outputMetaData: Optional[dict] = None
+    keepAlive: Optional[bool] = False
+    keepAliveInterval: Optional[int] = 30
+    credentials: Optional[List[Credential]] = None

zsynctech_studio_sdk/models/execution.py

@@ -0,0 +1,18 @@
+from zsynctech_studio_sdk.enums.execution import ExecutionStatus
+from zsynctech_studio_sdk.models.base import BaseEntity
+from pydantic import model_validator
+
+
+class ExecutionModel(BaseEntity):
+    totalTaskCount: int = 0
+    currentTaskCount: int = 0
+    status: ExecutionStatus = ExecutionStatus.WAITING
+
+    @model_validator(mode='after')
+    def validate_business_rules(self):
+        current = self.currentTaskCount or 0
+        total = self.totalTaskCount or 0
+        if current > total:
+            raise ValueError('currentTaskCount não pode ser maior que totalTaskCount')
+
+        return self

zsynctech_studio_sdk/models/step.py

@@ -0,0 +1,28 @@
+from zsynctech_studio_sdk.models.base import BaseEntity
+from zsynctech_studio_sdk.enums.step import StepStatus
+from pydantic import field_validator
+from datetime import datetime
+from typing import Optional
+import re
+
+
+class StepModel(BaseEntity):
+    status: StepStatus = StepStatus.UNPROCESSED
+    taskId: Optional[str] = None
+    stepCode: Optional[str] = None
+    startDate: Optional[str] = None
+    automationOnClientId: str
+
+    @field_validator('startDate')
+    @classmethod
+    def validate_end_date_format(cls, v):
+        if v is None:
+            return v
+        pattern = r'^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$'
+        if not re.match(pattern, v):
+            raise ValueError('endDate deve estar no formato ISO 8601 com Z')
+        try:
+            datetime.fromisoformat(v.replace('Z', '+00:00'))
+        except ValueError:
+            raise ValueError('endDate deve ser uma data válida')
+        return v

zsynctech_studio_sdk/models/task.py

@@ -0,0 +1,29 @@
+from zsynctech_studio_sdk.models.base import BaseEntity
+from zsynctech_studio_sdk.enums.task import TaskStatus
+from pydantic import field_validator
+from datetime import datetime
+from typing import Optional
+import re
+
+
+class TaskModel(BaseEntity):
+    status: TaskStatus = TaskStatus.UNPROCESSED
+    description: Optional[str] = None
+    jsonData: Optional[dict] = {}
+    code: Optional[str] = None
+    executionId: Optional[str] = None
+    startDate: Optional[str] = None
+
+    @field_validator('startDate')
+    @classmethod
+    def validate_end_date_format(cls, v):
+        if v is None:
+            return v
+        pattern = r'^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$'
+        if not re.match(pattern, v):
+            raise ValueError('endDate deve estar no formato ISO 8601 com Z')
+        try:
+            datetime.fromisoformat(v.replace('Z', '+00:00'))
+        except ValueError:
+            raise ValueError('endDate deve ser uma data válida')
+        return v

zsynctech_studio_sdk/start.py

@@ -0,0 +1,88 @@
+from zsynctech_studio_sdk.utils import validate_id_format
+from zsynctech_studio_sdk.models import Config
+from zsynctech_studio_sdk import client
+from typing import Callable, Optional
+import pika
+import json
+
+EXCHANGE_NAME = "start"
+
+
+class StartService:
+    def __init__(self, rabbitmq_url: str, heartbeat: int = 5400):
+        if client._instance_id is None:
+            raise RuntimeError("Credentials not set. Call set_credentials() first.")
+        self._instance_id = validate_id_format(client._instance_id)
+        self._queue_name = f"robot_{self._instance_id}"
+        self._connection = pika.BlockingConnection(
+            parameters=pika.URLParameters(
+                f"{rabbitmq_url}?heartbeat={heartbeat}"
+            )
+        )
+        self._channel = self._connection.channel()
+
+        self._channel.exchange_declare(
+            exchange=EXCHANGE_NAME,
+            exchange_type='direct',
+            durable=True
+        )
+        self._channel.queue_declare(
+            queue=self._queue_name,
+            durable=True
+        )
+        self._channel.queue_bind(
+            exchange=EXCHANGE_NAME,
+            queue=self._queue_name,
+            routing_key=f"instance.{self._instance_id}"
+        )
+
+    def get_start_config(self) -> Optional[Config]:
+        """Checks if there are start events in the queue
+
+        Returns:
+            Optional[Config]: Returns the configuration json, 
+            if the queue is empty it returns None
+        """
+        method_frame, _, body = self._channel.basic_get(
+            queue=self._queue_name,
+            auto_ack=True
+        )
+        if method_frame:
+            try:
+                message = json.loads(body)
+            except json.JSONDecodeError:
+                message = body.decode()
+            return Config(**message)
+        return None
+
+    def start_listener(self, callback: Callable):
+        """Starts a consumer to check for start events
+
+        Args:
+            callback (Callable): Function that will be 
+            called when there is an event.
+        """
+        def _internal_callback(ch, method, properties, body):
+            try:
+                message = json.loads(body)
+            except json.JSONDecodeError:
+                message = body.decode()
+            callback(Config(**message))
+
+        self._channel.basic_consume(
+            queue=self._queue_name,
+            on_message_callback=_internal_callback,
+            auto_ack=True
+        )
+
+        print(f"[StartService] Waiting for events in queue: {self._queue_name}...")
+
+        try:
+            self._channel.start_consuming()
+        except KeyboardInterrupt:
+            self.close()
+
+    def close(self):
+        if self._connection and not self._connection.is_closed:
+            self._connection.close()
+            print("[StartService] Connection closed.")

zsynctech_studio_sdk/step.py

@@ -0,0 +1,90 @@
+from zsynctech_studio_sdk.utils import get_utc_now
+from zsynctech_studio_sdk.models import StepModel
+from zsynctech_studio_sdk.enums import StepStatus
+from zsynctech_studio_sdk import client
+from typing import Optional
+
+
+STEP_STATUS_COMPLETED = [
+    StepStatus.FAIL,
+    StepStatus.SUCCESS,
+]
+
+
+class Step(StepModel):
+    def __init__(self, task_id: str, code: str, observation: Optional[str] = None):
+        self._current_step = StepModel(
+            stepCode=code,
+            taskId=task_id,
+            startDate=get_utc_now(),
+            observation=observation,
+            automationOnClientId=client._instance_id
+        )
+        self._resource_path = "taskSteps"
+
+    def _update(
+            self,
+            status: Optional[StepStatus] = None,
+            observation: Optional[str] = None,
+        ) -> dict:
+        if status in STEP_STATUS_COMPLETED:
+            self._current_step.endDate = get_utc_now()
+
+        if observation is not None:
+            self._current_step.observation = observation
+        
+        if status is not None:
+            self._current_step.status = status
+
+        client.post(
+            endpoint=f"{self._resource_path}",
+            json=self._current_step.model_dump()
+        )
+
+        return self._current_step.model_dump()
+    
+    def _start(self, observation: Optional[str] = None) -> dict:
+        """Updates the step status to running
+
+        Args:
+            observation (Optional[str], optional): Step observation text. Defaults to None.
+
+        Returns:
+            dict: Dictionary containing the information of the current step
+        """
+        return self._update(status=StepStatus.RUNNING, observation=observation)
+
+    def fail(self, observation: Optional[str] = None) -> dict:
+        """Updates the step status to fail
+
+        Args:
+            observation (Optional[str], optional): Step observation text. Defaults to None.
+
+        Returns:
+            dict: Dictionary containing the information of the current step
+        """
+        return self._update(status=StepStatus.FAIL, observation=observation)
+
+    def success(self, observation: Optional[str] = None) -> dict:
+        """Updates the step status to success
+
+        Args:
+            observation (Optional[str], optional): Step observation text. Defaults to None.
+
+        Returns:
+            dict: Dictionary containing the information of the current step
+        """
+        return self._update(status=StepStatus.SUCCESS, observation=observation)
+
+    def __enter__(self):
+        self._start()
+        return self
+
+    def __exit__(self, exc_type, exc_value, traceback):
+        if self._current_step.status not in STEP_STATUS_COMPLETED:
+            if exc_type is not None:
+                self.fail(observation=str(exc_value))
+            else:
+                self.success()
+
+        return False

zsynctech_studio_sdk/task.py

@@ -0,0 +1,103 @@
+from zsynctech_studio_sdk.utils import get_utc_now
+from zsynctech_studio_sdk.models import TaskModel
+from zsynctech_studio_sdk.enums import TaskStatus
+from zsynctech_studio_sdk import client
+from uuid_extensions import uuid7
+from typing import Optional
+
+
+TASK_STATUS_COMPLETED = [
+    TaskStatus.FAIL,
+    TaskStatus.SUCCESS,
+    TaskStatus.VALIDATION_ERROR,
+]
+
+
+class Task:
+    def __init__(self, execution_id: str, code: Optional[str] = None, description: Optional[str] = None):
+        self._current_task = TaskModel(
+            executionId=execution_id,
+            startDate=get_utc_now()
+        )
+        self._resource_path = "tasks"
+
+        if code:
+            self._current_task.code = code
+        else:
+            self._current_task.code = str(uuid7())
+
+        if description:
+            self._current_task.description = description
+        else:
+            self._current_task.description = "Descrição não informada"
+        
+    @property
+    def task_id(self):
+        return self._current_task.id
+    
+    def _update(
+            self,
+            status: Optional[TaskStatus] = None,
+            observation: Optional[str] = None,
+        ) -> dict:
+        if status in TASK_STATUS_COMPLETED:
+            self._current_task.endDate = get_utc_now()
+
+        if status is not None:
+            self._current_task.status = status
+    
+        if observation is not None:
+            self._current_task.observation = observation
+
+        client.post(
+            endpoint=self._resource_path,
+            json=self._current_task.model_dump()
+        )
+
+        return self._current_task.model_dump()
+
+    def start(self, observation: Optional[str] = None) -> dict:
+        """Updates the task status to running
+
+        Args:
+            observation (Optional[str], optional): Task observation text. Defaults to None.
+
+        Returns:
+            dict: Dictionary containing the information of the current task
+        """
+        return self._update(TaskStatus.RUNNING, observation)
+
+    def fail(self, observation: Optional[str] = None) -> dict:
+        """Updates the task status to fail
+
+        Args:
+            observation (Optional[str], optional): Task observation text. Defaults to None.
+
+        Returns:
+            dict: Dictionary containing the information of the current task
+        """
+        return self._update(TaskStatus.FAIL, observation=observation)
+
+    def success(self, observation: Optional[str] = None) -> dict:
+        """Updates the task status to success
+
+        Args:
+            observation (Optional[str], optional): Task observation text. Defaults to None.
+
+        Returns:
+            dict: Dictionary containing the information of the current task
+        """
+        return self._update(TaskStatus.SUCCESS, observation=observation)
+
+    def __enter__(self):
+        self.start()
+        return self
+
+    def __exit__(self, exc_type, exc_value, traceback):
+        if self._current_task.status not in TASK_STATUS_COMPLETED:
+            if exc_type is not None:
+                self.fail(observation=str(exc_value))
+            else:
+                self.success()
+
+        return False

zsynctech_studio_sdk/utils.py

@@ -0,0 +1,21 @@
+from datetime import datetime, timezone
+import re
+
+
+def get_utc_now() -> str:
+    """
+    Get the current date and time in UTC format as an ISO string.
+
+    Returns:
+        str: Current UTC datetime in ISO format with 'Z' suffix (e.g., '2024-01-15T10:30:45.123Z')
+    """
+    return datetime.now(timezone.utc).isoformat(timespec='milliseconds').replace('+00:00', 'Z')
+
+
+def validate_id_format(v):
+    if not re.match(r'^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$', v):
+        raise ValueError('ID deve ser um UUID válido')
+    version = int(v[14], 16)
+    if version != 7:
+        raise ValueError('ID deve ser um UUID7 válido')
+    return v

zsynctech_studio_sdk-0.1.0.dist-info/METADATA

@@ -0,0 +1,289 @@
+Metadata-Version: 2.4
+Name: zsynctech-studio-sdk
+Version: 0.1.0
+Summary: Lib
+Author-email: ZSync Tech LTDA <contato@zsynctech.com>
+Requires-Python: >=3.13
+Requires-Dist: httpx>=0.28.1
+Requires-Dist: pika>=1.3.2
+Requires-Dist: pydantic>=2.11.7
+Requires-Dist: rich>=14.1.0
+Requires-Dist: uuid7>=0.1.0
+Description-Content-Type: text/markdown
+
+# ZSync Tech Studio SDK
+
+SDK oficial da ZSync Tech para integração com o ZSync Tech Studio, uma plataforma de automação de processos. Este SDK permite que você desenvolva robôs de automação que se integram perfeitamente com o ecossistema ZSync Tech.
+
+![PyPI](https://img.shields.io/badge/version-0.1.0-green)
+
+## 📋 Índice
+
+- [Instalação](#instalação)
+- [Configuração Inicial](#configuração-inicial)
+- [Conceitos Básicos](#conceitos-básicos)
+- [Guia de Uso](#guia-de-uso)
+  - [StartService - Recebendo Configurações](#startservice---recebendo-configurações)
+  - [Execution - Gerenciando Execuções](#execution---gerenciando-execuções)
+  - [Task - Gerenciando Tarefas](#task---gerenciando-tarefas)
+  - [Step - Gerenciando Passos](#step---gerenciando-passos)
+- [Exemplo Completo](#exemplo-completo)
+- [API Reference](#api-reference)
+- [Dependências](#dependências)
+- [Suporte](#suporte)
+
+## 🚀 Instalação via pip
+
+```bash
+pip install zsynctech-studio-sdk
+```
+
+## 🚀 Instalação via uv
+
+```bash
+uv add zsynctech-studio-sdk
+```
+
+## ⚙️ Configuração Inicial
+
+Antes de usar o SDK, você precisa configurar suas credenciais:
+
+```python
+from zsynctech_studio_sdk import set_credentials
+
+# Configure suas credenciais
+set_credentials(
+    secret_key="sua_secret_key",
+    instance_id="seu_instance_id", 
+    server="https://seu-servidor.com"
+)
+```
+
+## 🧠 Conceitos Básicos
+
+O ZSync Tech Studio SDK trabalha com uma hierarquia de conceitos:
+
+1. **Execution (Execução)**: Representa uma execução completa de um robô
+2. **Task (Tarefa)**: Uma tarefa específica dentro de uma execução
+3. **Step (Passo)**: Um passo individual dentro de uma tarefa
+
+Cada nível pode ter diferentes status e observações para rastreamento detalhado.
+
+## 📖 Guia de Uso
+
+### StartService - Recebendo Configurações
+
+O `StartService` permite que seu robô receba configurações via RabbitMQ:
+
+```python
+from zsynctech_studio_sdk import StartService
+
+# Configure o serviço
+start_service = StartService(
+    rabbitmq_url="amqp://usuario:senha@servidor:5672/",
+    heartbeat=5400
+)
+
+# Verificar se há configurações disponíveis
+config = start_service.get_start_config()
+if config:
+    print(f"Execução recebida: {config.executionId}")
+    # Processar a configuração...
+
+# Ou usar um listener contínuo
+def process_config(config):
+    print(f"Processando execução: {config.executionId}")
+    # Sua lógica aqui...
+
+start_service.start_listener(process_config)
+```
+
+### Execution - Gerenciando Execuções
+
+A classe `Execution` gerencia o ciclo de vida de uma execução:
+
+```python
+from zsynctech_studio_sdk import Execution, ExecutionStatus
+
+# Criar uma execução
+execution = Execution(config.executionId)
+
+# Iniciar a execução
+execution.start("Iniciando processamento...")
+
+# Atualizar progresso
+execution.set_total_task_count(100)
+execution.update_current_task_count(50)
+
+# Atualizar observação
+execution.update_observation("Processando dados...")
+
+# Finalizar com sucesso
+execution.finished("Processamento concluído com sucesso!")
+
+# Ou em caso de erro
+execution.error("Erro ao processar dados")
+```
+
+### Task - Gerenciando Tarefas
+
+A classe `Task` gerencia tarefas individuais:
+
+```python
+from zsynctech_studio_sdk import Task
+
+# Criar uma tarefa
+task = Task(
+    execution_id=execution.execution_id,
+    code="TASK_001",
+    description="Processar arquivo de dados"
+)
+
+# Usar como context manager (recomendado)
+with task:
+    # Sua lógica aqui
+    process_file()
+    # Status será automaticamente SUCCESS ou FAIL
+
+# Ou gerenciar manualmente
+task.start("Iniciando processamento do arquivo")
+try:
+    process_file()
+    task.success("Arquivo processado com sucesso")
+except Exception as e:
+    task.fail(f"Erro ao processar arquivo: {str(e)}")
+```
+
+### Step - Gerenciando Passos
+
+A classe `Step` gerencia passos individuais dentro de uma tarefa:
+
+```python
+from zsynctech_studio_sdk import Step
+
+# Criar um passo
+step = Step(
+    task_id=task.task_id,
+    code="STEP_001",
+    observation="Validando dados"
+)
+
+# Usar como context manager (recomendado)
+with step:
+    # Sua lógica aqui
+    validate_data()
+    # Status será automaticamente SUCCESS ou FAIL
+
+# Ou gerenciar manualmente
+step._start("Iniciando validação")
+try:
+    validate_data()
+    step.success("Dados validados com sucesso")
+except Exception as e:
+    step.fail(f"Erro na validação: {str(e)}")
+```
+
+## 💡 Exemplo Completo
+
+```python
+from zsynctech_studio_sdk import (
+    set_credentials, StartService, Execution, Task, Step
+)
+
+# 1. Configurar credenciais
+set_credentials(
+    secret_key="sua_secret_key",
+    instance_id="seu_instance_id",
+    server="https://seu-servidor.com"
+)
+
+# 2. Configurar StartService
+start_service = StartService("amqp://usuario:senha@servidor:5672/")
+
+def process_automation(config):
+    """Função principal de processamento"""
+    
+    # 3. Criar execução
+    execution = Execution(config.executionId)
+    execution.start("Iniciando automação")
+    
+    try:
+        # 4. Definir total de tarefas
+        execution.set_total_task_count(3)
+        
+        # 5. Processar cada tarefa
+        for i, data in enumerate(data_to_process):
+            with Task(execution.execution_id, f"TASK_{i:03d}", f"Processar {data}") as task:
+                
+                # 6. Processar passos da tarefa
+                with Step(task.task_id, "VALIDATE", "Validando arquivo") as step:
+                    validate_file(data)
+                
+                with Step(task.task_id, "PROCESS", "Processando dados") as step:
+                    process_file(data)
+                
+                with Step(task.task_id, "SAVE", "Salvando resultado") as step:
+                    save_result(data)
+                
+                # 7. Atualizar progresso
+                execution.update_current_task_count(i)
+        
+        # 8. Finalizar com sucesso
+        execution.finished("Automação concluída com sucesso!")
+        
+    except Exception as e:
+        execution.error(f"Erro na automação: {str(e)}")
+
+# 9. Iniciar listener
+start_service.start_listener(process_automation)
+```
+
+## 📚 API Reference
+
+### StartService
+
+- `__init__(rabbitmq_url: str, heartbeat: int = 5400)`: Inicializa o serviço
+- `get_start_config() -> Optional[Config]`: Obtém configuração disponível
+- `start_listener(callback: Callable)`: Inicia listener contínuo
+- `close()`: Fecha conexão
+
+### Execution
+
+- `start(observation: Optional[str] = None)`: Inicia execução
+- `finished(observation: Optional[str] = None)`: Finaliza com sucesso
+- `error(observation: Optional[str] = None)`: Marca como erro
+- `waiting(observation: Optional[str] = None)`: Marca como aguardando
+- `set_total_task_count(count: int)`: Define total de tarefas
+- `update_current_task_count(count: int)`: Atualiza progresso
+- `update_observation(observation: str)`: Atualiza observação
+
+### Task
+
+- `start(observation: Optional[str] = None)`: Inicia tarefa
+- `success(observation: Optional[str] = None)`: Marca como sucesso
+- `fail(observation: Optional[str] = None)`: Marca como falha
+- Suporte a context manager (`with`)
+
+### Step
+
+- `_start(observation: Optional[str] = None)`: Inicia passo
+- `success(observation: Optional[str] = None)`: Marca como sucesso
+- `fail(observation: Optional[str] = None)`: Marca como falha
+- Suporte a context manager (`with`)
+
+## 📦 Dependências
+
+- `httpx>=0.28.1` - Cliente HTTP
+- `pika>=1.3.2` - Cliente RabbitMQ
+- `pydantic>=2.11.7` - Validação de dados
+- `rich>=14.1.0` - Interface rica
+- `uuid7>=0.1.0` - Geração de UUIDs
+
+## 🆘 Suporte
+
+Para suporte técnico, entre em contato:
+
+- **Email**: contato@zsynctech.com
+- **Empresa**: ZSync Tech LTDA
+
+---

zsynctech_studio_sdk-0.1.0.dist-info/RECORD

@@ -0,0 +1,21 @@
+zsynctech_studio_sdk/__init__.py,sha256=ZAnvP6KLyduIxoA5aIPUcW2-WgAr7kq9V-Q5CFgTDuI,549
+zsynctech_studio_sdk/client.py,sha256=FN4XAyaCISyzHnSdU6Fu3eY1X8h_UXpUpcjdfU6KAug,1195
+zsynctech_studio_sdk/execution.py,sha256=-u-roSf8RHsS5EWPsAHTudH45qSeipi0aGO6BxmwVcg,5514
+zsynctech_studio_sdk/start.py,sha256=XiNxtf-7BKKJ87eASIErgJH6nL72flpMMQV52OcGths,2845
+zsynctech_studio_sdk/step.py,sha256=9jp_Byn-9hkkN67KqD7Cqvjd3Dqb_026FsHEtFihtoY,2849
+zsynctech_studio_sdk/task.py,sha256=7p6UVLCyniHsI_pAusnq1LW_j39MaWNAi75V1SXMv3s,3150
+zsynctech_studio_sdk/utils.py,sha256=uKgNffummtFJYnnozl9l4YRq9ViE9XkVFgU0KJLCdYc,664
+zsynctech_studio_sdk/enums/__init__.py,sha256=bM5eghvamVTAvFR2RSF8h-zQrKPbs1oTIklpcRuNPtw,171
+zsynctech_studio_sdk/enums/execution.py,sha256=DTKys4F3oXOxEZBef01gsgJYYea6t3Zfp0gLQ6_wJlo,267
+zsynctech_studio_sdk/enums/step.py,sha256=gw1PoRk8oNZfDdwMKNAjYvQFRuUsZQSaueF0qpEGn0g,152
+zsynctech_studio_sdk/enums/task.py,sha256=EaqTKCuQBRQ5P7R1U6ppa9Hcy8_d_KKB_ylsNoYteWQ,194
+zsynctech_studio_sdk/models/__init__.py,sha256=oQfAKeDbTwvJXRsiBQ096v3AdqTjxCaat798vQfN3RM,206
+zsynctech_studio_sdk/models/base.py,sha256=NTy3NVJaEt4Xhp0XXIXCRBPDLs_7AsyQVqvux_cyVrc,1615
+zsynctech_studio_sdk/models/config.py,sha256=iCfwWji3rXTcZR2g5bMa0Ar0k5aG6jCy6DSLb1zv9ds,857
+zsynctech_studio_sdk/models/execution.py,sha256=VAFkGxOwVEjGq1oCoLqPSRAvLxadMoJXCld93kDue40,604
+zsynctech_studio_sdk/models/step.py,sha256=qq9dO42wHvyP1ABpiEjhLzuKb9ExclSX73ota4zycfA,931
+zsynctech_studio_sdk/models/task.py,sha256=MNrbAovV-tRwoyrIUtfKgnchr6SZPtGd74FfRVoLHQU,973
+zsynctech_studio_sdk-0.1.0.dist-info/METADATA,sha256=-a2hSnb0vaNecMxJy9zrQTy8ChUpWDHPzht2GzllVf4,8042
+zsynctech_studio_sdk-0.1.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+zsynctech_studio_sdk-0.1.0.dist-info/entry_points.txt,sha256=I8nmQxT0vbevct2PeNvBGQOXZ5rAQqqFvZbRMihwrOM,69
+zsynctech_studio_sdk-0.1.0.dist-info/RECORD,,

zsynctech_studio_sdk-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.27.0
+Root-Is-Purelib: true
+Tag: py3-none-any

zsynctech_studio_sdk-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+zsynctech-studio-sdk = zsynctech_studio_sdk:master