discogs-sdk 0.1.0__py3-none-any.whl

discogs_sdk/_async/_resource.py

@@ -0,0 +1,92 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import TYPE_CHECKING, Any, TypeVar
+
+import httpx
+from pydantic import BaseModel
+
+if TYPE_CHECKING:
+    from discogs_sdk._async._client import AsyncDiscogs
+
+_M = TypeVar("_M", bound=BaseModel)
+
+
+class AsyncAPIResource:
+    def __init__(self, client: AsyncDiscogs) -> None:
+        self._client = client
+
+    def _parse_list_response(self, response: httpx.Response, model_cls: type[_M], items_key: str) -> list[_M]:
+        """Parse JSON, raise on error, return validated list from a keyed array."""
+        data = response.json()
+        self._client._maybe_raise(response.status_code, data, retry_after=response.headers.get("Retry-After"))
+        return [model_cls.model_validate(item) for item in data.get(items_key, [])]
+
+    def _parse_response(self, response: httpx.Response, model_cls: type[_M]) -> _M:
+        """Parse JSON, raise on error, return validated model."""
+        data = response.json()
+        self._client._maybe_raise(response.status_code, data, retry_after=response.headers.get("Retry-After"))
+        return model_cls.model_validate(data)
+
+    def _raise_for_error(self, response: httpx.Response) -> None:
+        """Raise on error for void methods (delete, update returning None)."""
+        if response.status_code >= 400:
+            body = response.json() if response.content else {}
+            self._client._maybe_raise(response.status_code, body, retry_after=response.headers.get("Retry-After"))
+
+    async def _delete(self, path: str) -> httpx.Response:
+        return await self._request("DELETE", path)
+
+    async def _get(self, path: str, *, params: dict[str, Any] | None = None) -> httpx.Response:
+        return await self._request("GET", path, params=params)
+
+    async def _get_binary(self, path: str) -> bytes:
+        response = await self._client._send("GET", self._client._build_url(path))
+        self._client._maybe_raise(
+            response.status_code,
+            response.text,
+            retry_after=response.headers.get("Retry-After"),
+        )
+        return response.content
+
+    async def _post(
+        self,
+        path: str,
+        *,
+        json: dict[str, Any] | None = None,
+        params: dict[str, Any] | None = None,
+    ) -> httpx.Response:
+        return await self._request("POST", path, json=json, params=params)
+
+    async def _post_file(self, path: str, *, file_path: str) -> httpx.Response:
+        p = Path(file_path)
+        data = p.read_bytes()
+        return await self._client._send(
+            "POST",
+            self._client._build_url(path),
+            files={"upload": (p.name, data, "text/csv")},
+        )
+
+    async def _put(
+        self,
+        path: str,
+        *,
+        json: dict[str, Any] | None = None,
+        params: dict[str, Any] | None = None,
+    ) -> httpx.Response:
+        return await self._request("PUT", path, json=json, params=params)
+
+    async def _request(
+        self,
+        method: str,
+        path: str,
+        *,
+        json: dict[str, Any] | None = None,
+        params: dict[str, Any] | None = None,
+    ) -> httpx.Response:
+        return await self._client._send(
+            method,
+            self._client._build_url(path),
+            json=json,
+            params=params,
+        )

discogs_sdk/_async/resources/__init__.py

@@ -0,0 +1,75 @@
+from discogs_sdk._async.resources.artists import ArtistReleases, Artists
+from discogs_sdk._async.resources.collection import (
+    Collection,
+    CollectionFields,
+    CollectionFolders,
+    CollectionReleases,
+    CollectionValueResource,
+    FolderReleases,
+)
+from discogs_sdk._async.resources.exports import Exports
+from discogs_sdk._async.resources.labels import LabelReleases, Labels
+from discogs_sdk._async.resources.lists import Lists, UserLists
+from discogs_sdk._async.resources.marketplace import (
+    Marketplace,
+    MarketplaceFee,
+    MarketplaceListings,
+    MarketplaceOrders,
+    OrderMessages,
+)
+from discogs_sdk._async.resources.masters import Masters, MasterVersions
+from discogs_sdk._async.resources.releases import (
+    ReleaseMarketplaceStats,
+    ReleasePriceSuggestions,
+    ReleaseRating,
+    ReleaseStatsResource,
+    Releases,
+)
+from discogs_sdk._async.resources.search import SearchResource
+from discogs_sdk._async.resources.uploads import Uploads
+from discogs_sdk._async.resources.users import (
+    UserContributions,
+    UserInventory,
+    UserNamespace,
+    Users,
+    UserSubmissions,
+    UserUpdate,
+)
+from discogs_sdk._async.resources.wantlist import Wantlist
+
+__all__ = [
+    "ArtistReleases",
+    "Artists",
+    "Collection",
+    "CollectionFields",
+    "CollectionFolders",
+    "CollectionReleases",
+    "CollectionValueResource",
+    "Exports",
+    "FolderReleases",
+    "LabelReleases",
+    "Labels",
+    "Lists",
+    "Marketplace",
+    "MarketplaceFee",
+    "MarketplaceListings",
+    "MarketplaceOrders",
+    "Masters",
+    "MasterVersions",
+    "OrderMessages",
+    "ReleasePriceSuggestions",
+    "ReleaseMarketplaceStats",
+    "ReleaseRating",
+    "ReleaseStatsResource",
+    "Releases",
+    "SearchResource",
+    "Uploads",
+    "UserContributions",
+    "UserInventory",
+    "UserLists",
+    "UserNamespace",
+    "Users",
+    "UserSubmissions",
+    "UserUpdate",
+    "Wantlist",
+]

discogs_sdk/_async/resources/artists.py

@@ -0,0 +1,39 @@
+from __future__ import annotations
+
+from discogs_sdk._async._lazy import AsyncLazyResource
+from discogs_sdk._async._paginator import AsyncPage
+from discogs_sdk._async._resource import AsyncAPIResource
+from discogs_sdk.models.artist import Artist, ArtistRelease
+
+
+class ArtistReleases(AsyncAPIResource):
+    def __init__(self, client, artist_id: int) -> None:
+        super().__init__(client)
+        self._artist_id = artist_id
+
+    def list(
+        self,
+        *,
+        sort: str | None = None,
+        sort_order: str | None = None,
+    ) -> AsyncPage[ArtistRelease]:
+        params = {k: v for k, v in {"sort": sort, "sort_order": sort_order}.items() if v}
+        return AsyncPage(
+            client=self._client,
+            path=f"/artists/{self._artist_id}/releases",
+            params=params,
+            model_cls=ArtistRelease,
+            items_key="releases",
+        )
+
+
+class Artists(AsyncAPIResource):
+    def get(self, artist_id: int) -> AsyncLazyResource:
+        return AsyncLazyResource(
+            client=self._client,
+            path=f"/artists/{artist_id}",
+            model_cls=Artist,
+            sub_resources={
+                "releases": lambda: ArtistReleases(self._client, artist_id),
+            },
+        )

discogs_sdk/_async/resources/collection.py

@@ -0,0 +1,248 @@
+from __future__ import annotations
+
+import builtins
+from functools import cached_property
+from typing import TYPE_CHECKING, Any
+
+from discogs_sdk._async._lazy import AsyncLazyResource
+from discogs_sdk._async._paginator import AsyncPage
+from discogs_sdk._async._resource import AsyncAPIResource
+from discogs_sdk.models.collection import (
+    CollectionField,
+    CollectionFolder,
+    CollectionItem,
+    CollectionValue_,
+)
+
+if TYPE_CHECKING:
+    from discogs_sdk._async._client import AsyncDiscogs
+
+
+# --- Deep chaining: folder -> releases -> instances -> fields ---
+
+
+class InstanceFields(AsyncAPIResource):
+    """Edit a custom field value on a specific instance."""
+
+    def __init__(self, client, username: str, folder_id: int, release_id: int, instance_id: int) -> None:
+        super().__init__(client)
+        self._username = username
+        self._folder_id = folder_id
+        self._release_id = release_id
+        self._instance_id = instance_id
+
+    async def update(self, field_id: int, *, value: str) -> None:
+        response = await self._post(
+            f"/users/{self._username}/collection/folders/{self._folder_id}"
+            f"/releases/{self._release_id}/instances/{self._instance_id}/fields/{field_id}",
+            json={"value": value},
+        )
+        self._raise_for_error(response)
+
+
+class InstanceRef:
+    """Lightweight ref that captures instance_id for field editing."""
+
+    def __init__(self, client: AsyncDiscogs, username: str, folder_id: int, release_id: int, instance_id: int) -> None:
+        self._client = client
+        self._username = username
+        self._folder_id = folder_id
+        self._release_id = release_id
+        self._instance_id = instance_id
+
+    @cached_property
+    def fields(self) -> InstanceFields:
+        return InstanceFields(self._client, self._username, self._folder_id, self._release_id, self._instance_id)
+
+
+class CollectionInstances(AsyncAPIResource):
+    """Manage instances of a release within a folder."""
+
+    def __init__(self, client, username: str, folder_id: int, release_id: int) -> None:
+        super().__init__(client)
+        self._username = username
+        self._folder_id = folder_id
+        self._release_id = release_id
+
+    def _base_path(self) -> str:
+        return f"/users/{self._username}/collection/folders/{self._folder_id}/releases/{self._release_id}/instances"
+
+    def get(self, instance_id: int) -> InstanceRef:
+        return InstanceRef(self._client, self._username, self._folder_id, self._release_id, instance_id)
+
+    async def delete(self, instance_id: int) -> None:
+        response = await self._delete(f"{self._base_path()}/{instance_id}")
+        self._raise_for_error(response)
+
+    async def update(self, instance_id: int, **kwargs: Any) -> None:
+        response = await self._post(f"{self._base_path()}/{instance_id}", json=kwargs)
+        self._raise_for_error(response)
+
+
+class FolderReleaseRef:
+    """Lightweight ref for a release within a folder — provides .instances accessor."""
+
+    def __init__(self, client: AsyncDiscogs, username: str, folder_id: int, release_id: int) -> None:
+        self._client = client
+        self._username = username
+        self._folder_id = folder_id
+        self._release_id = release_id
+
+    @cached_property
+    def instances(self) -> CollectionInstances:
+        return CollectionInstances(self._client, self._username, self._folder_id, self._release_id)
+
+
+class FolderReleases(AsyncAPIResource):
+    """Items in a collection folder."""
+
+    def __init__(self, client, username: str, folder_id: int) -> None:
+        super().__init__(client)
+        self._username = username
+        self._folder_id = folder_id
+
+    def _base_path(self) -> str:
+        return f"/users/{self._username}/collection/folders/{self._folder_id}/releases"
+
+    def get(self, release_id: int) -> FolderReleaseRef:
+        return FolderReleaseRef(self._client, self._username, self._folder_id, release_id)
+
+    def list(
+        self,
+        *,
+        sort: str | None = None,
+        sort_order: str | None = None,
+    ) -> AsyncPage[CollectionItem]:
+        params = {k: v for k, v in {"sort": sort, "sort_order": sort_order}.items() if v}
+        return AsyncPage(
+            client=self._client,
+            items_key="releases",
+            model_cls=CollectionItem,
+            params=params,
+            path=self._base_path(),
+        )
+
+    async def create(self, *, release_id: int) -> None:
+        response = await self._post(f"{self._base_path()}/{release_id}")
+        self._raise_for_error(response)
+
+
+# --- Collection Folders ---
+
+
+class CollectionFolders(AsyncAPIResource):
+    def __init__(self, client, username: str) -> None:
+        super().__init__(client)
+        self._username = username
+
+    def _base_path(self) -> str:
+        return f"/users/{self._username}/collection/folders"
+
+    def get(self, folder_id: int) -> AsyncLazyResource:
+        return AsyncLazyResource(
+            client=self._client,
+            path=f"{self._base_path()}/{folder_id}",
+            model_cls=CollectionFolder,
+            sub_resources={
+                "releases": lambda: FolderReleases(self._client, self._username, folder_id),
+            },
+        )
+
+    async def list(self) -> builtins.list[CollectionFolder]:
+        response = await self._get(self._base_path())
+        return self._parse_list_response(response, CollectionFolder, "folders")
+
+    async def create(self, *, name: str) -> CollectionFolder:
+        response = await self._post(self._base_path(), json={"name": name})
+        return self._parse_response(response, CollectionFolder)
+
+    async def delete(self, folder_id: int) -> None:
+        response = await self._delete(f"{self._base_path()}/{folder_id}")
+        self._raise_for_error(response)
+
+    async def update(self, folder_id: int, *, name: str) -> CollectionFolder:
+        response = await self._post(f"{self._base_path()}/{folder_id}", json={"name": name})
+        return self._parse_response(response, CollectionFolder)
+
+
+# --- Collection Releases (cross-folder) ---
+
+
+class CollectionReleaseRef:
+    """Ref for a release across all folders. Provides .list() for instances."""
+
+    def __init__(self, client: AsyncDiscogs, username: str, release_id: int) -> None:
+        self._client = client
+        self._username = username
+        self._release_id = release_id
+
+    def list(self) -> AsyncPage[CollectionItem]:
+        return AsyncPage(
+            client=self._client,
+            items_key="releases",
+            model_cls=CollectionItem,
+            path=f"/users/{self._username}/collection/releases/{self._release_id}",
+        )
+
+
+class CollectionReleases(AsyncAPIResource):
+    def __init__(self, client, username: str) -> None:
+        super().__init__(client)
+        self._username = username
+
+    def get(self, release_id: int) -> CollectionReleaseRef:
+        return CollectionReleaseRef(self._client, self._username, release_id)
+
+
+# --- Collection Fields ---
+
+
+class CollectionFields(AsyncAPIResource):
+    def __init__(self, client, username: str) -> None:
+        super().__init__(client)
+        self._username = username
+
+    async def list(self) -> builtins.list[CollectionField]:
+        response = await self._get(f"/users/{self._username}/collection/fields")
+        return self._parse_list_response(response, CollectionField, "fields")
+
+
+# --- Collection Value ---
+
+
+class CollectionValueResource(AsyncAPIResource):
+    def __init__(self, client, username: str) -> None:
+        super().__init__(client)
+        self._username = username
+
+    def get(self) -> AsyncLazyResource:
+        return AsyncLazyResource(
+            client=self._client,
+            model_cls=CollectionValue_,
+            path=f"/users/{self._username}/collection/value",
+        )
+
+
+# --- Collection namespace ---
+
+
+class Collection:
+    def __init__(self, client: AsyncDiscogs, username: str) -> None:
+        self._client = client
+        self._username = username
+
+    @cached_property
+    def fields(self) -> CollectionFields:
+        return CollectionFields(self._client, self._username)
+
+    @cached_property
+    def folders(self) -> CollectionFolders:
+        return CollectionFolders(self._client, self._username)
+
+    @cached_property
+    def releases(self) -> CollectionReleases:
+        return CollectionReleases(self._client, self._username)
+
+    @cached_property
+    def value(self) -> CollectionValueResource:
+        return CollectionValueResource(self._client, self._username)

discogs_sdk/_async/resources/exports.py

@@ -0,0 +1,30 @@
+from __future__ import annotations
+
+from discogs_sdk._async._lazy import AsyncLazyResource
+from discogs_sdk._async._paginator import AsyncPage
+from discogs_sdk._async._resource import AsyncAPIResource
+from discogs_sdk.models.export import Export
+
+
+class Exports(AsyncAPIResource):
+    def get(self, export_id: int) -> AsyncLazyResource:
+        return AsyncLazyResource(
+            client=self._client,
+            model_cls=Export,
+            path=f"/inventory/export/{export_id}",
+        )
+
+    def list(self) -> AsyncPage[Export]:
+        return AsyncPage(
+            client=self._client,
+            items_key="items",
+            model_cls=Export,
+            path="/inventory/export",
+        )
+
+    async def download(self, export_id: int) -> bytes:
+        return await self._get_binary(f"/inventory/export/{export_id}/download")
+
+    async def request(self) -> None:
+        response = await self._post("/inventory/export")
+        self._raise_for_error(response)

discogs_sdk/_async/resources/labels.py

@@ -0,0 +1,32 @@
+from __future__ import annotations
+
+from discogs_sdk._async._lazy import AsyncLazyResource
+from discogs_sdk._async._paginator import AsyncPage
+from discogs_sdk._async._resource import AsyncAPIResource
+from discogs_sdk.models.label import Label, LabelRelease
+
+
+class LabelReleases(AsyncAPIResource):
+    def __init__(self, client, label_id: int) -> None:
+        super().__init__(client)
+        self._label_id = label_id
+
+    def list(self) -> AsyncPage[LabelRelease]:
+        return AsyncPage(
+            client=self._client,
+            items_key="releases",
+            model_cls=LabelRelease,
+            path=f"/labels/{self._label_id}/releases",
+        )
+
+
+class Labels(AsyncAPIResource):
+    def get(self, label_id: int) -> AsyncLazyResource:
+        return AsyncLazyResource(
+            client=self._client,
+            model_cls=Label,
+            path=f"/labels/{label_id}",
+            sub_resources={
+                "releases": lambda: LabelReleases(self._client, label_id),
+            },
+        )

discogs_sdk/_async/resources/lists.py

@@ -0,0 +1,33 @@
+from __future__ import annotations
+
+from discogs_sdk._async._lazy import AsyncLazyResource
+from discogs_sdk._async._paginator import AsyncPage
+from discogs_sdk._async._resource import AsyncAPIResource
+from discogs_sdk.models.list_ import List_, ListSummary
+
+
+class UserLists(AsyncAPIResource):
+    """User's lists: GET /users/{username}/lists (paginated)."""
+
+    def __init__(self, client, username: str) -> None:
+        super().__init__(client)
+        self._username = username
+
+    def list(self) -> AsyncPage[ListSummary]:
+        return AsyncPage(
+            client=self._client,
+            items_key="lists",
+            model_cls=ListSummary,
+            path=f"/users/{self._username}/lists",
+        )
+
+
+class Lists(AsyncAPIResource):
+    """Top-level list access: GET /lists/{id}."""
+
+    def get(self, list_id: int) -> AsyncLazyResource:
+        return AsyncLazyResource(
+            client=self._client,
+            model_cls=List_,
+            path=f"/lists/{list_id}",
+        )

discogs_sdk/_async/resources/marketplace.py

@@ -0,0 +1,122 @@
+from __future__ import annotations
+
+from functools import cached_property
+from typing import TYPE_CHECKING, Any
+
+from discogs_sdk.models._common import Condition, CurrencyCode
+
+from discogs_sdk._async._lazy import AsyncLazyResource
+from discogs_sdk._async._paginator import AsyncPage
+from discogs_sdk._async._resource import AsyncAPIResource
+from discogs_sdk.models.marketplace import Fee, Listing, Order, OrderMessage
+
+if TYPE_CHECKING:
+    from discogs_sdk._async._client import AsyncDiscogs
+
+
+class OrderMessages(AsyncAPIResource):
+    def __init__(self, client, order_id: str) -> None:
+        super().__init__(client)
+        self._order_id = order_id
+
+    def list(self) -> AsyncPage[OrderMessage]:
+        return AsyncPage(
+            client=self._client,
+            items_key="messages",
+            model_cls=OrderMessage,
+            path=f"/marketplace/orders/{self._order_id}/messages",
+        )
+
+    async def create(self, *, message: str | None = None, status: str | None = None) -> OrderMessage:
+        body = {k: v for k, v in {"message": message, "status": status}.items() if v is not None}
+        response = await self._post(
+            f"/marketplace/orders/{self._order_id}/messages",
+            json=body,
+        )
+        return self._parse_response(response, OrderMessage)
+
+
+class MarketplaceOrders(AsyncAPIResource):
+    def get(self, order_id: str) -> AsyncLazyResource:
+        return AsyncLazyResource(
+            client=self._client,
+            model_cls=Order,
+            path=f"/marketplace/orders/{order_id}",
+            sub_resources={
+                "messages": lambda: OrderMessages(self._client, order_id),
+            },
+        )
+
+    def list(
+        self,
+        *,
+        status: str | None = None,
+        sort: str | None = None,
+        sort_order: str | None = None,
+    ) -> AsyncPage[Order]:
+        params = {k: v for k, v in {"status": status, "sort": sort, "sort_order": sort_order}.items() if v}
+        return AsyncPage(
+            client=self._client,
+            items_key="orders",
+            model_cls=Order,
+            params=params,
+            path="/marketplace/orders",
+        )
+
+    async def update(self, order_id: str, **kwargs: Any) -> Order:
+        response = await self._post(f"/marketplace/orders/{order_id}", json=kwargs)
+        return self._parse_response(response, Order)
+
+
+class MarketplaceListings(AsyncAPIResource):
+    def get(self, listing_id: int) -> AsyncLazyResource:
+        return AsyncLazyResource(
+            client=self._client,
+            model_cls=Listing,
+            path=f"/marketplace/listings/{listing_id}",
+        )
+
+    async def create(
+        self, *, release_id: int, condition: Condition, price: float, status: str = "For Sale", **kwargs: Any
+    ) -> Listing:
+        body = {"release_id": release_id, "condition": condition, "price": price, "status": status, **kwargs}
+        response = await self._post("/marketplace/listings", json=body)
+        return self._parse_response(response, Listing)
+
+    async def update(self, listing_id: int, **kwargs: Any) -> None:
+        response = await self._post(f"/marketplace/listings/{listing_id}", json=kwargs)
+        self._raise_for_error(response)
+
+    async def delete(self, listing_id: int) -> None:
+        response = await self._delete(f"/marketplace/listings/{listing_id}")
+        self._raise_for_error(response)
+
+
+class MarketplaceFee(AsyncAPIResource):
+    def get(self, *, price: float, currency: CurrencyCode | None = None) -> AsyncLazyResource:
+        if currency:
+            path = f"/marketplace/fee/{price}/{currency}"
+        else:
+            path = f"/marketplace/fee/{price}"
+        return AsyncLazyResource(
+            client=self._client,
+            model_cls=Fee,
+            path=path,
+        )
+
+
+class Marketplace:
+    def __init__(self, client: AsyncDiscogs) -> None:
+        self._client = client
+
+    @cached_property
+    def fee(self) -> MarketplaceFee:
+        return MarketplaceFee(self._client)
+
+    @cached_property
+    def listings(self) -> MarketplaceListings:
+        return MarketplaceListings(self._client)
+
+    @cached_property
+    def orders(self) -> MarketplaceOrders:
+        return MarketplaceOrders(self._client)