commit before computer blows up

schloerke · schloerke · commit 44b26c719bdf · 2024-11-05T17:01:09.000-05:00
diff --git a/integration/tests/posit/connect/test_content_item_repository.py b/integration/tests/posit/connect/test_content_item_repository.py
@@ -0,0 +1,87 @@
+from posit import connect
+from posit.connect.content import ContentItem, ContentItemRepository
+
+
+class TestContentItemRepository:
+    @classmethod
+    def setup_class(cls):
+        cls.client = connect.Client()
+
+    @classmethod
+    def teardown_class(cls):
+        assert cls.client.content.count() == 0
+
+    @property
+    def content_name(self):
+        return "example"
+
+    def create_content(self) -> ContentItem:
+        return self.client.content.create(name=self.content_name)
+
+    @property
+    def repo_repository(self):
+        return "posit-dev/posit-sdk-py"
+
+    @property
+    def repo_branch(self):
+        return "1dacc4dd"
+
+    @property
+    def repo_directory(self):
+        return "integration/resources/connect/bundles/example-quarto-minimal"
+
+    @property
+    def repo_polling(self):
+        return False
+
+    @property
+    def default_repository(self):
+        return {
+            "repository": self.repo_repository,
+            "branch": self.repo_branch,
+            "directory": self.repo_directory,
+            "polling": self.repo_polling,
+        }
+
+    def test_create_get_update_delete(self):
+        content = self.create_content()
+
+        # None by default
+        print("!!!!HERE!!!!")
+        print(content)
+        print(content.repository)
+
+        assert content.repository is None
+
+        # Create
+        new_repo = content.create_repository(**self.default_repository)
+
+        # Get
+        content_repo = content.repository
+        assert content_repo is not None
+
+        def assert_repo(r: ContentItemRepository):
+            assert isinstance(content_repo, ContentItemRepository)
+            assert r["repository"] == self.repo_repository
+            assert r["branch"] == self.repo_branch
+            assert r["directory"] == self.repo_directory
+            assert r["polling"] is self.repo_polling
+
+        assert_repo(new_repo)
+        assert_repo(content_repo)
+
+        # Update
+        ex_branch = "main"
+        updated_repo = content_repo.update(branch=ex_branch)
+        assert updated_repo["branch"] == ex_branch
+
+        assert updated_repo["repository"] == self.repo_repository
+        assert updated_repo["directory"] == self.repo_directory
+        assert updated_repo["polling"] is self.repo_polling
+
+        # Delete
+        content.repository.delete()
+        assert content.repository is None
+
+        # Cleanup
+        content.delete()
diff --git a/src/posit/connect/_api.py b/src/posit/connect/_api.py
@@ -2,42 +2,39 @@
 
 import posixpath
 from abc import ABC, abstractmethod
-from typing import TYPE_CHECKING, Any, Generic, Protocol, TypeVar, cast
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any, Generic, TypeVar, cast
 
+from ._api_call import ApiCallMixin, get_api
 from ._json import Jsonifiable, JsonifiableDict, ResponseAttrs
 
 if TYPE_CHECKING:
     from .context import Context
 
+
 # Design Notes:
 # * Perform API calls on property retrieval
 # * Dictionary endpoints: Retrieve all attributes during init unless provided
 # * List endpoints: Do not retrieve until `.fetch()` is called directly. Avoids cache invalidation issues.
 # * Only expose methods needed for `ReadOnlyDict`.
 #   * Ex: When inheriting from `dict`, we'd need to shut down `update`, `pop`, etc.
 # * Use `ApiContextProtocol` to ensure that the class has the necessary attributes for API calls.
-#    * Inherit from `EndpointMixin` to add all helper methods for API calls.
+#    * Inherit from `ApiCallMixin` to add all helper methods for API calls.
 # * Classes should write the `path` only once within its init method.
 #    * Through regular interactions, the path should only be written once.
 
 
-class ApiContextProtocol(Protocol):
-    _ctx: Context
-    _path: str
-
-
 # TODO-future?; Add type hints for the ReadOnlyDict class
 # ArgsT = TypeVar("ArgsT", bound="ResponseAttrs")
 
 
 class ReadOnlyDict(
     # Generic[ArgsT],
+    Mapping,
 ):
     # _attrs: ArgsT
     _attrs: ResponseAttrs
     """Resource attributes passed."""
-    _attrs_locked: bool
-    """Semaphore for locking the resource attributes. Deters setting new attributes after initialization."""
 
     def __init__(self, attrs: ResponseAttrs) -> None:
         """
@@ -48,8 +45,10 @@ def __init__(self, attrs: ResponseAttrs) -> None:
         attrs : dict
             Resource attributes passed
         """
+        print("here!", attrs)
+        super().__init__()
+        print("mapping attrs", attrs)
         self._attrs = attrs
-        self._attrs_locked = True
 
     def get(self, key: str, default: Any = None) -> Any:
         return self._attrs.get(key, default)
@@ -58,53 +57,37 @@ def __getitem__(self, key: str) -> Any:
         return self._attrs[key]
 
     def __setitem__(self, key: str, value: Any) -> None:
-        if self._attrs_locked:
-            raise AttributeError(
-                "Resource attributes are locked. "
-                "To retrieve updated values, please retrieve the parent object again."
-            )
-        self._attrs[key] = value
-
-    def _set_attrs(self, **kwargs: Any) -> None:
-        # Unlock
-        self._attrs_locked = False
-        # Set
-        for key, value in kwargs.items():
-            self._attrs[key] = value
-        # Lock
-        self._attrs_locked = True
+        raise AttributeError(
+            "Resource attributes are locked. "
+            "To retrieve updated values, please retrieve the parent object again."
+        )
 
     def __len__(self) -> int:
         return self._attrs.__len__()
 
+    def __iter__(self):
+        return self._attrs.__iter__()
 
-class EndpointMixin(ApiContextProtocol):
-    _ctx: Context
-    """The context object containing the session and URL for API interactions."""
-    _path: str
-    """The HTTP path component for the resource endpoint."""
+    def __contains__(self, key: object) -> bool:
+        return self._attrs.__contains__(key)
 
-    def _endpoint(self, extra_endpoint: str = "") -> str:
-        return self._ctx.url + self._path + extra_endpoint
+    def __repr__(self) -> str:
+        return repr(self._attrs)
 
-    def _get_api(self, *, extra_endpoint: str = "") -> Jsonifiable:
-        response = self._ctx.session.get(self._endpoint(extra_endpoint))
-        return response.json()
+    def __str__(self) -> str:
+        return str(self._attrs)
 
-    def _delete_api(self, *, extra_endpoint: str = "") -> Jsonifiable:
-        response = self._ctx.session.get(self._endpoint(extra_endpoint))
-        return response.json()
+    def keys(self):
+        return self._attrs.keys()
 
-    def _patch_api(self, json: Jsonifiable | None, *, extra_endpoint: str = "") -> Jsonifiable:
-        response = self._ctx.session.patch(self._endpoint(extra_endpoint), json=json)
-        return response.json()
+    def values(self):
+        return self._attrs.values()
 
-    def _put_api(self, json: Jsonifiable | None, *, extra_endpoint: str = "") -> Jsonifiable:
-        response = self._ctx.session.put(self._endpoint(extra_endpoint), json=json)
-        return response.json()
+    def items(self):
+        return self._attrs.items()
 
 
-class ApiDictEndpoint(EndpointMixin, ReadOnlyDict):
+class ApiDictEndpoint(ApiCallMixin, ReadOnlyDict):
     def _get_api(self, *, extra_endpoint: str = "") -> JsonifiableDict | None:
         super()._get_api(extra_endpoint=extra_endpoint)
 
@@ -123,21 +106,26 @@ def __init__(self, *, ctx: Context, path: str, attrs: ResponseAttrs | None = Non
         attrs : dict
             Resource attributes passed
         """
-        super().__init__(attrs or {})
+        # If no attributes are provided, fetch the API and set the attributes from the response
+        print("dict attrs", attrs)
+        if attrs is None:
+            init_attrs: Jsonifiable = get_api(ctx, path)
+            attrs = cast(ResponseAttrs, init_attrs)
+            print("dict init attrs", attrs)
+
+        print("pre init")
+        print("super", super())
+        super().__init__(attrs)
+        print("post init")
         self._ctx = ctx
         self._path = path
 
-        # If attrs is None, Fetch the API and set the attributes
-        if attrs is None:
-            init_attrs = self._get_api() or {}
-            self._set_attrs(**init_attrs)
-
 
 T = TypeVar("T", bound="ReadOnlyDict")
 """A type variable that is bound to the `Active` class"""
 
 
-class ApiListEndpoint(EndpointMixin, Generic[T], ABC, object):
+class ApiListEndpoint(ApiCallMixin, Generic[T], ABC, object):
     """A tuple for any HTTP GET endpoint that returns a collection."""
 
     _data: tuple[T, ...]
diff --git a/src/posit/connect/_api_call.py b/src/posit/connect/_api_call.py
@@ -0,0 +1,47 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Protocol
+
+if TYPE_CHECKING:
+    from ._json import Jsonifiable
+    from .context import Context
+
+
+class ApiContextProtocol(Protocol):
+    _ctx: Context
+    _path: str
+
+
+def endpoint(ctx: Context, path: str, *, extra_endpoint: str = "") -> str:
+    return ctx.url + path + extra_endpoint
+
+
+def get_api(ctx: Context, path: str, *, extra_endpoint: str = "") -> Jsonifiable:
+    response = ctx.session.get(endpoint(ctx, path, extra_endpoint=extra_endpoint))
+    return response.json()
+
+
+class ApiCallMixin(ApiContextProtocol):
+    _ctx: Context
+    """The context object containing the session and URL for API interactions."""
+    _path: str
+    """The HTTP path component for the resource endpoint."""
+
+    def _endpoint(self, extra_endpoint: str = "") -> str:
+        return endpoint(self._ctx, self._path, extra_endpoint=extra_endpoint)
+
+    def _get_api(self, *, extra_endpoint: str = "") -> Jsonifiable:
+        response = self._ctx.session.get(self._endpoint(extra_endpoint))
+        return response.json()
+
+    def _delete_api(self, *, extra_endpoint: str = "") -> Jsonifiable:
+        response = self._ctx.session.get(self._endpoint(extra_endpoint))
+        return response.json()
+
+    def _patch_api(self, json: Jsonifiable | None, *, extra_endpoint: str = "") -> Jsonifiable:
+        response = self._ctx.session.patch(self._endpoint(extra_endpoint), json=json)
+        return response.json()
+
+    def _put_api(self, json: Jsonifiable | None, *, extra_endpoint: str = "") -> Jsonifiable:
+        response = self._ctx.session.put(self._endpoint(extra_endpoint), json=json)
+        return response.json()
diff --git a/src/posit/connect/content.py b/src/posit/connect/content.py
@@ -24,6 +24,7 @@
 from .bundles import Bundles
 from .context import Context
 from .env import EnvVars
+from .errors import ClientError
 from .jobs import JobsMixin
 from .oauth.associations import ContentItemAssociations
 from .permissions import Permissions
@@ -68,7 +69,7 @@ class _Attrs(TypedDict, total=False):
     def __init__(
         self,
         ctx: Context,
-        *,
+        /,
         content_guid: str,
         # By default, the attrs will be retrieved from the API.
         **attrs: Unpack[_Attrs],
@@ -88,6 +89,7 @@ def __init__(
         _assert_content_guid(content_guid)
 
         init_attrs = {"content_guid": content_guid, **attrs} if len(attrs) > 0 else None
+        print("init_attrs", init_attrs)
         super().__init__(
             ctx=ctx,
             path=f"v1/content/{content_guid}/repository",
@@ -108,7 +110,7 @@ def update(
         self,
         # *,
         **attrs: Unpack[_Attrs],
-    ) -> None:
+    ) -> ContentItemRepository:
         """Update the content's repository.
 
         Parameters
@@ -130,7 +132,12 @@ def update(
         --------
         * https://docs.posit.co/connect/api/#patch-/v1/content/-guid-/repository
         """
-        self._patch_api(cast(JsonifiableDict, dict(attrs)))
+        result = self._patch_api(cast(JsonifiableDict, dict(attrs)))
+        return ContentItemRepository(
+            self._ctx,
+            content_guid=self["content_guid"],
+            **result,  # pyright: ignore[reportCallIssue]
+        )
 
 
 class ContentItemOAuth(Resource):
@@ -169,10 +176,10 @@ def oauth(self) -> ContentItemOAuth:
 
     @property
     def repository(self) -> ContentItemRepository | None:
-        return ContentItemRepository(
-            self._ctx,
-            content_guid=self["guid"],
-        )
+        try:
+            return ContentItemRepository(self._ctx, content_guid=self["guid"])
+        except ClientError:
+            return None
 
     def create_repository(
         self,
@@ -197,9 +204,12 @@ def create_repository(
         -------
         ContentItemRepository
         """
-        response = ContentItemRepository(self._ctx, content_guid=self["guid"])._put_api(
-            cast(JsonifiableDict, attrs)
-        )
+        response = ContentItemRepository(
+            self._ctx,
+            content_guid=self["guid"],
+            # Add a placeholder `attr` to avoid a `GET` request.
+            _init=True,  # pyright: ignore[reportCallIssue]
+        )._put_api(cast(JsonifiableDict, attrs))
 
         return ContentItemRepository(
             self._ctx,
@@ -297,6 +307,7 @@ def restart(self) -> None:
     def update(
         self,
         *,
+        # TODO-barret; Reformat arguments to be similar to `ContentItemRepository._Attrs`
         # Required argument
         name: Optional[str] = None,
         # Content Metadata
@@ -417,6 +428,7 @@ def update(
             **attributes,
         }
         url = self.params.url + f"v1/content/{self['guid']}"
+        # TODO-barret; Remove `drop_none`
         response = self.params.session.patch(url, json=drop_none(args))
         super().update(**response.json())
 
diff --git a/tests/posit/connect/test_api_endpoint.py b/tests/posit/connect/test_api_endpoint.py
diff --git a/tests/posit/connect/test_content.py b/tests/posit/connect/test_content.py
