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

zsynctech_studio_sdk/client.py

@@ -0,0 +1,54 @@
+from httpx import Client, Response
+
+_instance_id = None
+_secret_key = None
+_client = None
+_server = None
+_gateway = "automation-gateway"
+
+def set_credentials(
+    instance_id: str,
+    server: str,
+    secret_key: str
+):
+    global _instance_id, _client, _server, _secret_key, _gateway
+
+    _secret_key = secret_key
+    _instance_id = instance_id
+    _server = str(server).rstrip("/")
+    base_url = f"{_server}/{_gateway}/{_instance_id}"
+
+    _client = Client(
+        base_url=base_url,
+        headers={
+            "Authorization": f"Bearer {_secret_key}",
+            "Content-Type": "application/json"
+        },
+        timeout=10
+    )
+
+
+def request(method: str, endpoint: str, **kwargs):
+    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) -> Response:
+    return request("GET", endpoint, params=params)
+
+
+def post(endpoint: str, json: dict = None) -> Response:
+    return request("POST", endpoint, json=json)
+
+
+def put(endpoint: str, json: dict = None) -> Response:
+    return request("PUT", endpoint, json=json)
+
+
+def patch(endpoint: str, json: dict = None) -> Response:
+    return request("PATCH", endpoint, json=json)

zsynctech_studio_sdk/common/exceptions.py

@@ -0,0 +1,26 @@
+class ExecutionError(Exception):
+    """Exceção base para erros relacionados à execução."""
+
+class ExecutionAlreadyFinishedError(ExecutionError):
+    """Lançada quando uma operação é chamada em uma execução já finalizada."""
+
+class ExecutionFieldError(ExecutionError):
+    """Lançada quando o campo informado não existe no ExecutionModel."""
+
+class ExecutionUpdateError(ExecutionError):
+    """Lançada quando ocorre falha ao atualizar a execução no servidor."""
+
+class ExecutionNotStardedError(ExecutionError):
+    """Lançada quando ocorre falha ao atualizar a execução no servidor."""
+
+
+class TaskError(Exception):
+    """Exceção base para erros relacionados à task."""
+
+class TaskUpdateError(TaskError):
+    """Lançada quando ocorre falha ao atualizar a execução no servidor."""
+
+class TaksNotStardedError(TaskError):
+    """Lançada quando ocorre falha ao atualizar a execução no servidor."""
+
+

zsynctech_studio_sdk/context.py

@@ -0,0 +1,4 @@
+class Context:
+    execution = None
+    task = None
+    step = None

zsynctech_studio_sdk/enums/__init__.py

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

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/operations.py

@@ -0,0 +1,6 @@
+from enum import StrEnum
+
+
+class Operations(StrEnum):
+    CREATE = 'create'
+    UPDATE = 'update'

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,84 @@
+from zsynctech_studio_sdk.models.execution import ExecutionModel, ExecutionStatus
+from zsynctech_studio_sdk.common.exceptions import ExecutionUpdateError
+from zsynctech_studio_sdk.utils import get_utc_now
+from zsynctech_studio_sdk import client
+from typing import Optional, Any
+
+
+EXECUTION_STATUS_COMPLETED = [
+    ExecutionStatus.OUT_OF_OPERATING_HOURS,
+    ExecutionStatus.INTERRUPTED,
+    ExecutionStatus.FINISHED,
+    ExecutionStatus.ERROR,
+]
+
+
+class Execution:
+    def __init__(self, execution_id: Optional[str] = None):
+        self.__execution_id = execution_id
+        self.__execution: ExecutionModel = ExecutionModel()
+
+        if self.execution_id:
+            self.execution.id = self.execution_id
+
+    @property
+    def execution(self) -> ExecutionModel:
+        return self.__execution
+
+    @property
+    def execution_id(self) -> str:
+        return self.__execution_id
+
+    @execution_id.setter
+    def execution_id(self, value: str):
+        self.__execution_id = value
+
+    def _update(
+            self,
+            status: Optional[ExecutionStatus] = None,
+            observation: Optional[str] = None,
+            end_date: Optional[str] = None,
+            total_task_count: Optional[int] = None,
+            current_task_count: Optional[int] = None,
+        ) -> dict:
+
+        self.execution.status = status or self.execution.status
+        self.execution.endDate = end_date or self.execution.endDate
+        self.execution.observation = observation or self.execution.observation
+        self.execution.totalTaskCount = total_task_count or self.execution.totalTaskCount
+        self.execution.currentTaskCount = current_task_count or self.execution.currentTaskCount
+
+        try:
+            response = client.patch(
+                endpoint=f"{self.execution_id}/executions",
+                json=self.execution.model_dump()
+            )
+            response.raise_for_status()
+        except Exception as e:
+            raise ExecutionUpdateError(f"Erro ao atualizar execução: {str(e)}") from e
+
+        return self.execution.model_dump()
+
+    def set_total_task_count(self, total_task_count: int) -> dict[str, Any]:
+        return self._update(total_task_count=total_task_count)
+
+    def update_current_task_count(self, current_task_count: int) -> dict[str, Any]:
+        return self._update(current_task_count=current_task_count)
+
+    def update_observation(self, observation: str) -> dict[str, Any]:
+        return self._update(observation=observation)
+
+    def start(self, observation: Optional[str] = None) -> dict:
+        return self._update(ExecutionStatus.RUNNING, observation)
+
+    def error(self, observation: Optional[str] = None) -> dict:
+        return self._update(ExecutionStatus.ERROR, observation=observation, end_date=get_utc_now())
+
+    def out_of_operating_hours(self, observation: Optional[str] = None) -> dict:
+        return self._update(ExecutionStatus.OUT_OF_OPERATING_HOURS, observation=observation, end_date=get_utc_now())
+
+    def finished(self, observation: Optional[str] = None) -> dict:
+        return self._update(ExecutionStatus.FINISHED, observation=observation, end_date=get_utc_now())
+
+    def interrupted(self, observation: Optional[str] = None) -> dict:
+        return self._update(ExecutionStatus.INTERRUPTED, observation=observation, end_date=get_utc_now())

zsynctech_studio_sdk/loggers.py

@@ -0,0 +1,56 @@
+import logging
+from logging.config import dictConfig
+from typing import Any
+
+
+LOGGING_CONFIG: dict[str, Any] = {
+    "version": 1,
+    "disable_existing_loggers": False,
+    "formatters": {
+        "file": {
+            "format": "%(asctime)s %(levelname)s [module:(%(module)s) line:%(lineno)d]: %(message)s",
+            "datefmt": "%d-%m-%Y %H:%M"
+        },
+        "console": {
+            "format": "[module:(%(module)s) %(lineno)d]: %(message)s", 
+            "datefmt": "[%X]"
+        },
+    },
+    "handlers": {
+        "console": {
+            "()": "rich.logging.RichHandler",
+            "formatter": "console",
+            "rich_tracebacks": False,
+            "tracebacks_show_locals": False,
+            "show_time": True,
+            "show_level": True,
+            "omit_repeated_times": False,
+            "markup": False,
+            "enable_link_path": True,
+            "show_path": True,
+        },
+        "file": {
+            "class": "logging.handlers.RotatingFileHandler",
+            "formatter": "file",
+            "filename": "log.log",
+            "maxBytes": 1024 * 1024 * 5,
+            "backupCount": 5,
+            "encoding": "utf-8",
+        },
+    },
+    "root": {
+        "handlers": [
+            "console",
+            "file"
+        ]
+    },
+    "loggers": {
+        "zsynctech-studio-sdk": {
+            "level": "DEBUG"
+        }
+    },
+}
+
+dictConfig(LOGGING_CONFIG)
+
+logger = logging.getLogger("zsynctech-studio-sdk")

zsynctech_studio_sdk/models/__init__.py

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

zsynctech_studio_sdk/models/config.py

@@ -0,0 +1,52 @@
+from uuid_extensions import uuid7
+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
+    automationName: Optional[str] = "System"
+    clientId: Optional[str] = None
+    userId: Optional[str] = "System"
+    executionId: Optional[str] = str(uuid7())
+    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
+
+
+if __name__ == "__main__":
+    print(Config(
+        instanceId='0198cdc7-6e20-74b9-89f8-2a6e975da3db',
+        automationName='Robô Benner Eventos',
+        clientId='0198c254-dec1-7bc2-9ed2-33f046155d13',
+        userId='0198c254-df28-7074-9b48-2567993dcf12',
+        executionId='0198d8d5-548f-7c00-baba-12f514b6419a',
+        inputPath='/benner/eventos/input',
+        inputMetaData=None,
+        inputType='FTP',
+        outputPath='/benner/eventos/output',
+        outputMetaData=None,
+        outputType='FTP',
+        keepAlive=False,
+        keepAliveInterval=None,
+        credentials=None
+    ).model_dump())

zsynctech_studio_sdk/models/execution.py

@@ -0,0 +1,102 @@
+from pydantic import Field, field_validator, model_validator, BaseModel
+from zsynctech_studio_sdk.enums.execution import ExecutionStatus
+from uuid_extensions.uuid7 import uuid7
+from datetime import datetime
+from typing import Optional
+import re
+
+
+class ExecutionModel(BaseModel):
+    id: str = Field(
+        default_factory=lambda: str(uuid7()),
+        min_length=1,
+        description="ID único da execução"
+    )
+
+    observation: Optional[str] = Field(
+        default=None,
+        description="Observação sobre a execução"
+    )
+
+    status: Optional[ExecutionStatus] = Field(
+        default=ExecutionStatus.WAITING,
+        description="Status atual da execução"
+    )
+
+    endDate: Optional[str] = Field(
+        default=None,
+        description="Data de término no formato ISO 8601 com Z"
+    )
+
+    totalTaskCount: Optional[int] = Field(
+        ge=0,
+        default=0,
+        description="Número total de tarefas"
+    )
+
+    currentTaskCount: Optional[int] = Field(
+        ge=0,
+        default=0,
+        description="Número de tarefas executadas"
+    )
+
+    @field_validator('endDate')
+    @classmethod
+    def validate_end_date_format(cls, v):
+        """Valida o formato da data de término"""
+        if v is None:
+            return v
+
+        # Regex para formato ISO 8601 com Z no final
+        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 (ex: 2024-01-15T10:30:00.000Z)')
+
+        # Valida se é uma data válida
+        try:
+            datetime.fromisoformat(v.replace('Z', '+00:00'))
+        except ValueError:
+            raise ValueError('endDate deve ser uma data válida')
+
+        return v
+
+    @field_validator('id')
+    @classmethod
+    def validate_id_format(cls, v):
+        """Valida se o ID é um UUID7 válido"""
+        # Verifica se é um UUID válido
+
+        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')
+
+        # Verifica se é um UUID7 (primeiro dígito da versão deve ser 7)
+        version = int(v[14], 16)
+        if version != 7:
+            raise ValueError('ID deve ser um UUID7 válido')
+
+        return v
+
+    @model_validator(mode='after')
+    def validate_business_rules(self):
+        """Valida regras de negócio que dependem de múltiplos campos"""
+        # Valida se current_task_count não excede total_task_count
+        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
+
+    class Config:
+        extra = "forbid"
+        validate_assignment = True
+        json_schema_extra = {
+            "example": {
+                "id": "0685b254-3a1f-7bf6-8000-3a0ce7a0a52f",
+                "observation": "Execução de teste bem-sucedida",
+                "status": "FINISHED",
+                "endDate": "2024-01-15T10:30:00.000Z",
+                "totalTaskCount": 10,
+                "currentTaskCount": 10
+            }
+        }

zsynctech_studio_sdk/models/step.py

@@ -0,0 +1,173 @@
+from zsynctech_studio_sdk.enums.operations import Operations
+from pydantic import Field, field_validator, BaseModel
+from zsynctech_studio_sdk.enums.step import StepStatus
+from zsynctech_studio_sdk.utils import get_utc_now
+from uuid_extensions.uuid7 import uuid7
+from datetime import datetime
+from typing import Optional
+import re
+
+
+class StepModel(BaseModel):
+    id: str = Field(
+        default_factory=lambda: str(uuid7()),
+        min_length=1,
+        description="ID único do step"
+    )
+
+    observation: Optional[str] = Field(
+        default=None,
+        description="Observação sobre o step"
+    )
+
+    operation: Operations = Field(
+        default=Operations.CREATE,
+        description="Operação a ser realizada no step"
+    )
+
+    taskId: Optional[str] = Field(
+        min_length=1,
+        default=None,
+        description="ID da tarefa a ser realizada no step"
+    )
+
+    automationOnClientId: Optional[str] = Field(
+        default=None,
+        min_length=1,
+        description="ID do cliente da automação"
+    )
+
+    status: StepStatus = Field(
+        default=StepStatus.UNPROCESSED,
+        description="Status do step"
+    )
+
+    stepCode: Optional[str] = Field(
+        default=None,
+        min_length=1,
+        description="Código do step"
+    )
+
+    startDate: Optional[str] = Field(
+        default=get_utc_now(),
+        description="Data de término do step"
+    )
+
+    endDate: Optional[str] = Field(
+        default=None,
+        description="Data de término do step"
+    )
+
+    @field_validator('startDate')
+    @classmethod
+    def validate_start_date_format(cls, v):
+        """Valida o formato da data de término"""
+        if v is None:
+            return v
+
+        # Regex para formato ISO 8601 com Z no final
+        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 (ex: 2024-01-15T10:30:00.000Z)')
+
+        # Valida se é uma data válida
+        try:
+            datetime.fromisoformat(v.replace('Z', '+00:00'))
+        except ValueError:
+            raise ValueError('end_date deve ser uma data válida')
+
+        return v
+
+    @field_validator('endDate')
+    @classmethod
+    def validate_end_date_format(cls, v):
+        """Valida o formato da data de término"""
+        if v is None:
+            return v
+
+        # Regex para formato ISO 8601 com Z no final
+        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 (ex: 2024-01-15T10:30:00.000Z)')
+
+        # Valida se é uma data válida
+        try:
+            datetime.fromisoformat(v.replace('Z', '+00:00'))
+        except ValueError:
+            raise ValueError('end_date deve ser uma data válida')
+
+        return v
+
+    @field_validator('status')
+    @classmethod
+    def validate_status(cls, v):
+        """Valida se o status é um status válido"""
+        if v not in StepStatus:
+            raise ValueError('status deve ser um status válido')
+        return v
+
+    @field_validator('id')
+    @classmethod
+    def validate_id_format(cls, v):
+        """Valida se o ID é um UUID7 válido"""
+        # Verifica se é um UUID válido
+        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')
+
+        # Verifica se é um UUID7 (primeiro dígito da versão deve ser 7)
+        version = int(v[14], 16)
+        if version != 7:
+            raise ValueError('ID deve ser um UUID7 válido')
+
+        return v
+
+    @field_validator('taskId')
+    @classmethod
+    def validate_task_id_format(cls, v):
+        """Valida se o task_id é um UUID7 válido"""
+        # Verifica se é um UUID válido
+        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('taskId deve ser um UUID válido')
+
+        # Verifica se é um UUID7 (primeiro dígito da versão deve ser 7)
+        version = int(v[14], 16)
+        if version != 7:
+            raise ValueError('taskId deve ser um UUID7 válido')
+
+        return v
+
+    @field_validator('automationOnClientId')
+    @classmethod
+    def validate_automation_on_cliente_id_format(cls, v):
+        """Valida se o automationOnClientId é um UUID7 válido"""
+        if v is None:
+            return v
+
+        # Verifica se é um UUID válido
+        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('automationOnClientId deve ser um UUID válido')
+
+        # Verifica se é um UUID7 (primeiro dígito da versão deve ser 7)
+        version = int(v[14], 16)
+        if version != 7:
+            raise ValueError('automationOnClientId deve ser um UUID7 válido')
+
+        return v
+
+    class Config:
+        extra = "forbid"
+        validate_assignment = True
+        json_schema_extra = {
+            "example": {
+                "id": "0685b254-3a1f-7bf6-8000-3a0ce7a0a52f",
+                "observation": "Execução bem-sucedida",
+                "operation": "CREATE",
+                "taskId": "0685b254-3a1f-7bf6-8000-3a0ce7a0a52f",
+                "automationOnClienteId": "0685b254-3a1f-7bf6-8000-3a0ce7a0a52f",
+                "status": "SUCCESS",
+                "stepCode": "0001",
+                "endDate": "2024-01-15T10:30:00.000Z"
+            }
+        }
+
+    

zsynctech_studio_sdk/models/task.py

@@ -0,0 +1,169 @@
+from zsynctech_studio_sdk.enums.operations import Operations
+from pydantic import Field, field_validator, BaseModel
+from zsynctech_studio_sdk.enums.task import TaskStatus
+from zsynctech_studio_sdk.utils import get_utc_now
+from uuid_extensions.uuid7 import uuid7
+from datetime import datetime
+from typing import Optional
+import re
+
+
+class TaskModel(BaseModel):
+    id: str = Field(
+        default_factory=lambda: str(uuid7()),
+        min_length=1,
+        description="ID único da task"
+    )
+
+    operation: Operations = Field(
+        default=Operations.CREATE,
+        description="Operação a ser realizada na task"
+    )
+
+    description: Optional[str] = Field(
+        default=None,
+        max_length=60,
+        description="Descrição da task"
+    )
+
+    jsonData: Optional[dict] = Field(
+        default=None,
+        description="Dados JSON da task"
+    )
+
+    observation: Optional[str] = Field(
+        default=None,
+        description="Observação sobre a task"
+    )
+
+    code: Optional[str] = Field(
+        default=None,
+        description="Código da task"
+    )
+
+    executionId: Optional[str] = Field(
+        min_length=1,
+        default=None,
+        description="ID da execução"
+    )
+
+    status: TaskStatus = Field(
+        default=TaskStatus.UNPROCESSED,
+        description="Status da task"
+    )
+
+    startDate: Optional[str] = Field(
+        default=get_utc_now(),
+        description="Data de início da task"
+    )
+
+    endDate: Optional[str] = Field(
+        default=None,
+        description="Data de término da task"
+    )
+
+    @field_validator('startDate')
+    @classmethod
+    def validate_start_date_format(cls, v):
+        """Valida o formato da data de término"""
+        if v is None:
+            return v
+
+        # Regex para formato ISO 8601 com Z no final
+        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 (ex: 2024-01-15T10:30:00.000Z)')
+
+        # Valida se é uma data válida
+        try:
+            datetime.fromisoformat(v.replace('Z', '+00:00'))
+        except ValueError:
+            raise ValueError('end_date deve ser uma data válida')
+
+        return v
+
+    @field_validator('endDate')
+    @classmethod
+    def validate_end_date_format(cls, v):
+        """Valida o formato da data de término"""
+        if v is None:
+            return v
+
+        # Regex para formato ISO 8601 com Z no final
+        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 (ex: 2024-01-15T10:30:00.000Z)')
+
+        # Valida se é uma data válida
+        try:
+            datetime.fromisoformat(v.replace('Z', '+00:00'))
+        except ValueError:
+            raise ValueError('end_date deve ser uma data válida')
+
+        return v
+
+    @field_validator('status')
+    @classmethod
+    def validate_status(cls, v):
+        """Valida se o status é um status válido"""
+        if v not in TaskStatus:
+            raise ValueError('status deve ser um status válido')
+        return v
+
+    @field_validator('id')
+    @classmethod
+    def validate_id_format(cls, v):
+        """Valida se o ID é um UUID7 válido"""
+        # Verifica se é um UUID válido
+        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')
+
+        # Verifica se é um UUID7 (primeiro dígito da versão deve ser 7)
+        version = int(v[14], 16)
+        if version != 7:
+            raise ValueError('ID deve ser um UUID7 válido')
+
+        return v
+
+    @field_validator('executionId')
+    @classmethod
+    def validate_executionid_format(cls, v):
+        """Valida se o executionId é um UUID7 válido"""
+        # Verifica se é um UUID válido
+        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('executionId deve ser um UUID válido')
+
+        # Verifica se é um UUID7 (primeiro dígito da versão deve ser 7)
+        version = int(v[14], 16)
+        if version != 7:
+            raise ValueError('executionId deve ser um UUID7 válido')
+
+        return v
+
+    @field_validator('description')
+    @classmethod
+    def validate_description_length(cls, v):
+        """Valida se a descrição tem no máximo 60 caracteres"""
+
+        if v is None:
+            return v
+
+        if len(v) > 60:
+            raise ValueError('description deve ter no máximo 60 caracteres')
+        return v
+
+    class Config:
+        extra = "forbid"
+        validate_assignment = True
+        json_schema_extra = {
+            "example": {
+                "id": "0685b254-3a1f-7bf6-8000-3a0ce7a0a52f",
+                "operation": "CREATE",
+                "description": "Processar dados do cliente",
+                "jsonData": {"clientId": "12345", "action": "process"},
+                "observation": "Task executada com sucesso",
+                "executionId": "0685b254-3a1f-7bf6-8000-3a0ce7a0a52f",
+                "status": "SUCCESS",
+                "endDate": "2024-01-15T10:30:00.000Z"
+            }
+        }

zsynctech_studio_sdk/start.py

@@ -0,0 +1,83 @@
+from zsynctech_studio_sdk.utils import wait_until_file_stable
+from watchdog.events import PatternMatchingEventHandler
+from zsynctech_studio_sdk.loggers import logger
+from watchdog.observers import Observer
+from zsynctech_studio_sdk import client
+from appdirs import AppDirs
+from queue import Queue
+import json
+import os
+
+
+APPS_DIR = AppDirs()
+SDK_DIR = os.path.join(APPS_DIR.user_data_dir, "zsynctech")
+
+
+class StartEventHandler:
+    def __init__(self):
+        self.observer = Observer()
+        self._recursive = False
+        self.queue = Queue()
+
+        if client._instance_id is None:
+            raise RuntimeError("Credentials not set. Call set_credentials() first.")
+
+        self.sdk_path = os.path.join(SDK_DIR, client._instance_id)
+        os.makedirs(self.sdk_path, exist_ok=True)
+
+    @property
+    def recursive(self):
+        return self._recursive
+
+    class JSONHandler(PatternMatchingEventHandler):
+        def __init__(self, queue):
+            super().__init__(patterns=["*.json"], ignore_directories=True)
+            self.queue = queue
+            self._processed_files = {}
+
+        def _load_json(self, src_path):
+            if wait_until_file_stable(src_path, check_interval=0.5, timeout=10):
+                try:
+                    with open(src_path, "r", encoding="utf-8") as f:
+                        return json.load(f)
+                except Exception:
+                    logger.exception("An error occurred while loading the file", stack_info=True)
+            return None
+
+        def _should_process(self, src_path):
+            try:
+                mtime = os.path.getmtime(src_path)
+            except FileNotFoundError:
+                return False
+            last_mtime = self._processed_files.get(src_path, 0)
+            if mtime > last_mtime:
+                self._processed_files[src_path] = mtime
+                return True
+            return False
+
+        def on_modified(self, event):
+            if self._should_process(event.src_path):
+                data = self._load_json(event.src_path)
+                if data:
+                    self.queue.put(data)
+
+    def __start_observer(self):
+        event_handler = self.JSONHandler(self.queue)
+        self.observer.schedule(event_handler, self.sdk_path, recursive=self.recursive)
+        self.observer.start()
+        logger.info(f"Aguardando eventos em: {self.sdk_path}")
+
+    def listen_events(self, timeout=None):
+        self.__start_observer()
+        try:
+            while True:
+                try:
+                    data = self.queue.get(timeout=timeout)
+                    yield data
+                except KeyboardInterrupt:
+                    break
+                except Exception:
+                    pass
+        finally:
+            self.observer.stop()
+            self.observer.join()

zsynctech_studio_sdk/utils.py

@@ -0,0 +1,40 @@
+from datetime import datetime, timezone
+import time
+import os
+
+
+def wait_until_file_stable(path, check_interval=0.5, timeout=10):
+    """
+    Aguarda até que o arquivo 'path' não mude de tamanho por 'check_interval' segundos.
+    Retorna True se o arquivo estabilizar, False se estourar o timeout.
+    """
+    start_time = time.time()
+
+    if not os.path.exists(path):
+        return False
+
+    last_size = -1
+    while True:
+        try:
+            current_size = os.path.getsize(path)
+        except FileNotFoundError:
+            return False
+
+        if current_size == last_size and current_size > 0:
+            return True
+
+        last_size = current_size
+        time.sleep(check_interval)
+
+        if time.time() - start_time > timeout:
+            return False
+    
+
+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')

zsynctech_studio_sdk-0.1.1.dist-info/METADATA

@@ -0,0 +1,15 @@
+Metadata-Version: 2.4
+Name: zsynctech-studio-sdk
+Version: 0.1.1
+Summary: SDK Python para integração com plataforma ZSync Studio
+Author-email: Rodrigo Zavan <rodrigo.zavan@zsynctech.com>
+Requires-Python: >=3.13
+Requires-Dist: appdirs>=1.4.4
+Requires-Dist: httpx>=0.28.1
+Requires-Dist: playwright>=1.54.0
+Requires-Dist: pydantic>=2.11.7
+Requires-Dist: uuid7>=0.1.0
+Requires-Dist: watchdog>=6.0.0
+Description-Content-Type: text/markdown
+
+

zsynctech_studio_sdk-0.1.1.dist-info/RECORD

@@ -0,0 +1,22 @@
+zsynctech_studio_sdk/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+zsynctech_studio_sdk/client.py,sha256=1Y5X1LxFWsC6oy1rhX8pynbngMfd9ng01Li1MdMNAAk,1401
+zsynctech_studio_sdk/context.py,sha256=_ffe036XK2esyMMVI8P-ZcagJYLn8wi5T6vfbm9P3jc,70
+zsynctech_studio_sdk/execution.py,sha256=o72kqf9IrQID4gKlf9H9JBpwLMFey2-BosYadgh8lBk,3413
+zsynctech_studio_sdk/loggers.py,sha256=ZowaCfqcHLZsLi5j1mf1Tkjk8RoKJkz50SrDhFfMG0M,1517
+zsynctech_studio_sdk/start.py,sha256=BMMZJqb2v2KG7_Sj6eT4iR1fPtx3Bhq6JLIt-0q4dTE,2895
+zsynctech_studio_sdk/task.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+zsynctech_studio_sdk/utils.py,sha256=e2LOKQQVNTzsgUJy6nurG-15lhFA4T6ryazd0_H6aGM,1136
+zsynctech_studio_sdk/common/exceptions.py,sha256=Aio_w8ZAb7V-LHuu73egk3sk-umbLaISMljXquNEjwQ,952
+zsynctech_studio_sdk/enums/__init__.py,sha256=xaRgVmXIenVCybZCC7OvwJei00-cb0XJjqBpxy79Khw,234
+zsynctech_studio_sdk/enums/execution.py,sha256=TVsUzRzdNXNj96pLzms3tskva01iwXx9fKJqj8xaoIQ,278
+zsynctech_studio_sdk/enums/operations.py,sha256=MbE486aNRFCWqZj1gS61TIssCPfCG6ISdXvYaQ3wDcc,104
+zsynctech_studio_sdk/enums/step.py,sha256=iHUWHdjqBZwP3YE_yZWpEkYKdVuwew-JwWMPO3kR9PQ,160
+zsynctech_studio_sdk/enums/task.py,sha256=6PMjcQclVoZObjkGqjMh6mJVMcpzLXQ3dLWWkjMkg2o,203
+zsynctech_studio_sdk/models/__init__.py,sha256=gPF2pDK84uJAzSHluOfzBrqpFuLV_GKM_PDB2pKsTiQ,276
+zsynctech_studio_sdk/models/config.py,sha256=CeKmy7lvziuqgU35rM3WvU0v9aa5ybk3FQbJpm233QE,1589
+zsynctech_studio_sdk/models/execution.py,sha256=Ig9Lsr9WsCeHeMvPihiOzABqzgeqzYQfxRJvOykOVtU,3302
+zsynctech_studio_sdk/models/step.py,sha256=ya1tMr1iXt1DAGQ6Mk2RRnlzDL_ojzKKEGrRw4IjUwM,5677
+zsynctech_studio_sdk/models/task.py,sha256=EgUmbuTRwEvv-w9qpes7YXDBmewpy_VfzSuXPauuA6o,5418
+zsynctech_studio_sdk-0.1.1.dist-info/METADATA,sha256=AvidlA0lRH00PV3rwSp1OMSQCbOjSNpHA9FXu4vWikc,438
+zsynctech_studio_sdk-0.1.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+zsynctech_studio_sdk-0.1.1.dist-info/RECORD,,

zsynctech_studio_sdk-0.1.1.dist-info/WHEEL

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