glpi-python-client 0.2.1__py3-none-any.whl → 0.3.1__py3-none-any.whl

glpi_python_client/__init__.py

@@ -1,13 +1,20 @@
 """Public import surface for the GLPI Python client package.
 
-The package re-exports the asynchronous :class:`GlpiClient` and the
-``api_schema`` and ``custom_schema`` Pydantic models so downstream users
-can import them from a single stable package root.
+The package re-exports two client classes:
+
+* :class:`GlpiClient` — synchronous, blocking client (single source of
+  truth for endpoint behaviour).
+* :class:`AsyncGlpiClient` — asynchronous facade that wraps each
+  synchronous method into a coroutine.
+
+The ``api_schema`` and ``custom_schema`` Pydantic models are also
+re-exported so downstream users can import them from a single stable
+package root.
 """
 
 from __future__ import annotations
 
-from glpi_python_client.clients import GlpiClient
+from glpi_python_client.clients import AsyncGlpiClient, GlpiClient
 from glpi_python_client.models import (
     DeleteDocument,
     DeleteEntity,
@@ -62,11 +69,13 @@ from glpi_python_client.models import (
     PostTicketTask,
     PostTimelineDocument,
     PostUser,
+    TicketMarkdownOptions,
 )
 
-__version__ = "0.2.1"
+__version__ = "0.3.1"
 
 __all__ = [
+    "AsyncGlpiClient",
     "DeleteDocument",
     "DeleteEntity",
     "DeleteFollowup",
@@ -121,5 +130,6 @@ __all__ = [
     "PostTicketTask",
     "PostTimelineDocument",
     "PostUser",
+    "TicketMarkdownOptions",
     "__version__",
 ]

glpi_python_client/clients/__init__.py

@@ -1,13 +1,20 @@
 """Public client exports for the GLPI Python package.
 
-Only one client class is supported: the asynchronous
-:class:`glpi_python_client.clients.glpi_client.GlpiClient`. The legacy
-synchronous and dual-stack clients have been removed in favour of the
-async-only design described in ``update.md``.
+The package exposes two client classes:
+
+* :class:`GlpiClient` — synchronous, blocking client. The single source
+  of truth for endpoint behaviour.
+* :class:`AsyncGlpiClient` — asynchronous facade that wraps every
+  synchronous method into a coroutine via
+  :class:`~glpi_python_client.clients.commons._async_bridge.AsyncBridge`.
+
+Both classes share the same endpoint surface; pick the one matching
+your runtime model.
 """
 
 from __future__ import annotations
 
-from glpi_python_client.clients.glpi_client import GlpiClient
+from glpi_python_client.clients.async_client import AsyncGlpiClient
+from glpi_python_client.clients.sync_client import GlpiClient
 
-__all__ = ["GlpiClient"]
+__all__ = ["AsyncGlpiClient", "GlpiClient"]

glpi_python_client/clients/api/__init__.py

@@ -1,7 +1,7 @@
 """Per-endpoint API mixins backed by the ``api_schema`` Pydantic models.
 
 The mixins under this package mirror the endpoints documented in
-``docs/glpi_api_contract.json`` one for one. They wrap the asynchronous
+``docs/glpi_api_contract.json`` one for one. They wrap the Synchronous
 transport helpers from :mod:`glpi_python_client.clients.commons` and exchange
 typed ``Get<Name>``, ``Post<Name>``, ``Patch<Name>``, and ``Delete<Name>``
 models with the GLPI API.
@@ -10,31 +10,31 @@ models with the GLPI API.
 from __future__ import annotations
 
 from glpi_python_client.clients.api.administration import (
-    AsyncEntityMixin,
-    AsyncUserMixin,
+    EntityMixin,
+    UserMixin,
 )
 from glpi_python_client.clients.api.assistance import (
-    AsyncTeamMemberMixin,
-    AsyncTicketMixin,
+    TeamMemberMixin,
+    TicketMixin,
 )
 from glpi_python_client.clients.api.assistance.timeline import (
-    AsyncFollowupMixin,
-    AsyncSolutionMixin,
-    AsyncTicketTaskMixin,
-    AsyncTimelineDocumentMixin,
+    FollowupMixin,
+    SolutionMixin,
+    TicketTaskMixin,
+    TimelineDocumentMixin,
 )
-from glpi_python_client.clients.api.dropdowns import AsyncLocationMixin
-from glpi_python_client.clients.api.management import AsyncDocumentMixin
+from glpi_python_client.clients.api.dropdowns import LocationMixin
+from glpi_python_client.clients.api.management import DocumentMixin
 
 __all__ = [
-    "AsyncDocumentMixin",
-    "AsyncEntityMixin",
-    "AsyncFollowupMixin",
-    "AsyncLocationMixin",
-    "AsyncSolutionMixin",
-    "AsyncTeamMemberMixin",
-    "AsyncTicketMixin",
-    "AsyncTicketTaskMixin",
-    "AsyncTimelineDocumentMixin",
-    "AsyncUserMixin",
+    "DocumentMixin",
+    "EntityMixin",
+    "FollowupMixin",
+    "LocationMixin",
+    "SolutionMixin",
+    "TeamMemberMixin",
+    "TicketMixin",
+    "TicketTaskMixin",
+    "TimelineDocumentMixin",
+    "UserMixin",
 ]

glpi_python_client/clients/api/administration/__init__.py

@@ -1,12 +1,13 @@
-"""GLPI ``/Administration`` mixins for the asynchronous client.
+"""GLPI ``/Administration`` mixins for the Synchronous client.
 
 The submodules expose the user and entity mixins used by
-:class:`glpi_python_client.clients.glpi_client.GlpiClient`.
+:class:`glpi_python_client.clients.sync_client.GlpiClient` and
+:class:`glpi_python_client.clients.async_client.AsyncGlpiClient`.
 """
 
 from __future__ import annotations
 
-from glpi_python_client.clients.api.administration._entity import AsyncEntityMixin
-from glpi_python_client.clients.api.administration._user import AsyncUserMixin
+from glpi_python_client.clients.api.administration._entity import EntityMixin
+from glpi_python_client.clients.api.administration._user import UserMixin
 
-__all__ = ["AsyncEntityMixin", "AsyncUserMixin"]
+__all__ = ["EntityMixin", "UserMixin"]

glpi_python_client/clients/api/administration/_entity.py

@@ -1,4 +1,4 @@
-"""Asynchronous GLPI ``/Administration/Entity`` mixin.
+"""Synchronous GLPI ``/Administration/Entity`` mixin.
 
 The mixin exposes the search, fetch, create, update, and delete helpers
 for the GLPI entity resource. Entity calls intentionally bypass the
@@ -7,8 +7,10 @@ client's ``GLPI-Entity`` header so cross-entity lookups remain possible.
 
 from __future__ import annotations
 
+from collections.abc import Iterator
+
 from glpi_python_client.clients.commons._constants import ENTITY_ENDPOINT, GlpiId
-from glpi_python_client.clients.commons._transport import AsyncTransportMixin
+from glpi_python_client.clients.commons._transport import TransportMixin
 from glpi_python_client.models.api_schema.administration._entity import (
     DeleteEntity,
     GetEntity,
@@ -17,10 +19,10 @@ from glpi_python_client.models.api_schema.administration._entity import (
 )
 
 
-class AsyncEntityMixin(AsyncTransportMixin):
-    """Asynchronous CRUD helpers for ``/Administration/Entity``."""
+class EntityMixin(TransportMixin):
+    """Synchronous CRUD helpers for ``/Administration/Entity``."""
 
-    async def search_entities(
+    def search_entities(
         self,
         rsql_filter: str = "",
         *,
@@ -50,11 +52,53 @@ class AsyncEntityMixin(AsyncTransportMixin):
             params["limit"] = limit
         if rsql_filter:
             params["filter"] = rsql_filter
-        return await self._resource_list(
+        return self._resource_list(
             ENTITY_ENDPOINT, GetEntity, params=params, skip_entity=True
         )
 
-    async def get_entity(self, entity_id: GlpiId) -> GetEntity:
+    def iter_search_entities(
+        self,
+        rsql_filter: str = "",
+        *,
+        batch_size: int = 50,
+    ) -> Iterator[list[GetEntity]]:
+        """Yield successive pages of GLPI entities until exhausted.
+
+        The generator drives pagination automatically by advancing the
+        ``start`` offset after each batch. Iteration stops when the server
+        returns fewer items than ``batch_size``, which signals the last page.
+        Entity calls bypass the ``GLPI-Entity`` header so cross-entity
+        lookups remain possible.
+
+        Parameters
+        ----------
+        rsql_filter : str, optional
+            Raw RSQL filter forwarded as the ``filter`` query parameter.
+            Empty by default, which lists every accessible entity.
+        batch_size : int, optional
+            Number of records requested per page (default 50).
+
+        Yields
+        ------
+        list[GetEntity]
+            One page of entities per iteration. The last yielded batch may
+            be shorter than ``batch_size``.
+        """
+
+        start = 0
+        while True:
+            batch = self.search_entities(
+                rsql_filter,
+                limit=batch_size,
+                start=start,
+            )
+            if batch:
+                yield batch
+            if len(batch) < batch_size:
+                break
+            start += batch_size
+
+    def get_entity(self, entity_id: GlpiId) -> GetEntity:
         """Fetch one GLPI entity by identifier.
 
         Parameters
@@ -73,14 +117,14 @@ class AsyncEntityMixin(AsyncTransportMixin):
             If the GLPI server returns a non-success HTTP status.
         """
 
-        return await self._resource_get(
+        return self._resource_get(
             f"{ENTITY_ENDPOINT}/{entity_id}",
             GetEntity,
             failure_message=f"Failed to get entity {entity_id}",
             skip_entity=True,
         )
 
-    async def create_entity(self, entity: PostEntity) -> int:
+    def create_entity(self, entity: PostEntity) -> int:
         """Create one GLPI entity.
 
         Parameters
@@ -100,7 +144,7 @@ class AsyncEntityMixin(AsyncTransportMixin):
             non-success HTTP status.
         """
 
-        return await self._resource_create(
+        return self._resource_create(
             ENTITY_ENDPOINT,
             entity,
             failure_message="Failed to create entity",
@@ -109,7 +153,7 @@ class AsyncEntityMixin(AsyncTransportMixin):
             skip_entity=True,
         )
 
-    async def update_entity(self, entity_id: GlpiId, entity: PatchEntity) -> None:
+    def update_entity(self, entity_id: GlpiId, entity: PatchEntity) -> None:
         """Update one GLPI entity with a partial body.
 
         Parameters
@@ -129,16 +173,14 @@ class AsyncEntityMixin(AsyncTransportMixin):
             If the GLPI server returns a non-success HTTP status.
         """
 
-        await self._resource_update(
+        self._resource_update(
             f"{ENTITY_ENDPOINT}/{entity_id}",
             entity,
             failure_message=f"Failed to update entity {entity_id}",
             log_message=f"GLPI API updated entity {entity_id}",
         )
 
-    async def delete_entity(
-        self, entity_id: GlpiId, *, force: bool | None = None
-    ) -> None:
+    def delete_entity(self, entity_id: GlpiId, *, force: bool | None = None) -> None:
         """Delete one GLPI entity by identifier.
 
         Parameters
@@ -159,7 +201,7 @@ class AsyncEntityMixin(AsyncTransportMixin):
             If the GLPI server returns a non-success HTTP status.
         """
 
-        await self._resource_delete(
+        self._resource_delete(
             f"{ENTITY_ENDPOINT}/{entity_id}",
             failure_message=f"Failed to delete entity {entity_id}",
             log_message=f"GLPI API deleted entity {entity_id}",
@@ -169,4 +211,4 @@ class AsyncEntityMixin(AsyncTransportMixin):
         )
 
 
-__all__ = ["AsyncEntityMixin"]
+__all__ = ["EntityMixin"]

glpi_python_client/clients/api/administration/_user.py

@@ -1,15 +1,17 @@
-"""Asynchronous GLPI ``/Administration/User`` mixin.
+"""Synchronous GLPI ``/Administration/User`` mixin.
 
 The mixin exposes search, fetch, create, update, and delete helpers for the
 GLPI user resource. All operations exchange the
 :mod:`glpi_python_client.models.api_schema.administration` models and rely on
-the asynchronous transport mixin for HTTP dispatch.
+the Synchronous transport mixin for HTTP dispatch.
 """
 
 from __future__ import annotations
 
+from collections.abc import Iterator
+
 from glpi_python_client.clients.commons._constants import USER_ENDPOINT, GlpiId
-from glpi_python_client.clients.commons._transport import AsyncTransportMixin
+from glpi_python_client.clients.commons._transport import TransportMixin
 from glpi_python_client.models.api_schema.administration._user import (
     DeleteUser,
     GetUser,
@@ -18,15 +20,15 @@ from glpi_python_client.models.api_schema.administration._user import (
 )
 
 
-class AsyncUserMixin(AsyncTransportMixin):
-    """Asynchronous CRUD helpers for ``/Administration/User``.
+class UserMixin(TransportMixin):
+    """Synchronous CRUD helpers for ``/Administration/User``.
 
     The helpers follow the contract-first naming convention and forward all
     server-side validation to the GLPI API instead of duplicating checks on
     the client side.
     """
 
-    async def search_users(
+    def search_users(
         self,
         rsql_filter: str = "",
         *,
@@ -59,11 +61,56 @@ class AsyncUserMixin(AsyncTransportMixin):
         params: dict[str, object] = {"limit": limit, "start": start}
         if rsql_filter:
             params["filter"] = rsql_filter
-        return await self._resource_list(
+        return self._resource_list(
             USER_ENDPOINT, GetUser, params=params, skip_entity=skip_entity
         )
 
-    async def get_user(self, user_id: GlpiId) -> GetUser:
+    def iter_search_users(
+        self,
+        rsql_filter: str = "",
+        *,
+        batch_size: int = 50,
+        skip_entity: bool = False,
+    ) -> Iterator[list[GetUser]]:
+        """Yield successive pages of GLPI users until exhausted.
+
+        The generator drives pagination automatically by advancing the
+        ``start`` offset after each batch. Iteration stops when the server
+        returns fewer items than ``batch_size``, which signals the last page.
+
+        Parameters
+        ----------
+        rsql_filter : str, optional
+            Raw RSQL filter forwarded as the ``filter`` query parameter.
+            Empty by default, which lists every visible user.
+        batch_size : int, optional
+            Number of records requested per page (default 50).
+        skip_entity : bool, optional
+            When ``True`` the ``GLPI-Entity`` header is omitted so the
+            search spans every entity the caller has access to.
+
+        Yields
+        ------
+        list[GetUser]
+            One page of users per iteration. The last yielded batch may
+            be shorter than ``batch_size``.
+        """
+
+        start = 0
+        while True:
+            batch = self.search_users(
+                rsql_filter,
+                limit=batch_size,
+                start=start,
+                skip_entity=skip_entity,
+            )
+            if batch:
+                yield batch
+            if len(batch) < batch_size:
+                break
+            start += batch_size
+
+    def get_user(self, user_id: GlpiId) -> GetUser:
         """Fetch one GLPI user by identifier.
 
         Parameters
@@ -82,13 +129,13 @@ class AsyncUserMixin(AsyncTransportMixin):
             If the GLPI server returns a non-success HTTP status.
         """
 
-        return await self._resource_get(
+        return self._resource_get(
             f"{USER_ENDPOINT}/{user_id}",
             GetUser,
             failure_message=f"Failed to get user {user_id}",
         )
 
-    async def create_user(self, user: PostUser) -> int:
+    def create_user(self, user: PostUser) -> int:
         """Create one GLPI user.
 
         Parameters
@@ -108,7 +155,7 @@ class AsyncUserMixin(AsyncTransportMixin):
             non-success HTTP status.
         """
 
-        return await self._resource_create(
+        return self._resource_create(
             USER_ENDPOINT,
             user,
             failure_message="Failed to create user",
@@ -116,7 +163,7 @@ class AsyncUserMixin(AsyncTransportMixin):
             log_message_factory=lambda new_id: f"GLPI API created user {new_id}",
         )
 
-    async def update_user(self, user_id: GlpiId, user: PatchUser) -> None:
+    def update_user(self, user_id: GlpiId, user: PatchUser) -> None:
         """Update one GLPI user with a partial body.
 
         Parameters
@@ -136,14 +183,14 @@ class AsyncUserMixin(AsyncTransportMixin):
             If the GLPI server returns a non-success HTTP status.
         """
 
-        await self._resource_update(
+        self._resource_update(
             f"{USER_ENDPOINT}/{user_id}",
             user,
             failure_message=f"Failed to update user {user_id}",
             log_message=f"GLPI API updated user {user_id}",
         )
 
-    async def delete_user(self, user_id: GlpiId, *, force: bool | None = None) -> None:
+    def delete_user(self, user_id: GlpiId, *, force: bool | None = None) -> None:
         """Delete one GLPI user by identifier.
 
         Parameters
@@ -164,7 +211,7 @@ class AsyncUserMixin(AsyncTransportMixin):
             If the GLPI server returns a non-success HTTP status.
         """
 
-        await self._resource_delete(
+        self._resource_delete(
             f"{USER_ENDPOINT}/{user_id}",
             failure_message=f"Failed to delete user {user_id}",
             log_message=f"GLPI API deleted user {user_id}",
@@ -173,4 +220,4 @@ class AsyncUserMixin(AsyncTransportMixin):
         )
 
 
-__all__ = ["AsyncUserMixin"]
+__all__ = ["UserMixin"]

glpi_python_client/clients/api/assistance/__init__.py

@@ -1,8 +1,8 @@
-"""GLPI ``/Assistance`` mixins for the asynchronous client."""
+"""GLPI ``/Assistance`` mixins for the Synchronous client."""
 
 from __future__ import annotations
 
-from glpi_python_client.clients.api.assistance._team import AsyncTeamMemberMixin
-from glpi_python_client.clients.api.assistance._ticket import AsyncTicketMixin
+from glpi_python_client.clients.api.assistance._team import TeamMemberMixin
+from glpi_python_client.clients.api.assistance._ticket import TicketMixin
 
-__all__ = ["AsyncTeamMemberMixin", "AsyncTicketMixin"]
+__all__ = ["TeamMemberMixin", "TicketMixin"]

glpi_python_client/clients/api/assistance/_team.py

@@ -1,4 +1,4 @@
-"""Asynchronous GLPI ``/Assistance/Ticket/{id}/TeamMember`` mixin.
+"""Synchronous GLPI ``/Assistance/Ticket/{id}/TeamMember`` mixin.
 
 The team-member endpoint exposes list, add, and remove operations on a
 ticket. The mixin uses the ``api_schema`` ``TeamMember`` models and lets
@@ -16,7 +16,7 @@ from glpi_python_client.clients.commons._constants import (
 )
 from glpi_python_client.clients.commons._http import ensure_response_status
 from glpi_python_client.clients.commons._payloads import model_to_payload
-from glpi_python_client.clients.commons._transport import AsyncTransportMixin
+from glpi_python_client.clients.commons._transport import TransportMixin
 from glpi_python_client.models.api_schema.assistance._team import (
     GetTeamMember,
     PostTeamMember,
@@ -25,10 +25,10 @@ from glpi_python_client.models.api_schema.assistance._team import (
 logger = logging.getLogger(__name__)
 
 
-class AsyncTeamMemberMixin(AsyncTransportMixin):
-    """Asynchronous helpers for the ticket team-member endpoint."""
+class TeamMemberMixin(TransportMixin):
+    """Synchronous helpers for the ticket team-member endpoint."""
 
-    async def list_ticket_team_members(self, ticket_id: GlpiId) -> list[GetTeamMember]:
+    def list_ticket_team_members(self, ticket_id: GlpiId) -> list[GetTeamMember]:
         """List the team members currently linked to one ticket.
 
         Parameters
@@ -47,15 +47,13 @@ class AsyncTeamMemberMixin(AsyncTransportMixin):
             If the GLPI server returns a non-success HTTP status.
         """
 
-        return await self._resource_list(
+        return self._resource_list(
             f"{TICKET_ENDPOINT}/{ticket_id}/{TEAM_MEMBER_SUFFIX}",
             GetTeamMember,
             failure_message=f"Failed to list ticket team members for {ticket_id}",
         )
 
-    async def add_ticket_team_member(
-        self, ticket_id: GlpiId, member: PostTeamMember
-    ) -> None:
+    def add_ticket_team_member(self, ticket_id: GlpiId, member: PostTeamMember) -> None:
         """Add one team member to a ticket.
 
         Parameters
@@ -79,7 +77,7 @@ class AsyncTeamMemberMixin(AsyncTransportMixin):
         """
 
         endpoint = f"{TICKET_ENDPOINT}/{ticket_id}/{TEAM_MEMBER_SUFFIX}"
-        response = await self._post_request(endpoint, model_to_payload(member))
+        response = self._post_request(endpoint, model_to_payload(member))
         ensure_response_status(
             response,
             success_statuses=(200, 201),
@@ -87,7 +85,7 @@ class AsyncTeamMemberMixin(AsyncTransportMixin):
         )
         logger.info("GLPI API added team member on ticket %s", ticket_id)
 
-    async def remove_ticket_team_member(
+    def remove_ticket_team_member(
         self, ticket_id: GlpiId, member: PostTeamMember
     ) -> None:
         """Remove one team member from a ticket.
@@ -110,7 +108,7 @@ class AsyncTeamMemberMixin(AsyncTransportMixin):
             If the GLPI server returns a non-success HTTP status.
         """
 
-        await self._resource_delete(
+        self._resource_delete(
             f"{TICKET_ENDPOINT}/{ticket_id}/{TEAM_MEMBER_SUFFIX}",
             failure_message=f"Failed to remove team member on ticket {ticket_id}",
             log_message=f"GLPI API removed team member on ticket {ticket_id}",
@@ -118,4 +116,4 @@ class AsyncTeamMemberMixin(AsyncTransportMixin):
         )
 
 
-__all__ = ["AsyncTeamMemberMixin"]
+__all__ = ["TeamMemberMixin"]