pyznuny 0.0.1__py3-none-any.whl

pyznuny/__init__.py

@@ -0,0 +1,3 @@
+from .ticket.client import TicketClient
+
+__all__ = ["TicketClient"]

pyznuny/ticket/__init__.py

@@ -0,0 +1,7 @@
+from .client import TicketClient, SessionRoutes
+from .endpoints import Endpoint, EndpointsRegistry
+from .models import TicketCreateArticle, TicketCreatePayload, TicketCreateTicket
+
+__all__ = [
+    "TicketClient",
+]

pyznuny/ticket/client.py

@@ -0,0 +1,261 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any
+
+import httpx
+
+if __name__ == "__main__" and __package__ is None:
+    import os
+    import sys
+
+    sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), "../..")))
+    from pyznuny.ticket.endpoints import Endpoint, EndpointsRegistry,EndpointSetter, _DEFAULT_ENDPOINT_IDENTIFIERS, _DEFAULT_ENDPOINTS
+    from pyznuny.ticket.models import (
+        TicketCreateArticle,
+        TicketCreatePayload,
+        TicketCreateTicket,
+    )
+    from pyznuny.ticket.exceptions import TicketClientError
+    from pyznuny.ticket.routes import TicketRoutes, SessionRoutes
+else:
+    from .endpoints import Endpoint, EndpointsRegistry,EndpointSetter, _DEFAULT_ENDPOINT_IDENTIFIERS, _DEFAULT_ENDPOINTS
+    from .models import (
+        TicketCreateArticle,
+        TicketCreatePayload,
+        TicketCreateTicket,
+    )
+    from .routes import TicketRoutes, SessionRoutes
+    from .exceptions import TicketClientError
+
+
+
+
+class TicketClient:
+    """
+    Represents a client for interacting with the Ticket API
+
+    :param base_url: Base URL for the Ticket API which the client will connect to
+    :type base_url: str | None
+    :param username: Username for authentication
+    :type username: str | None
+    :param password: Password for authentication
+    :type password: str | None
+    :param endpoints: Optional custom endpoints registry
+    :type endpoints: EndpointsRegistry | None
+    :param timeout: Request timeout
+    :type timeout: float | None
+    :param headers: Optional custom headers
+    :type headers: Mapping[str, str] | None
+    """
+    def __init__(
+        self,
+        base_url: str | None = None,
+        *,
+        username: str | None = None,
+        password: str | None = None,
+        endpoints: EndpointsRegistry | None = None,
+        timeout: float | None = None,
+        headers: Mapping[str, str] | None = None,
+        client: httpx.Client | None = None,
+    ) -> None:
+        self._endpoints = endpoints or EndpointsRegistry()
+        self._endpoint_identifiers = dict(_DEFAULT_ENDPOINT_IDENTIFIERS)
+        if client is not None:
+            self._client = client
+        else:
+            client_kwargs: dict[str, Any] = {"timeout": timeout, "headers": headers}
+            if base_url is not None:
+                client_kwargs["base_url"] = base_url
+            self._client = httpx.Client(**client_kwargs)
+
+        self._register_default_endpoints()
+        self.ticket = TicketRoutes(self)
+        self.session = SessionRoutes(self)
+        self.set_endpoint = EndpointSetter(self)
+        self.session_id: str | None = None
+
+        if username is not None and password is not None:
+            self.login(username, password)
+
+    @property
+    def endpoints(self) -> EndpointsRegistry:
+        return self._endpoints
+
+    def register_endpoint(self, name: str, method: str, path: str) -> Endpoint:
+        """
+        Registers a custom endpoint for the Ticket API
+
+        :param name: Name of the endpoint
+        :type name: str
+        :param method: HTTP method for the endpoint
+        :type method: str
+        :param path: Endpoint path
+        :type path: str
+        :return: Registered endpoint
+        :rtype: Endpoint
+        """
+        return self._endpoints.register(Endpoint(name=name, method=method, path=path))
+
+    def set_endpoint_identifier(self, name: str, identifier: str) -> None:
+        """
+        Sets a custom identifier for an endpoint
+
+        :param name: Name of the endpoint
+        :type name: str
+        :param identifier: Custom identifier for the endpoint
+        :type identifier: str
+        """
+        self._endpoint_identifiers[name] = identifier
+
+    def endpoint_identifier(self, name: str) -> str:
+        """
+        Returns the custom identifier for an endpoint
+
+        :param name: Name of the endpoint
+        :type name: str
+        :return: Custom identifier for the endpoint
+        :rtype: str
+        """
+        try:
+            return self._endpoint_identifiers[name]
+        except KeyError as exc:
+            raise KeyError(f"Endpoint identifier not registered: {name}") from exc
+
+    def login(self, username: str, password: str) -> httpx.Response:
+        """
+        Creates a new session with the given username and password.
+
+        :param username: Username for authentication
+        :type username: str
+        :param password: Password for authentication
+        :type password: str
+        :return: Response object containing session details
+        :rtype: Response
+        """
+        response = self.session.create(username, password)
+        self.session_id = response.json().get("SessionID")
+
+
+    def request(
+        self,
+        endpoint_name: str,
+        *,
+        method: str | None = None,
+        path: str | None = None,
+        path_params: Mapping[str, Any] | None = None,
+        **kwargs: Any,
+    ) -> httpx.Response:
+        """
+        Sends a request to the Ticket API
+
+        :param endpoint_name: Name of the endpoint
+        :type endpoint_name: str
+        :param method: HTTP method for the request, defaults to None
+        :type method: str | None
+        :param path: Custom endpoint path, defaults to None
+        :type path: str | None
+        :param path_params: Parameters for the endpoint path, defaults to None
+        :type path_params: Mapping[str, Any] | None
+        :param kwargs: Additional keyword arguments for the request
+        :type kwargs: Any
+        :return: Response object
+        :rtype: httpx.Response
+        """
+        endpoint_method = method or self._endpoints.method_for(endpoint_name)
+        endpoint_path = path or self._endpoints.path_for(endpoint_name)
+        
+        
+        
+        if path_params:
+            endpoint_path = endpoint_path.format(**path_params)
+        response = self._client.request(endpoint_method, endpoint_path, **kwargs)
+        
+        response.raise_for_status()
+        if error := response.json().get("Error"):
+            self._raise_error(error)
+            
+        return response
+
+    def _raise_error(self, error: Mapping[str, Any]) -> None:
+        raise TicketClientError(error)
+
+    def close(self) -> None:
+        """
+        Closes the client connection
+        """
+        self._client.close()
+
+    def __enter__(self) -> "TicketClient":
+        return self
+
+    def __exit__(self, exc_type, exc, traceback) -> None:
+        self.close()
+
+    def _register_default_endpoints(self) -> None:
+        for name, (method, path) in _DEFAULT_ENDPOINTS.items():
+            if not self._endpoints.has(name):
+                self._endpoints.register(
+                    Endpoint(name=name, method=method, path=path)
+                )
+
+
+if __name__ == "__main__":
+    from dotenv import load_dotenv
+    load_dotenv()
+    import os
+    
+    class_payload_create = TicketCreatePayload(
+    Ticket=TicketCreateTicket(
+        Title="Erro no login",
+        Queue="ITS::Ops-TechOps::Sentinelops::Cops React - N1",
+        State="new",
+        Priority="3 normal",
+        CustomerUser="joel.junior@eitisolucoes.com.br",
+        Type="Monitoramento",
+    ),
+    Article=TicketCreateArticle(
+        Subject="Não consigo acessar",
+        Body="Detalhes do problema...",
+        ContentType="text/plain; charset=utf-8",
+        Charset="utf-8",
+        MimeType="text/plain",
+        SenderType="customer",
+        From_="joel.junior@eitisolucoes.com.br",
+    ),
+)
+
+    payload_create = {
+        "Ticket": {
+            "Title": "Erro no login",
+            "Queue": "ITS::Ops-TechOps::Sentinelops::Cops React - N1",
+            "State": "new",
+            "Priority": "3 normal",
+            "CustomerUser": "joel.junior@eitisolucoes.com.br",
+            "Type": "Monitoramento",
+        },
+        "Article": {
+            "Subject": "Não consigo acessar",
+            "Body": "Detalhes do problema...",
+            "ContentType": "text/plain; charset=utf-8",
+            "Charset": "utf-8",
+            "MimeType": "text/plain",
+            "SenderType": "customer",
+            "From": "joel.junior@eitisolucoes.com.br",
+        },
+    }
+    
+    payload_update = {
+        "Ticket": {
+            "State": "open",
+        }
+    }
+    
+    
+    client = TicketClient(base_url=os.getenv("HOST"), 
+                          username=os.getenv("USER_LOGIN"), password=os.getenv("PASS"))
+    
+    client.set_endpoint.ticket_get(endpoint="Tickets/{ticket_id}", 
+                                   identifier="ticket_id")
+    response = client.ticket.get(ticket_id=5853276)
+    print("GET Ticket Response:", response.json())

pyznuny/ticket/endpoints.py

@@ -0,0 +1,154 @@
+from __future__ import annotations
+
+
+from .models import Endpoint
+from typing import Iterable, Mapping, MutableMapping, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from pyznuny.ticket.client import TicketClient
+
+_DEFAULT_ENDPOINTS = {
+    "ticket_create": ("POST", "/Ticket"),
+    "ticket_update": ("PATCH", "/Ticket/{ticket_id}"),
+    "ticket_get": ("GET", "/Ticket/{ticket_id}"),
+    "session_create": ("POST", "/Session"),
+}
+
+_DEFAULT_ENDPOINT_IDENTIFIERS = {
+    "ticket_update": "ticket_id",
+    "ticket_get": "ticket_id",
+}
+
+
+
+class EndpointSetter:
+    """
+    Custom endpoint setter for the Ticket API
+
+    :arg client: Ticket client instance
+    :type client: TicketClient
+    """
+    def __init__(self, client: "TicketClient") -> None:
+        self._client = client
+
+    
+    def ticket_create(self, *, endpoint: str, method: str = "POST") -> Endpoint:
+        """
+        Sets a custom endpoint for creating tickets
+
+        :param endpoint: Custom endpoint for creating tickets
+        :type endpoint: str
+        :param method: HTTP method for creating tickets, defaults to POST
+        :type method: str
+        :return: Endpoint object
+        :rtype: Endpoint
+        """
+        return self._client.register_endpoint("ticket_create", method, endpoint)
+
+    def ticket_get(
+        self,
+        *,
+        endpoint: str,
+        identifier: str = "ticket_id",
+        method: str = "GET",
+    ) -> Endpoint:
+        """
+        Sets a custom endpoint for retrieving a ticket.
+
+        :param endpoint: Custom endpoint path
+        :type endpoint: str
+        :param identifier: Identifier for the ticket ID in the endpoint path
+        :type identifier: str
+        :param method: HTTP method for the endpoint, defaults to GET
+        :type method: str
+        :return: Registered endpoint
+        :rtype: Endpoint
+        """
+        endpoint_obj = self._client.register_endpoint(
+            "ticket_get",
+            method,
+            endpoint,
+        )
+        self._client.set_endpoint_identifier("ticket_get", identifier)
+        return endpoint_obj
+    
+    def ticket_update(
+        self,
+        *,
+        endpoint: str,
+        identifier: str = "ticket_id",
+        method: str = "POST",
+    ) -> Endpoint:
+        """
+        Sets a custom endpoint for updating a ticket.
+
+        :param endpoint: Custom endpoint path
+        :type endpoint: str
+        :param identifier: Identifier for the ticket ID in the endpoint path
+        :type identifier: str
+        :param method: HTTP method for the endpoint, defaults to POST
+        :type method: str
+        :return: Registered endpoint
+        :rtype: Endpoint
+        """
+        endpoint_obj = self._client.register_endpoint(
+            "ticket_update",
+            method,
+            endpoint,
+        )
+        self._client.set_endpoint_identifier("ticket_update", identifier)
+        return endpoint_obj
+
+
+
+
+class EndpointsRegistry:
+    """
+    Object representing the registry of API endpoints for the Ticket API
+
+    :arg base_path: Base path for the endpoints, defaults to an empty string
+    :type base_path: str
+    """
+    def __init__(
+        self,
+        *,
+        base_path: str = "",
+        endpoints: Iterable[Endpoint] | None = None,
+    ) -> None:
+        self._base_path = base_path
+        self._endpoints: MutableMapping[str, Endpoint] = {}
+        if endpoints:
+            for endpoint in endpoints:
+                self.register(endpoint)
+
+    @property
+    def base_path(self) -> str:
+        return self._base_path
+
+    @base_path.setter
+    def base_path(self, value: str) -> None:
+        self._base_path = value
+
+    def register(self, endpoint: Endpoint) -> Endpoint:
+        self._endpoints[endpoint.name] = endpoint
+        return endpoint
+
+    def configure(self, mapping: Mapping[str, tuple[str, str]]) -> None:
+        for name, (method, path) in mapping.items():
+            self.register(Endpoint(name=name, method=method, path=path))
+
+    def get(self, name: str) -> Endpoint:
+        try:
+            return self._endpoints[name]
+        except KeyError as exc:
+            raise KeyError(f"Endpoint not registered: {name}") from exc
+
+    def has(self, name: str) -> bool:
+        return name in self._endpoints
+
+    def path_for(self, name: str) -> str:
+        endpoint = self.get(name)
+        return endpoint.full_path(self._base_path)
+
+    def method_for(self, name: str) -> str:
+        return self.get(name).method

pyznuny/ticket/exceptions.py

@@ -0,0 +1,15 @@
+
+
+from typing import Any, Mapping
+
+class TicketClientError(Exception):
+    """
+    Docstring for TicketClientError
+    Represents an error returned by the TicketClient API.
+    """
+    def __init__(self, error: Mapping[str, Any] | str) -> None:
+        
+        self.error = error
+        code = error.get("ErrorCode") if isinstance(error, dict) else error
+        message = error.get("ErrorMessage") or "Unknown error" if isinstance(error, dict) else str(error)
+        super().__init__(f"{code}: {message}" if code else str(message))

pyznuny/ticket/models.py

@@ -0,0 +1,172 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, Mapping
+
+
+_VALID_METHODS = {
+    "GET",
+    "POST",
+    "PUT",
+    "PATCH",
+    "DELETE",
+    "HEAD",
+    "OPTIONS",
+}
+
+
+def _clean_dict(data: Mapping[str, Any]) -> dict[str, Any]:
+    return {key: value for key, value in data.items() if value is not None}
+
+
+def _require_non_empty(value: str, field: str) -> None:
+    if not value or not str(value).strip():
+        raise ValueError(f"{field} is required.")
+
+
+def _normalize_method(method: str) -> str:
+    normalized = method.strip().upper()
+    if normalized not in _VALID_METHODS:
+        valid = ", ".join(sorted(_VALID_METHODS))
+        raise ValueError(f"Unsupported HTTP method: {method!r}. Use one of: {valid}")
+    return normalized
+
+
+def _normalize_path(path: str) -> str:
+    normalized = "/" + path.lstrip("/")
+    if normalized == "/":
+        raise ValueError("Endpoint path cannot be empty.")
+    return normalized
+
+
+def _join_base_path(base_path: str, endpoint_path: str) -> str:
+    base = base_path.strip("/")
+    tail = endpoint_path.lstrip("/")
+    if not base:
+        return "/" + tail
+    return f"/{base}/{tail}"
+
+@dataclass(frozen=True, slots=True)
+class Endpoint:
+    """
+    Object representing an API endpoint
+
+    :arg name: Name of the endpoint
+    :type name: str
+    :arg method: HTTP method for the endpoint
+    :type method: str
+    :arg path: Endpoint path
+    :type path: str
+    """
+    name: str
+    method: str
+    path: str
+
+    def __post_init__(self) -> None:
+        object.__setattr__(self, "method", _normalize_method(self.method))
+        object.__setattr__(self, "path", _normalize_path(self.path))
+
+    def full_path(self, base_path: str = "") -> str:
+        """
+        Returns the full path for the endpoint
+
+        :param base_path: Base path for the endpoint, defaults to an empty string
+        :type base_path: str
+        :return: Full path for the endpoint
+        :rtype: str
+        """
+        return _join_base_path(base_path, self.path)
+
+
+
+@dataclass(slots=True)
+class TicketCreateTicket:
+    Title: str
+    Queue: str
+    State: str
+    Priority: str
+    CustomerUser: str | None = None
+    Type: str | None = None
+    Service: str | None = None
+    SLA: str | None = None
+    Owner: str | None = None
+    Responsible: str | None = None
+
+    def validate(self) -> None:
+        _require_non_empty(self.Title, "Ticket.Title")
+        _require_non_empty(self.Queue, "Ticket.Queue")
+        _require_non_empty(self.State, "Ticket.State")
+        _require_non_empty(self.Priority, "Ticket.Priority")
+
+    def to_dict(self) -> dict[str, Any]:
+        self.validate()
+        return _clean_dict(
+            {
+                "Title": self.Title,
+                "Queue": self.Queue,
+                "State": self.State,
+                "Priority": self.Priority,
+                "CustomerUser": self.CustomerUser,
+                "Type": self.Type,
+                "Service": self.Service,
+                "SLA": self.SLA,
+                "Owner": self.Owner,
+                "Responsible": self.Responsible,
+            }
+        )
+
+
+@dataclass(slots=True)
+class TicketCreateArticle:
+    Subject: str
+    Body: str
+    ContentType: str
+    Charset: str | None = None
+    MimeType: str | None = None
+    SenderType: str | None = None
+    From_: str | None = None
+
+    def validate(self) -> None:
+        _require_non_empty(self.Subject, "Article.Subject")
+        _require_non_empty(self.Body, "Article.Body")
+        _require_non_empty(self.ContentType, "Article.ContentType")
+
+    def to_dict(self) -> dict[str, Any]:
+        self.validate()
+        return _clean_dict(
+            {
+                "Subject": self.Subject,
+                "Body": self.Body,
+                "ContentType": self.ContentType,
+                "Charset": self.Charset,
+                "MimeType": self.MimeType,
+                "SenderType": self.SenderType,
+                "From": self.From_,
+            }
+        )
+
+
+@dataclass(slots=True)
+class TicketCreatePayload:
+    Ticket: TicketCreateTicket
+    Article: TicketCreateArticle
+    DynamicField: Mapping[str, Any] | None = None
+    Attachment: list[Mapping[str, Any]] | None = None
+    TimeUnit: int | None = None
+
+    def to_dict(self) -> dict[str, Any]:
+        return _clean_dict(
+            {
+                "Ticket": self.Ticket.to_dict(),
+                "Article": self.Article.to_dict(),
+                "DynamicField": self.DynamicField,
+                "Attachment": self.Attachment,
+                "TimeUnit": self.TimeUnit,
+            }
+        )
+
+
+
+class TicketUpdateTicket(TicketCreateTicket):
+    def validate(self):
+        pass

pyznuny/ticket/routes.py

@@ -0,0 +1,78 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any, Mapping
+
+import httpx
+
+from pyznuny.ticket.models import TicketCreatePayload
+
+if TYPE_CHECKING:
+    from pyznuny.ticket.client import TicketClient
+
+
+class SessionRoutes:
+    def __init__(self, client: "TicketClient") -> None:
+        self._client = client
+
+    def create(self, username: str, password: str) -> httpx.Response:
+        """
+        Creates a new session with the given username and password.
+        
+        :param username: username for authentication
+        :type username: str
+        :param password: password for authentication
+        :type password: str
+        :return: Response object containing session details
+        :rtype: Response
+        """
+        return self._client.request(
+            "session_create",
+            json={"UserLogin": username, "Password": password},
+        )
+
+
+class TicketRoutes:
+    def __init__(self, client: "TicketClient") -> None:
+        self._client = client
+
+    def create(
+        self,
+        payload: TicketCreatePayload | Mapping[str, Any] | None = None,
+        **payload_kwargs: Any,
+    ) -> httpx.Response:
+        
+        if payload is None:
+            payload_dict = dict(payload_kwargs)
+            
+        elif isinstance(payload, TicketCreatePayload):
+            payload_dict = payload.to_dict()
+            payload_dict.update(payload_kwargs)
+        else:
+            payload_dict = dict(payload)
+            payload_dict.update(payload_kwargs)
+
+        payload_dict.update({"SessionID": self._client.session_id})
+        return self._client.request("ticket_create", json=payload_dict)
+    
+
+    def update(self, ticket_id: str | int , **payload: dict) -> httpx.Response:
+        identifier = self._client.endpoint_identifier("ticket_update")
+        
+        payload.update({"SessionID": self._client.session_id})
+        return self._client.request(
+            "ticket_update",
+            path_params={identifier: ticket_id},
+            json=payload,
+        )
+        
+    def get(self, ticket_id: str | int, 
+            dynamic_fields:int=0,
+            all_articles:int=0) -> httpx.Response:
+        identifier = self._client.endpoint_identifier("ticket_get")
+        return self._client.request(
+            "ticket_get",
+            path_params={identifier: ticket_id},
+            params={"SessionID": self._client.session_id,
+                    "DynamicFields": dynamic_fields,
+                    "AllArticles": all_articles},
+        )

pyznuny-0.0.1.dist-info/METADATA

@@ -0,0 +1,12 @@
+Metadata-Version: 2.4
+Name: pyznuny
+Version: 0.0.1
+Summary: A Python client for interacting with the Znuny ticketing system API.
+Author-email: Junior Rosa <jr.dasrosas@gmail.com>, Pablo Gascon <pablogasconiel445@gmail.com>
+Project-URL: Homepage, https://github.com/Junior-Rosa/py-znuny
+Project-URL: Repository, https://github.com/Junior-Rosa/py-znuny
+Project-URL: Issues, https://github.com/Junior-Rosa/py-znuny/issues
+Requires-Python: >=3.14
+Description-Content-Type: text/markdown
+Requires-Dist: httpx>=0.28.1
+Requires-Dist: pydantic>=2.12.5

pyznuny-0.0.1.dist-info/RECORD

@@ -0,0 +1,11 @@
+pyznuny/__init__.py,sha256=2hs3juXhAKpKyn_poQYzFr8ns0jmf_uBNKxT6u6w4Wo,68
+pyznuny/ticket/__init__.py,sha256=lnWfZ1Al7LLLogUK_EUS_8WSNrRKzoJdbuYxpMXnUcA,215
+pyznuny/ticket/client.py,sha256=kfYZIKFrCEJ7-A7aHF9ZMl_uw3tVj_1FAy3vrRw8JlI,8641
+pyznuny/ticket/endpoints.py,sha256=nX5zJxOtwiwg3rtnt_7h4tRgSTyKPwof0i1sqqxljug,4444
+pyznuny/ticket/exceptions.py,sha256=fqJFlMY1wl3Fb98Fz2odolOIyaDhKEwH1kP8Uv2k9-s,535
+pyznuny/ticket/models.py,sha256=ezUxGc_Ftot0J2Entz5NXB7oXAeBIiuulN7NlxXTVTc,4692
+pyznuny/ticket/routes.py,sha256=54cr08Z2NM9JwWCkY47E1Kj94Uen9d1PJXrJ24mb2nM,2514
+pyznuny-0.0.1.dist-info/METADATA,sha256=xQPKpX-wpBmKYxvy5iFeyPLBaO-cNY-Z4xw2uD0pc_U,544
+pyznuny-0.0.1.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+pyznuny-0.0.1.dist-info/top_level.txt,sha256=ki9uLRbo2oQCeiEaaYUcnYMj1mD_dkIhQroMCdJJXmk,8
+pyznuny-0.0.1.dist-info/RECORD,,

pyznuny-0.0.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.10.2)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

pyznuny-0.0.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+pyznuny