dataroom-client 1.0.6.post79.dev0__tar.gz → 1.0.6.post149.dev0__tar.gz

{dataroom_client-1.0.6.post79.dev0 → dataroom_client-1.0.6.post149.dev0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dataroom-client
-Version: 1.0.6.post79.dev0
+Version: 1.0.6.post149.dev0
 Summary: A python client to interface with the Dataroom backend API
 Author: Ales Kocjancic
 Author-email: hi@ales.io

{dataroom_client-1.0.6.post79.dev0 → dataroom_client-1.0.6.post149.dev0}/dataroom_client/client.py

@@ -353,6 +353,9 @@ class DataRoomClient:
         datasets__all: list = None,
         datasets__ne_all: list = None,
         datasets__empty: bool = None,
+        group_ids: list[str] = None,
+        roles: list[str] = None,
+        group_type: str = None,
     ) -> list[dict]:
         """
         Retrieves a paginated list of images, with optional filtering and field selection.
@@ -437,6 +440,9 @@ class DataRoomClient:
                     "datasets__all": ",".join(datasets__all) if datasets__all else None,
                     "datasets__ne_all": ",".join(datasets__ne_all) if datasets__ne_all else None,
                     "datasets__empty": datasets__empty,
+                    "group_ids": ",".join(group_ids) if group_ids else None,
+                    "roles": ",".join(roles) if roles else None,
+                    "group_type": group_type,
                 }
             ),
             headers=headers,
@@ -1799,6 +1805,199 @@ class DataRoomClient:
             method="DELETE",
         )
 
+    # ------------------------------------------------------------------
+    # Roles, GroupTypes, Groups + memberships
+    #
+    # Setup flow when starting from an empty DB:
+    #   1. ``create_role(name)`` for each allowed role
+    #   2. ``create_group_type(name, roles=[{role, is_required}, ...])``
+    #      with admin credentials
+    #   3. ``create_group(name, type=...)`` then ``replace_group(...)`` to
+    #      attach memberships
+    # All four (Roles, GroupTypes, Groups, Memberships) are open to any
+    # token-authenticated dataroom user.
+    # Group ids are plain UUIDs in Postgres; the type is its own column.
+    # Membership rows carry a canonical role plus free-form metadata.
+    # ------------------------------------------------------------------
+    async def get_roles(self, limit: int = 1000) -> list[dict]:
+        """Lists all roles."""
+        return await self._make_paginated_request(url="roles/", limit=limit)
+
+    async def create_role(self, name: str, description: str = None) -> dict:
+        """Creates a role. Roles are referenced by name from GroupTypeRole rows."""
+        payload = self._dict_filter_none({"name": name, "description": description})
+        return await self._make_request(url="roles/", method="POST", json=payload)
+
+    async def delete_role(self, name: str) -> None:
+        """Deletes a role. Fails if any GroupTypeRole still references it."""
+        return await self._make_request(url=f"roles/{name}/", method="DELETE")
+
+    async def get_group_types(self, limit: int = 1000) -> list[dict]:
+        """Lists all GroupTypes with their (role, is_required) pairs."""
+        return await self._make_paginated_request(url="group-types/", limit=limit)
+
+    async def get_group_type(self, name: str) -> dict:
+        """Retrieves a single GroupType by name."""
+        return await self._make_request(url=f"group-types/{name}/", method="GET")
+
+    async def create_group_type(
+        self,
+        name: str,
+        roles: list[dict] = None,
+        description: str = None,
+        metadata_schema: dict = None,
+    ) -> dict:
+        """Creates a GroupType.
+
+        @param name: lowercase alphanumeric/underscore; doubles as the OS-encoding
+                     prefix (``<name>::<uuid>``).
+        @param roles: list of ``{"role": <existing role name>, "is_required": bool}``.
+                      Roles must already exist — create them with ``create_role`` first.
+        @param description: optional free-form description.
+        @param metadata_schema: JSON Schema applied to ``Group.metadata`` for groups
+                                of this type.
+        """
+        payload = self._dict_filter_none({
+            "name": name,
+            "description": description,
+            "metadata_schema": metadata_schema,
+            "roles": roles,
+        })
+        return await self._make_request(url="group-types/", method="POST", json=payload)
+
+    # No update_group_type: GroupTypes are immutable. A type's name is baked
+    # into the OS encoding of its groups and its schema/roles gate their
+    # validation, so the server rejects PUT/PATCH on group-types. Create a new
+    # type (and migrate) instead.
+
+    async def delete_group_type(self, name: str) -> None:
+        """Deletes a GroupType. Fails if any Group of this type exists."""
+        return await self._make_request(url=f"group-types/{name}/", method="DELETE")
+
+    async def get_groups(
+        self,
+        type: str = None,
+        search: str = None,
+        limit: int = 1000,
+    ) -> list[dict]:
+        """
+        Lists groups, optionally filtered by type or text search on name/id.
+
+        @param type: Optional group type filter (a GroupType.name).
+        @param search: Optional substring search over name and id.
+        @param limit: Maximum number of groups to return.
+        @return: List of group dicts.
+        """
+        params = self._dict_filter_none({"type": type, "search": search})
+        return await self._make_paginated_request(url="groups/", params=params, limit=limit)
+
+    async def get_group(self, group_id: str, include_members: bool = False) -> dict:
+        """
+        Retrieves a single group by id.
+
+        @param group_id: Group UUID.
+        @param include_members: When True, also fetch the group's memberships
+            (a second request to the members endpoint, which is paginated and
+            not part of the group representation) and attach them under a
+            ``members`` key as ``[{image_id, role, metadata}, ...]`` — the
+            shape ``upsert_group`` accepts, so a fetched group round-trips
+            without silently dropping members.
+        @return: Group dict (with ``members`` when ``include_members``).
+        """
+        group = await self._make_request(url=f"groups/{group_id}/", method="GET")
+        if include_members:
+            group["members"] = [
+                {"image_id": m["image_id"], "role": m["role"], "metadata": m.get("metadata", {})}
+                for m in await self.get_group_members(group_id)
+            ]
+        return group
+
+    async def update_group(
+        self,
+        group_id: str,
+        name: str = None,
+        description: str = None,
+        metadata: dict = None,
+        cover_image_id: str = None,
+    ) -> dict:
+        """
+        Partially updates a group. The `type` is immutable and cannot be changed.
+
+        @param group_id: Group UUID.
+        @return: Updated group dict.
+        """
+        payload = self._dict_filter_none({
+            "name": name,
+            "description": description,
+            "metadata": metadata,
+            "cover_image_id": cover_image_id,
+        })
+        return await self._make_request(
+            url=f"groups/{group_id}/",
+            method="PATCH",
+            json=payload,
+        )
+
+    async def delete_group(self, group_id: str) -> None:
+        """
+        Soft-deletes a group and queues the OS scrub. The Postgres row is
+        finalized by the reconciler once OS is clean.
+        """
+        return await self._make_request(url=f"groups/{group_id}/", method="DELETE")
+
+    async def get_group_members(self, group_id: str, limit: int = 1000) -> list[dict]:
+        """
+        Lists memberships of a group.
+
+        @return: List of {id, image_id, role, metadata, ...}.
+        """
+        return await self._make_paginated_request(url=f"groups/{group_id}/members/", limit=limit)
+
+    async def upsert_group(
+        self,
+        name: str,
+        type: str,
+        metadata: dict = None,
+        members: list[dict] = None,
+        description: str = None,
+        cover_image_id: str = None,
+        group_id: str = None,
+    ) -> dict:
+        """Create-or-replace a group by name. One PUT round-trip in the common case.
+
+        Re-running the same call with the same ``name`` is idempotent: the client
+        looks up an existing group with that name (or uses the explicit ``group_id``
+        when supplied), and PUTs the whole ``{metadata, members}`` payload to its
+        UUID. New groups get a fresh UUID4 generated client-side and committed via
+        the same PUT. The server validates roles + metadata in one transaction.
+        """
+        import uuid as _uuid
+
+        if group_id is None:
+            matches = [g for g in await self.get_groups(search=name) if g['name'] == name]
+            group_id = matches[0]['id'] if matches else str(_uuid.uuid4())
+
+        payload = self._dict_filter_none({
+            "name": name,
+            "type": type,
+            "metadata": metadata if metadata is not None else {},
+            "members": members if members is not None else [],
+            "description": description,
+            "cover_image_id": cover_image_id,
+        })
+        return await self._make_request(
+            url=f"groups/{group_id}/",
+            method="PUT",
+            json=payload,
+        )
+
+    async def get_image_groups(self, image_id: str) -> list[dict]:
+        """
+        Lists all (non-deleted) groups this image is a member of, hydrated.
+
+        Each item: {group: {...}, role, metadata}.
+        """
+        return await self._make_request(url=f"images/{image_id}/groups/", method="GET")
 
 
 class AsyncRunner:

{dataroom_client-1.0.6.post79.dev0 → dataroom_client-1.0.6.post149.dev0}/pyproject.toml

@@ -6,7 +6,7 @@ authors = [
 ]
 readme = "README.md"
 dynamic = []
-version = "1.0.6.post79.dev0"
+version = "1.0.6.post149.dev0"
 
 [tool.poetry]