FE2 API Updates

pyproject.toml

@@ -29,6 +29,7 @@ httpx = "^0.25.0"
 black = "23.11.0"
 isort = "^5.7.0"
 pytest = "^7.1.3"
+pytest-asyncio = "^0.23.0"
 pytest-ordering = "^0.6"
 pytest-cov = "^3.0.0"
 devtools = "^0.8.0"

src/specklepy/api/client.py

@@ -2,11 +2,16 @@
 
 from specklepy.api.credentials import Account
 from specklepy.api.resources import (
-    active_user,
+    ActiveUserResource,
+    ModelResource,
+    OtherUserResource,
+    ProjectInviteResource,
+    ProjectResource,
+    SubscriptionResource,
+    VersionResource,
     branch,
     commit,
     object,
-    other_user,
     server,
     stream,
     subscriptions,
@@ -67,24 +72,57 @@ def _init_resources(self) -> None:
         self.server = server.Resource(
             account=self.account, basepath=self.url, client=self.httpclient
         )
+
         server_version = None
         try:
             server_version = self.server.version()
         except Exception:
             pass
-        self.user = user.Resource(
+
+        self.other_user = OtherUserResource(
+            account=self.account,
+            basepath=self.url,
+            client=self.httpclient,
+            server_version=server_version,
+        )
+        self.active_user = ActiveUserResource(
+            account=self.account,
+            basepath=self.url,
+            client=self.httpclient,
+            server_version=server_version,
+        )
+        self.project = ProjectResource(
+            account=self.account,
+            basepath=self.url,
+            client=self.httpclient,
+            server_version=server_version,
+        )
+        self.project_invite = ProjectInviteResource(
+            account=self.account,
+            basepath=self.url,
+            client=self.httpclient,
+            server_version=server_version,
+        )
+        self.model = ModelResource(
             account=self.account,
             basepath=self.url,
             client=self.httpclient,
             server_version=server_version,
         )
-        self.other_user = other_user.Resource(
+        self.version = VersionResource(
             account=self.account,
             basepath=self.url,
             client=self.httpclient,
             server_version=server_version,
         )
-        self.active_user = active_user.Resource(
+        self.subscription = SubscriptionResource(
+            account=self.account,
+            basepath=self.ws_url,
+            client=self.wsclient,
+            # todo: why doesn't this take a server version
+        )
+        # Deprecated Resources
+        self.user = user.Resource(
             account=self.account,
             basepath=self.url,
             client=self.httpclient,

src/specklepy/api/resources/__init__.py

@@ -1,9 +1,41 @@
-import pkgutil
-import sys
-from importlib import import_module
+from specklepy.api.resources.current.active_user_resource import ActiveUserResource
+from specklepy.api.resources.current.model_resource import ModelResource
+from specklepy.api.resources.current.other_user_resource import OtherUserResource
+from specklepy.api.resources.current.project_invite_resource import (
+    ProjectInviteResource,
+)
+from specklepy.api.resources.current.project_resource import ProjectResource
+from specklepy.api.resources.current.server_resource import ServerResource
+from specklepy.api.resources.current.subscription_resource import SubscriptionResource
+from specklepy.api.resources.current.version_resource import VersionResource
+from specklepy.api.resources.deprecated import (
+    active_user,
+    branch,
+    commit,
+    object,
+    other_user,
+    server,
+    stream,
+    subscriptions,
+    user,
+)
 
-for _, name, _ in pkgutil.iter_modules(__path__):
-    imported_module = import_module("." + name, package=__name__)
-
-    if hasattr(imported_module, "Resource"):
-        setattr(sys.modules[__name__], name, imported_module)
+__all__ = [
+    "ActiveUserResource",
+    "ModelResource",
+    "OtherUserResource",
+    "ProjectInviteResource",
+    "ProjectResource",
+    "ServerResource",
+    "SubscriptionResource",
+    "VersionResource",
+    "active_user",
+    "branch",
+    "commit",
+    "object",
+    "other_user",
+    "server",
+    "stream",
+    "subscriptions",
+    "user",
+]

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

@@ -1,12 +1,25 @@
 from datetime import datetime
-from typing import List, Optional
-
-from specklepy.api.models import PendingStreamCollaborator, User
-from specklepy.core.api.resources.active_user import Resource as CoreResource
+from typing import List, Optional, overload
+
+from deprecated import deprecated
+
+from specklepy.core.api.inputs.project_inputs import UserProjectsFilter
+from specklepy.core.api.inputs.user_inputs import UserUpdateInput
+from specklepy.core.api.models import (
+    PendingStreamCollaborator,
+    Project,
+    ResourceCollection,
+    User,
+)
+from specklepy.core.api.models.deprecated import (
+    FE1_DEPRECATION_REASON,
+    FE1_DEPRECATION_VERSION,
+)
+from specklepy.core.api.resources import ActiveUserResource as CoreResource
 from specklepy.logging import metrics
 
 
-class Resource(CoreResource):
+class ActiveUserResource(CoreResource):
     """API Access class for users. This class provides methods to get and update
     the user profile, fetch user activity, and manage pending stream invitations."""
 
@@ -19,37 +32,64 @@
         )
         self.schema = User
 
-    def get(self) -> User:
-        """Gets the profile of the current authenticated user's profile
-        (as extracted from the authorization header).
-
-        Returns:
-            User -- the retrieved user
-        """
-        metrics.track(metrics.SDK, custom_props={"name": "User Active Get"})
+    def get(self) -> Optional[User]:
+        metrics.track(metrics.SDK, self.account, {"name": "Active User Get"})
         return super().get()
 
+    @deprecated("Use UserUpdateInput overload", version=FE1_DEPRECATION_VERSION)
+    @overload
     def update(
         self,
         name: Optional[str] = None,
         company: Optional[str] = None,
         bio: Optional[str] = None,
         avatar: Optional[str] = None,
-    ):
-        """Updates your user profile. All arguments are optional.
+    ) -> User:
+        ...
 
-        Args:
-            name (Optional[str]): The user's name.
-            company (Optional[str]): The company the user works for.
-            bio (Optional[str]): A brief user biography.
-            avatar (Optional[str]): A URL to an avatar image for the user.
+    @overload
+    def update(self, *, input: UserUpdateInput) -> User:
+        ...
 
-        Returns    @deprecated(version=DEPRECATION_VERSION, reason=DEPRECATION_TEXT):
-            bool -- True if your profile was updated successfully
-        """
-        metrics.track(metrics.SDK, self.account, {"name": "User Active Update"})
-        return super().update(name, company, bio, avatar)
+    def update(
+        self,
+        name: Optional[str] = None,
+        company: Optional[str] = None,
+        bio: Optional[str] = None,
+        avatar: Optional[str] = None,
+        *,
+        input: Optional[UserUpdateInput] = None,
+    ) -> User:
+        metrics.track(metrics.SDK, self.account, {"name": "Active User Update"})
+        if isinstance(input, UserUpdateInput):
+            return super()._update(input=input)
+        else:
+            return super()._update(
+                input=UserUpdateInput(
+                    name=name,
+                    company=company,
+                    bio=bio,
+                    avatar=avatar,
+                )
+            )
+
+    def get_projects(
+        self,
+        *,
+        limit: int = 25,
+        cursor: Optional[str] = None,
+        filter: Optional[UserProjectsFilter] = None,
+    ) -> ResourceCollection[Project]:
+        metrics.track(metrics.SDK, self.account, {"name": "Active User Get Projects"})
+        return super().get_projects(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"}
+        )
+        return super().get_project_invites()
 
+    @deprecated(reason=FE1_DEPRECATION_REASON, version=FE1_DEPRECATION_VERSION)
     def activity(
         self,
         limit: int = 20,
@@ -78,6 +118,7 @@
         metrics.track(metrics.SDK, self.account, {"name": "User Active Activity"})
         return super().activity(limit, action_type, before, after, cursor)
 
+    @deprecated(reason=FE1_DEPRECATION_REASON, version=FE1_DEPRECATION_VERSION)
     def get_all_pending_invites(self) -> List[PendingStreamCollaborator]:
         """Fetches all of the current user's pending stream invitations.
 
@@ -89,6 +130,7 @@
         )
         return super().get_all_pending_invites()
 
+    @deprecated(reason=FE1_DEPRECATION_REASON, version=FE1_DEPRECATION_VERSION)
     def get_pending_invite(
         self, stream_id: str, token: Optional[str] = None
     ) -> Optional[PendingStreamCollaborator]:

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

@@ -0,0 +1,74 @@
+from typing import Optional
+
+from specklepy.core.api.inputs.model_inputs import (
+    CreateModelInput,
+    DeleteModelInput,
+    ModelVersionsFilter,
+    UpdateModelInput,
+)
+from specklepy.core.api.inputs.project_inputs import ProjectModelsFilter
+from specklepy.core.api.models import Model, ModelWithVersions, ResourceCollection
+from specklepy.core.api.resources import ModelResource as CoreResource
+from specklepy.logging import metrics
+
+
+class ModelResource(CoreResource):
+    """API Access class for models"""
+
+    def __init__(self, account, basepath, client, server_version) -> None:
+        super().__init__(
+            account=account,
+            basepath=basepath,
+            client=client,
+            server_version=server_version,
+        )
+
+    def get(self, model_id: str, project_id: str) -> Model:
+        metrics.track(metrics.SDK, self.account, {"name": "Model Get"})
+        return super().get(model_id, project_id)
+
+    def get_with_versions(
+        self,
+        model_id: str,
+        project_id: str,
+        *,
+        versions_limit: int = 25,
+        versions_cursor: Optional[str] = None,
+        versions_filter: Optional[ModelVersionsFilter] = None,
+    ) -> ModelWithVersions:
+        metrics.track(metrics.SDK, self.account, {"name": "Model Get With Versions"})
+        return super().get_with_versions(
+            model_id,
+            project_id,
+            versions_limit=versions_limit,
+            versions_cursor=versions_cursor,
+            versions_filter=versions_filter,
+        )
+
+    def get_models(
+        self,
+        project_id: str,
+        *,
+        models_limit: int = 25,
+        models_cursor: Optional[str] = None,
+        models_filter: Optional[ProjectModelsFilter] = None,
+    ) -> ResourceCollection[Model]:
+        metrics.track(metrics.SDK, self.account, {"name": "Model Get Models"})
+        return super().get_models(
+            project_id,
+            models_limit=models_limit,
+            models_cursor=models_cursor,
+            models_filter=models_filter,
+        )
+
+    def create(self, input: CreateModelInput) -> Model:
+        metrics.track(metrics.SDK, self.account, {"name": "Model Create"})
+        return super().create(input)
+
+    def delete(self, input: DeleteModelInput) -> bool:
+        metrics.track(metrics.SDK, self.account, {"name": "Model Delete"})
+        return super().delete(input)
+
+    def update(self, input: UpdateModelInput) -> Model:
+        metrics.track(metrics.SDK, self.account, {"name": "Model Update"})
+        return super().update(input)