Limited Workspace (#438)

* Added connector feed utility functions

* Check ex code

src/specklepy/api/resources/current/active_user_resource.py

@@ -11,7 +11,12 @@ from specklepy.core.api.models import (
     ResourceCollection,
     User,
 )
-from specklepy.core.api.models.current import PermissionCheckResult, Workspace
+from specklepy.core.api.models.current import (
+    LimitedWorkspace,
+    PermissionCheckResult,
+    ProjectWithPermissions,
+    Workspace,
+)
 from specklepy.core.api.resources import ActiveUserResource as CoreResource
 from specklepy.logging import metrics
 
@@ -51,6 +56,22 @@ class ActiveUserResource(CoreResource):
         metrics.track(metrics.SDK, self.account, {"name": "Active User Get Projects"})
         return super().get_projects(limit=limit, cursor=cursor, filter=filter)
 
+    def get_projects_with_permissions(
+        self,
+        *,
+        limit: int = 25,
+        cursor: Optional[str] = None,
+        filter: Optional[UserProjectsFilter] = None,
+    ) -> ResourceCollection[ProjectWithPermissions]:
+        metrics.track(
+            metrics.SDK,
+            self.account,
+            {"name": "Active User Get Projects With Permissions"},
+        )
+        return super().get_projects_with_permissions(
+            limit=limit, cursor=cursor, filter=filter
+        )
+
     def get_project_invites(self) -> List[PendingStreamCollaborator]:
         metrics.track(
             metrics.SDK, self.account, {"name": "Active User Get Project Invites"}
@@ -74,7 +95,7 @@ class ActiveUserResource(CoreResource):
         metrics.track(metrics.SDK, self.account, {"name": "Active User Get Workspaces"})
         return super().get_workspaces(limit, cursor, filter)
 
-    def get_active_workspace(self) -> Optional[Workspace]:
+    def get_active_workspace(self) -> Optional[LimitedWorkspace]:
         metrics.track(
             metrics.SDK, self.account, {"name": "Active User Get Active Workspace"}
         )

src/specklepy/api/resources/current/project_resource.py

@@ -7,7 +7,11 @@ from specklepy.core.api.inputs.project_inputs import (
     ProjectUpdateRoleInput,
     WorkspaceProjectCreateInput,
 )
-from specklepy.core.api.models import Project, ProjectWithModels, ProjectWithTeam
+from specklepy.core.api.models import (
+    Project,
+    ProjectWithModels,
+    ProjectWithTeam,
+)
 from specklepy.core.api.models.current import ProjectPermissionChecks
 from specklepy.core.api.resources import ProjectResource as CoreResource
 from specklepy.logging import metrics

src/specklepy/api/resources/current/workspace_resource.py

@@ -1,7 +1,12 @@
 from typing import Optional
 
 from specklepy.core.api.inputs.project_inputs import WorksaceProjectsFilter
-from specklepy.core.api.models.current import Project, ResourceCollection, Workspace
+from specklepy.core.api.models.current import (
+    Project,
+    ProjectWithPermissions,
+    ResourceCollection,
+    Workspace,
+)
 from specklepy.core.api.resources import WorkspaceResource as CoreResource
 from specklepy.logging import metrics
 
@@ -30,3 +35,19 @@ class WorkspaceResource(CoreResource):
     ) -> ResourceCollection[Project]:
         metrics.track(metrics.SDK, self.account, {"name": "Workspace Get Projects"})
         return super().get_projects(workspace_id, limit, cursor, filter)
+
+    def get_projects_with_permissions(
+        self,
+        workspace_id: str,
+        limit: int = 25,
+        cursor: Optional[str] = None,
+        filter: Optional[WorksaceProjectsFilter] = None,
+    ) -> ResourceCollection[ProjectWithPermissions]:
+        metrics.track(
+            metrics.SDK,
+            self.account,
+            {"name": "Workspace Get Projects With Permissions"},
+        )
+        return super().get_projects_with_permissions(
+            workspace_id, limit, cursor, filter
+        )

src/specklepy/core/api/connector_versions.py

@@ -0,0 +1,70 @@
+from datetime import datetime
+from typing import List
+
+import httpx
+from pydantic import AliasGenerator, BaseModel, ConfigDict, HttpUrl
+from pydantic.alias_generators import to_pascal
+
+
+class ConnectorFeedBaseModel(BaseModel):
+    """
+    Parent class for all Connector Feed Object Model classes
+    Sets-up a pydantic config to serialize properties using a pascal case alias
+    """
+
+    model_config = ConfigDict(
+        alias_generator=AliasGenerator(
+            validation_alias=to_pascal,
+        ),
+        populate_by_name=True,
+    )
+
+
+class ConnectorVersion(ConnectorFeedBaseModel):
+    number: str
+    url: HttpUrl
+    os: int  # this is an enum, it's properly defined in the old v2 SDK (used by Speckle.Manager.Feed)  # noqa: E501
+    architecture: int  # These are enums, they are properly defined in the old v2 SDK (used by Speckle.Manager.Feed) # noqa: E501
+    date: datetime
+    prerelease: bool
+
+
+class ConnectorVersions(ConnectorFeedBaseModel):
+    versions: List[ConnectorVersion]
+
+
+def get_latest_version(host_app_slug: str, allow_pre_release: bool) -> ConnectorVersion:
+    """
+    Fetches the JSON feed for the given connector slug and
+    Returns the latest version by date - Note, it does not consider semvers!
+
+    Arguments:
+        host_app_slug {str} -- the host app slug to query for
+        allow_pre_release {bool} -- if false, only stable releases will be considered
+    Raises:
+        HTTPStatusError: if http request failed
+        ValidationError: response was not valid json
+        ValueError: The feed contained no connector versions
+    """
+    connector_versions = get_connector_versions(host_app_slug).versions
+    filtered_versions = [
+        v for v in connector_versions if allow_pre_release or not v.prerelease
+    ]
+
+    return max(filtered_versions, key=lambda x: x.date)
+
+
+def get_connector_versions(host_app_slug: str) -> ConnectorVersions:
+    """
+    Fetches the JSON feed for the given slug (v3 feeds only)
+    Raises:
+        HTTPStatusError: if http request failed
+        ValidationError: response was not valid json
+    """
+    url = f"https://releases.speckle.dev/manager2/feeds/{host_app_slug.lower()}-v3.json"
+
+    res = httpx.get(url).raise_for_status()
+
+    feed_data = ConnectorVersions.model_validate_json(res.text)
+
+    return feed_data

src/specklepy/core/api/models/__init__.py

@@ -8,6 +8,7 @@ from specklepy.core.api.models.current import (
     ProjectCollaborator,
     ProjectCommentCollection,
     ProjectWithModels,
+    ProjectWithPermissions,
     ProjectWithTeam,
     ResourceCollection,
     ServerConfiguration,
@@ -39,6 +40,7 @@ __all__ = [
     "ModelWithVersions",
     "Project",
     "ProjectWithModels",
+    "ProjectWithPermissions",
     "ProjectWithTeam",
     "ProjectCommentCollection",
     "UserSearchResultCollection",

src/specklepy/core/api/models/current.py

@@ -176,6 +176,10 @@ class ProjectWithModels(Project):
     models: ResourceCollection[Model]
 
 
+class ProjectWithPermissions(Project):
+    permissions: ProjectPermissionChecks
+
+
 class ProjectWithTeam(Project):
     invited_team: List[PendingStreamCollaborator]
     team: List[ProjectCollaborator]
@@ -209,15 +213,18 @@ class WorkspaceCreationState(GraphQLBaseModel):
     completed: bool
 
 
-class Workspace(GraphQLBaseModel):
+class LimitedWorkspace(GraphQLBaseModel):
     id: str
     name: str
     role: Optional[str]
     slug: str
     logo: Optional[str]
+    description: Optional[str]
+
+
+class Workspace(LimitedWorkspace):
     created_at: datetime
     updated_at: datetime
     read_only: bool
-    description: Optional[str]
     creation_state: Optional[WorkspaceCreationState]
     permissions: WorkspacePermissionChecks

src/specklepy/core/api/resources/current/active_user_resource.py

@@ -13,7 +13,12 @@ from specklepy.core.api.models import (
     ResourceCollection,
     User,
 )
-from specklepy.core.api.models.current import PermissionCheckResult, Workspace
+from specklepy.core.api.models.current import (
+    LimitedWorkspace,
+    PermissionCheckResult,
+    ProjectWithPermissions,
+    Workspace,
+)
 from specklepy.core.api.resource import ResourceBase
 from specklepy.core.api.responses import DataResponse
 from specklepy.logging.exceptions import GraphQLException
@@ -291,7 +296,7 @@ class ActiveUserResource(ResourceBase):
 
         return response.data.data
 
-    def get_active_workspace(self) -> Optional[Workspace]:
+    def get_active_workspace(self) -> Optional[LimitedWorkspace]:
         """
         This feature is only available on Workspace enabled servers  (server versions
         >=2.23.17) e.g. app.speckle.systems
@@ -306,29 +311,15 @@ class ActiveUserResource(ResourceBase):
                   role
                   slug
                   logo
-                  createdAt
-                  updatedAt
-                  readOnly
                   description
-                  creationState
-                  {
-                    completed
-                  }
-                  permissions {
-                    canCreateProject {
-                      authorized
-                      code
-                      message
-                    }
-                  }
                 }
               }
             }
-            """  # noqa: E501
+            """
         )
 
         response = self.make_request_and_parse_response(
-            DataResponse[Optional[DataResponse[Optional[Workspace]]]],
+            DataResponse[Optional[DataResponse[Optional[LimitedWorkspace]]]],
             QUERY,
         )
 
@@ -338,3 +329,84 @@ class ActiveUserResource(ResourceBase):
             )
 
         return response.data.data
+
+    def get_projects_with_permissions(
+        self,
+        *,
+        limit: int = 25,
+        cursor: Optional[str] = None,
+        filter: Optional[UserProjectsFilter] = None,
+    ) -> ResourceCollection[ProjectWithPermissions]:
+        """
+        Gets the currently active user's projects with their permissions.
+        This is useful for checking what actions can be performed on each project.
+        """
+        QUERY = gql(
+            """
+          query User($limit : Int!, $cursor: String, $filter: UserProjectsFilter) {
+            data:activeUser {
+              data:projects(limit: $limit, cursor: $cursor, filter: $filter) {
+                totalCount
+                cursor
+                items {
+                    id
+                    name
+                    description
+                    visibility
+                    allowPublicComments
+                    role
+                    createdAt
+                    updatedAt
+                    sourceApps
+                    workspaceId
+                    permissions {
+                      canCreateModel {
+                        code
+                        authorized
+                        message
+                      }
+                      canDelete {
+                        code
+                        authorized
+                        message
+                      }
+                      canLoad {
+                        code
+                        authorized
+                        message
+                      }
+                      canPublish {
+                        code
+                        authorized
+                        message
+                      }
+                    }
+                }
+              }
+            }
+          }
+          """
+        )
+
+        variables = {
+            "limit": limit,
+            "cursor": cursor,
+            "filter": filter.model_dump(warnings="error", by_alias=True)
+            if filter
+            else None,
+        }
+
+        response = self.make_request_and_parse_response(
+            DataResponse[
+                Optional[DataResponse[ResourceCollection[ProjectWithPermissions]]]
+            ],
+            QUERY,
+            variables,
+        )
+
+        if response.data is None:
+            raise GraphQLException(
+                "GraphQL response indicated that the ActiveUser could not be found"
+            )
+
+        return response.data.data

src/specklepy/core/api/resources/current/project_resource.py

@@ -9,7 +9,11 @@ from specklepy.core.api.inputs.project_inputs import (
     ProjectUpdateRoleInput,
     WorkspaceProjectCreateInput,
 )
-from specklepy.core.api.models import Project, ProjectWithModels, ProjectWithTeam
+from specklepy.core.api.models import (
+    Project,
+    ProjectWithModels,
+    ProjectWithTeam,
+)
 from specklepy.core.api.models.current import ProjectPermissionChecks
 from specklepy.core.api.resource import ResourceBase
 from specklepy.core.api.responses import DataResponse

src/specklepy/core/api/resources/current/workspace_resource.py

@@ -3,7 +3,12 @@ from typing import Optional
 from gql import gql
 
 from specklepy.core.api.inputs.project_inputs import WorksaceProjectsFilter
-from specklepy.core.api.models.current import Project, ResourceCollection, Workspace
+from specklepy.core.api.models.current import (
+    Project,
+    ProjectWithPermissions,
+    ResourceCollection,
+    Workspace,
+)
 from specklepy.core.api.resource import ResourceBase
 from specklepy.core.api.responses import DataResponse
 
@@ -104,3 +109,72 @@ class WorkspaceResource(ResourceBase):
         return self.make_request_and_parse_response(
             DataResponse[DataResponse[ResourceCollection[Project]]], QUERY, variables
         ).data.data
+
+    def get_projects_with_permissions(
+        self,
+        workspace_id: str,
+        limit: int = 25,
+        cursor: Optional[str] = None,
+        filter: Optional[WorksaceProjectsFilter] = None,
+    ) -> ResourceCollection[ProjectWithPermissions]:
+        QUERY = gql(
+            """
+            query Workspace($workspaceId: String!, $limit: Int!, $cursor: String, $filter: WorkspaceProjectsFilter) {
+              data:workspace(id: $workspaceId) {
+                data:projects(limit: $limit, cursor: $cursor, filter: $filter) {
+                  cursor
+                  items {
+                    allowPublicComments
+                    createdAt
+                    description
+                    id
+                    name
+                    role
+                    sourceApps
+                    updatedAt
+                    visibility
+                    workspaceId
+                    permissions {
+                      canCreateModel {
+                        code
+                        authorized
+                        message
+                      }
+                      canDelete {
+                        code
+                        authorized
+                        message
+                      }
+                      canLoad {
+                        code
+                        authorized
+                        message
+                      }
+                      canPublish {
+                        code
+                        authorized
+                        message
+                      }
+                    }
+                  }
+                  totalCount
+                }
+              }
+            }
+            """  # noqa: E501
+        )
+
+        variables = {
+            "workspaceId": workspace_id,
+            "limit": limit,
+            "cursor": cursor,
+            "filter": filter.model_dump(warnings="error", by_alias=True)
+            if filter
+            else None,
+        }
+
+        return self.make_request_and_parse_response(
+            DataResponse[DataResponse[ResourceCollection[ProjectWithPermissions]]],
+            QUERY,
+            variables,
+        ).data.data

src/specklepy/serialization/base_object_serializer.py

@@ -199,8 +199,9 @@ class BaseObjectSerializer:
 
         # write detached or root objects to transports
         if detached and self.write_transports:
+            serialized_data = ujson.dumps(object_builder)
             for t in self.write_transports:
-                t.save_object(id=obj_id, serialized_object=ujson.dumps(object_builder))
+                t.save_object(id=obj_id, serialized_object=serialized_data)
 
         del self.lineage[-1]
 

tests/integration/client/current/test_active_user_resource_permissions.py

@@ -0,0 +1,85 @@
+import pytest
+
+from specklepy.api.client import SpeckleClient
+from specklepy.core.api.inputs.project_inputs import ProjectCreateInput
+from specklepy.core.api.inputs.user_inputs import UserProjectsFilter
+from specklepy.core.api.models.current import (
+    Project,
+    ProjectWithPermissions,
+    ResourceCollection,
+)
+
+
+@pytest.mark.run()
+class TestActiveUserResourcePermissions:
+    @pytest.fixture()
+    def test_project(self, client: SpeckleClient) -> Project:
+        project = client.project.create(
+            ProjectCreateInput(
+                name="test project for active user permissions",
+                description="test description",
+                visibility=None,
+            )
+        )
+        return project
+
+    def test_active_user_get_projects_with_permissions(
+        self, client: SpeckleClient, test_project: Project
+    ):
+        result = client.active_user.get_projects_with_permissions()
+
+        assert isinstance(result, ResourceCollection)
+        assert len(result.items) >= 1
+
+        test_project_with_permissions = None
+        for project in result.items:
+            if project.id == test_project.id:
+                test_project_with_permissions = project
+                break
+
+        assert test_project_with_permissions is not None
+        assert isinstance(test_project_with_permissions, ProjectWithPermissions)
+
+        assert hasattr(test_project_with_permissions, "permissions")
+        assert test_project_with_permissions.permissions is not None
+
+        assert test_project_with_permissions.id == test_project.id
+        assert test_project_with_permissions.name == test_project.name
+
+        permissions = test_project_with_permissions.permissions
+        assert hasattr(permissions, "can_create_model")
+        assert hasattr(permissions, "can_delete")
+        assert hasattr(permissions, "can_load")
+        assert hasattr(permissions, "can_publish")
+
+        assert permissions.can_create_model.authorized is True
+        assert permissions.can_delete.authorized is True
+        assert permissions.can_load.authorized is True
+        assert permissions.can_publish.authorized is True
+
+    def test_active_user_get_projects_with_permissions_with_filter(
+        self, client: SpeckleClient, test_project: Project
+    ):
+        """test getting active user's projects with permissions using a filter."""
+        filter = UserProjectsFilter(search=test_project.name)
+
+        result = client.active_user.get_projects_with_permissions(filter=filter)
+
+        assert isinstance(result, ResourceCollection)
+        assert len(result.items) >= 1
+        assert result.total_count >= 1
+
+        project_with_permissions = result.items[0]
+        assert isinstance(project_with_permissions, ProjectWithPermissions)
+        assert project_with_permissions.id == test_project.id
+
+        assert hasattr(project_with_permissions, "permissions")
+        assert project_with_permissions.permissions is not None
+
+    def test_active_user_projects_with_permissions_method_exists(
+        self, client: SpeckleClient
+    ):
+        """test that the method exists and is callable on active user resource."""
+        assert hasattr(client.active_user, "get_projects_with_permissions")
+        method = client.active_user.get_projects_with_permissions
+        assert callable(method)

tests/integration/client/current/test_workspace_resource_permissions.py

@@ -0,0 +1,19 @@
+import pytest
+
+from specklepy.api.client import SpeckleClient
+from specklepy.logging.exceptions import GraphQLException
+
+
+@pytest.mark.run()
+class TestWorkspaceResourcePermissions:
+    def test_get_projects_with_permissions(self, client: SpeckleClient):
+        with pytest.raises(GraphQLException):
+            client.workspace.get_projects_with_permissions("not a real id")
+
+    def test_get_projects_with_permissions_method_exists(self, client: SpeckleClient):
+        """
+        test that the method exists with the correct signature.
+        """
+        assert hasattr(client.workspace, "get_projects_with_permissions")
+        method = client.workspace.get_projects_with_permissions
+        assert callable(method)

tests/integration/test_connector_versions.py

@@ -0,0 +1,32 @@
+import pytest
+from httpx import HTTPStatusError
+
+from specklepy.core.api.connector_versions import (
+    ConnectorVersion,
+    ConnectorVersions,
+    get_connector_versions,
+    get_latest_version,
+)
+
+# NOTE: the tests in this file are testing against the live releases.speckle.dev server
+# url defined in get_connector_versions.
+
+
+def test_connector_versions():
+    res = get_connector_versions("blender")
+
+    assert isinstance(res, ConnectorVersions)
+    assert res.versions  # Assuming the feed is not empty
+
+
+def test_get_latest_version_throws_no_slug():
+    with pytest.raises(HTTPStatusError) as ex:
+        get_latest_version("non-existent-connector!", True)
+
+    assert "404" in str(ex.value)
+
+
+def test_get_latest_version():
+    res = get_latest_version("blender", False)
+
+    assert isinstance(res, ConnectorVersion)