widen-client 0.0.15__py3-none-any.whl

widen_client/__init__.py

@@ -0,0 +1,19 @@
+"""
+widen-client public API
+"""
+
+from .client import Widen, WidenClient
+from .entities.assets import Assets
+from .entities.metadata import Metadata
+from .entities.uploads import Uploads
+
+
+__all__ = [
+    'Widen',
+    'WidenClient',
+    'Assets',
+    'Metadata',
+    'Uploads',
+]
+
+__version__ = '0.0.15'

widen_client/baseapi.py

@@ -0,0 +1,52 @@
+from urllib.parse import urlencode
+
+
+class BaseApi:
+    """
+    A base class to build paths and a baseline CRUD interface for an entity set.
+    """
+
+    def __init__(self, client):
+        super().__init__()
+        self._client = client
+
+        if not self.endpoint:
+            raise NotImplementedError('self.endpoint must be set when subclassing this class.')
+
+    def _build_path(self, key=None, endpoint=None, property=None, queryparams=None, *args, **kwargs):
+        """
+        Build path to endpoint, including support for key lookup of a single entity.
+        """
+        endpoint = endpoint or self.endpoint
+
+        if key:
+            endpoint += f'/{key}'
+
+        if property:
+            endpoint += f'/{property}'
+
+        if queryparams:
+            endpoint += f'?{urlencode(queryparams)}'
+
+        return endpoint
+
+    def get(self, key, property=None, queryparams=None):
+        """
+        Get an entity. e.g. GET /path/to/endpoint/key
+        """
+        response_json, _ = self._client._get(self._build_path(key=key, property=property, queryparams=queryparams))
+        return response_json
+
+    def exists(self, key, queryparams=None):
+        """
+        Check if an entity exists.
+        """
+        from . import WidenError
+        from requests.exceptions import RequestException
+
+        try:
+            _, status_code = self._client._get(self._build_path(key=key, queryparams=queryparams))
+        except (WidenError, RequestException) as exception:
+            return False
+        else:
+            return status_code == 200

widen_client/client.py

@@ -0,0 +1,382 @@
+import functools
+from http.client import responses
+import logging
+from itertools import takewhile
+from urllib.parse import urljoin
+import uuid
+
+import requests
+from requests.adapters import HTTPAdapter
+from urllib3 import Retry
+
+from widen_client.entities.assets import Assets
+from widen_client.entities.metadata import Metadata
+from widen_client.entities.uploads import Uploads
+
+
+logger = logging.getLogger(__name__)
+
+
+class CustomRetry(Retry):
+    def get_backoff_time(self):
+        """Formula for computing the current backoff
+
+        :rtype: float
+        """
+        # We want to consider only the last consecutive errors sequence (Ignore redirects).
+        consecutive_errors_len = len(
+            list(
+                takewhile(lambda x: x.redirect_location is None, reversed(self.history))
+            )
+        )
+        if consecutive_errors_len <= 1:
+            return 0
+
+        backoff_value = self.backoff_factor * (2 ** consecutive_errors_len)
+        return min(self.BACKOFF_MAX, backoff_value)
+
+
+class WidenError(Exception):
+    def __init__(self, message, request_info=None):
+        self.request_info = request_info
+        super().__init__(message)
+
+
+class WidenAttributeError(Exception):
+    pass
+
+
+def _get_error_data_from_response(response):
+    """
+    Construct a dictionary with error data from a >= 400 level response
+    """
+    try:
+        error_data = response.json()
+    except ValueError:
+        # in case of a 500 error, the response might not be a JSON
+        error_data = {'response': response}
+
+    error_data.update({
+        key: value
+        for key, value in response.headers.items()
+        if key.startswith('X-Ratelimit')
+    })
+    return error_data
+
+
+def _enabled_or_noop(fn):
+    @functools.wraps(fn)
+    def wrapper(self, *args, **kwargs):
+        if self.enabled:
+            return fn(self, *args, **kwargs)
+        return {}, 503
+    return wrapper
+
+
+class WidenClient:
+    """
+    Low-level client for interfacing with Widen v2 API.
+
+    This client layer is responsible for authenticating, handling constructing/making requests, logging API calls,
+    and catching request/connection exceptions, and catching/raising some select REST responses (4xx+, 204, etc.)
+
+    Documentation: https://widenv2.docs.apiary.io/#
+    """
+
+    def __init__(
+            self,
+            enabled=True,
+            access_token=None,
+            timeout=60,
+            retries_after_server_error=0,
+            backoff_factor=1.0,
+            request_hooks=None,
+            request_headers=None
+    ):
+        """
+        Create a session and setup access token in request header.
+
+        :param enabled: Whether the client should execute any requests
+        :param access_token: Widen access token
+        :param timeout: (optional) Seconds to wait for the server to send data before timing out (default to 60)
+        :param retries_after_server_error: (optional) Number of times to retry request after receiving a server error.
+            The error statuses that will be retried are:
+                - 429 (Too Many Requests)
+                - 502 (Bad Gateway)
+                - 504 (Gateway Timeout)
+        response (defaults to 0, which is to not retry)
+        :param backoff_factor: (optional) A backoff factor to apply between attempts after the second try, following the
+        formula: {backoff factor} * (2 ** ({number of total retries} - 1))
+        :param request_hooks: (optional) Hooks for :py:func:`requests.requests`.
+        :param request_headers: (optional) Headers for :py:func:`requests.requests`.
+        """
+
+        super(WidenClient).__init__()
+        self.enabled = enabled
+        self.base_url = f'https://api.widencollective.com/v2/'
+        self.timeout = timeout
+
+        self.request_headers = request_headers or requests.utils.default_headers()
+        self.request_hooks = request_hooks or requests.hooks.default_hooks()
+
+        self.session = self._get_session(
+            access_token=access_token,
+            retries_after_server_error=retries_after_server_error,
+            backoff_factor=backoff_factor
+        )
+
+        self.widen_api_request_correlation_id = uuid.uuid4()
+
+    def _get_session(self, access_token=None, retries_after_server_error=0, backoff_factor=1.0):
+        """
+        Create a session and setup access token in request header.
+
+        :param access_token: Widen API Access Token
+        :param retries_after_server_error: (optional) Number of times to retry request after receiving a server error.
+            The error statuses that will be retried are:
+                - 429 (Too Many Requests)
+                - 502 (Bad Gateway)
+                - 504 (Gateway Timeout)
+        :param backoff_factor: (optional) A backoff factor to apply between attempts after the second try, following the
+        formula: {backoff factor} * (2 ** ({number of total retries} - 1))
+        """
+        session = requests.Session()
+        session.encoding = 'utf8'
+        session.headers.update({
+            'Authorization': f'Bearer {access_token}',
+        })
+
+        if retries_after_server_error:
+            retry_strategy = CustomRetry(
+                total=retries_after_server_error,
+                backoff_factor=backoff_factor,
+                status_forcelist=[429, 502, 504],
+                method_whitelist=['HEAD', 'GET', 'POST', 'PUT', 'DELETE' 'OPTIONS']
+            )
+
+            adapter = HTTPAdapter(max_retries=retry_strategy)
+            session.mount("https://", adapter)
+
+        return session
+
+    @_enabled_or_noop
+    def _get(self, url):
+        """
+        Handle authenticated GET requests
+
+        :param url: The url for the endpoint including path parameters
+        :return: The JSON output from the API and status code
+        """
+
+        url = urljoin(self.base_url, url)
+        try:
+            response = self._make_request(**dict(
+                method='GET',
+                url=url,
+                timeout=self.timeout,
+                hooks=self.request_hooks,
+                headers=self.request_headers
+            ))
+        except requests.exceptions.RequestException as exception:
+            raise exception
+        except requests.exceptions.ReadTimeout as exception:
+            request_info = {
+                'method': 'PUT',
+                'url': url,
+            }
+            raise WidenError(_get_error_data_from_response(exception.response), request_info=request_info)
+        else:
+            if response.status_code >= 400:
+                request_info = {
+                    'method': 'GET',
+                    'url': url,
+                }
+                raise WidenError(_get_error_data_from_response(response), request_info=request_info)
+
+            if response.status_code == 204:
+                return {}, response.status_code
+
+            return response.json(), response.status_code
+
+    @_enabled_or_noop
+    def _post(self, url, data=None, files=None):
+        """
+        Handle authenticated POST requests
+
+        :param url: The url for the endpoint including path parameters
+        :param data: The request body parameters
+        :return: The JSON output from the API and status code
+        """
+        url = urljoin(self.base_url, url)
+        post_params = {
+            'method': 'POST',
+            'url': url,
+            'files': files,
+            'timeout': self.timeout,
+            'hooks': self.request_hooks,
+            'headers': self.request_headers
+        }
+
+        if files:
+            post_params.update({'data': data})
+        else:
+            self.session.headers.update({'Content-Type': 'application/json'})
+            post_params.update({'json': data})
+        try:
+            response = self._make_request(**post_params)
+        except requests.exceptions.RequestException as exception:
+            raise exception
+        except requests.exceptions.ReadTimeout as exception:
+            request_info = {
+                'method': 'PUT',
+                'url': url,
+                'json': data,
+            }
+            raise WidenError(_get_error_data_from_response(exception.response), request_info=request_info)
+        else:
+            if response.status_code >= 400:
+                request_info = {
+                    'method': 'POST',
+                    'url': url,
+                    'files': files,
+                }
+
+                # No need to include file data for exception capturing.
+                if not files:
+                    request_info.update({'json': data})
+
+                raise WidenError(_get_error_data_from_response(response), request_info=request_info)
+
+            if response.status_code == 204:
+                return {}, response.status_code
+
+            return response.json(), response.status_code
+
+    def _make_request(self, **kwargs):
+        logger.info(
+            f'Request to Widen API [{self.widen_api_request_correlation_id}]: '
+            f'{kwargs.get("method")} {kwargs.get("url")}'
+        )
+
+        if kwargs.get('json'):
+            logger.info(f'Request to Widen API [{self.widen_api_request_correlation_id}]: {kwargs.get("json")}')
+
+        response = self.session.request(**kwargs)
+
+        if response.status_code >= 400:
+            error_data = _get_error_data_from_response(response)
+            logger.info(
+                f'Response from Widen API [{self.widen_api_request_correlation_id}]: '
+                f'{response.status_code} {responses[response.status_code]}: {error_data}'
+            )
+        else:
+            logger.info(
+                f'Response from Widen API [{self.widen_api_request_correlation_id}]: '
+                f'{response.status_code} {responses[response.status_code]}'
+            )
+
+        # Once the request is finished it set a new correlation id
+        self.widen_api_request_correlation_id = uuid.uuid4()
+
+        return response
+
+    @_enabled_or_noop
+    def _put(self, url, data=None):
+        """
+        Handle authenticated PUT requests
+
+        :param url: The url for the endpoint including path parameters
+        :param data: The request body parameters
+        :return: The JSON output from the API and status code
+        """
+        url = urljoin(self.base_url, url)
+        self.session.headers.update({'Content-Type': 'application/json'})
+
+        try:
+            response = self._make_request(**dict(
+                method='PUT',
+                url=url,
+                json=data,
+                timeout=self.timeout,
+                hooks=self.request_hooks,
+                headers=self.request_headers
+            ))
+        except requests.exceptions.RequestException as exception:
+            raise exception
+        except requests.exceptions.ReadTimeout as exception:
+            request_info = {
+                'method': 'PUT',
+                'url': url,
+                'json': data,
+            }
+            raise WidenError(_get_error_data_from_response(exception.response), request_info=request_info)
+        else:
+            if response.status_code >= 400:
+                request_info = {
+                    'method': 'PUT',
+                    'url': url,
+                    'json': data,
+                }
+                raise WidenError(_get_error_data_from_response(response), request_info=request_info)
+
+            if response.status_code == 204:
+                return {}, response.status_code
+
+            return response.json(), response.status_code
+
+    @_enabled_or_noop
+    def _delete(self, url):
+        """
+        Handle authenticated DELETE requests.
+
+        :param url: The url for the endpoint including path parameters
+        :return: The JSON output from the API and status code
+        """
+
+        url = urljoin(self.base_url, url)
+
+        try:
+            response = self._make_request(**dict(
+                method='DELETE',
+                url=url,
+                timeout=self.timeout,
+                hooks=self.request_hooks,
+                headers=self.request_headers
+            ))
+        except requests.exceptions.RequestException as exception:
+            raise exception
+        except requests.exceptions.ReadTimeout as exception:
+            request_info = {
+                'method': 'PUT',
+                'url': url,
+            }
+            raise WidenError(_get_error_data_from_response(exception.response), request_info=request_info)
+        else:
+            if response.status_code >= 400:
+                request_info = {
+                    'method': 'DELETE',
+                    'url': url,
+                }
+                raise WidenError(_get_error_data_from_response(response), request_info=request_info)
+
+            if response.status_code == 204:
+                return {}, response.status_code
+
+            return response.json(), response.status_code
+
+
+class Widen(WidenClient):
+    """
+    Widen class for interfacing with Widen v2 API
+    """
+
+    def __init__(self, *args, **kwargs):
+        """
+        Initialize client class and attach all available entity endpoints
+        """
+
+        super().__init__(*args, **kwargs)
+
+        self.assets = Assets(self)
+        self.uploads = Uploads(self)
+        self.metadata = Metadata(self)

widen_client/entities/assets.py

@@ -0,0 +1,113 @@
+from ..baseapi import BaseApi
+
+
+class Assets(BaseApi):
+    def __init__(self, *args, **kwargs):
+        """
+        Initialize the endpoint.
+        """
+        self.endpoint = 'assets'
+        super().__init__(*args, **kwargs)
+
+    def list_asset_groups(self) -> dict:
+        """
+        List asset groups.
+        """
+        response_json, _ = self._client._get(self._build_path(property='assetgroups'))
+        return response_json
+
+    def search(self, querystring: str, queryparams: dict = None) -> dict:
+        """
+        List entities by search query. `querystring` parameter takes the quick search syntax documented here:
+        https://community.widen.com/collective/s/article/How-do-I-search-for-assets
+        """
+        if not queryparams:
+            queryparams = {}
+
+        queryparams.update({
+            'query': querystring,
+            'scroll': True,
+        })
+
+        response_json, _ = self._client._get(self._build_path(property='search', queryparams=queryparams))
+
+        if self._client.enabled:
+            if response_json['scroll_id']:
+                for items in self._scroll(response_json['scroll_id'], expand=queryparams.get('expand', '')):
+                    response_json['items'].extend(items)
+
+        return response_json
+
+    def _scroll(self, scroll_id: str, expand: str) -> list:
+        """
+        Fetch all remaining scroll results for a given response, returning an iterator with the results.
+        """
+        queryparams = {
+            'scroll_id': scroll_id,
+            'expand': expand,
+        }
+
+        result, _ = self._client._get(self._build_path(property='search/scroll', queryparams=queryparams))
+
+        if self._client.enabled:
+            items = result['items']
+
+            while items:
+                yield result['items']
+                result, _ = self._client._get(self._build_path(property='search/scroll', queryparams=queryparams))
+                items = result['items']
+        else:
+            return []
+
+    def get_metadata(self, key: str) -> dict:
+        """
+        Get metadata for an asset.
+        """
+        response_json, _ = self._client._get(self._build_path(key=key, property='metadata'))
+        return response_json
+
+    def update_metadata(self, key: str, metadata: dict) -> dict:
+        """
+        Update metadata for an asset. Only keys passed will be updated.
+        """
+        patch = {
+            'patch': ','.join(metadata['fields'].keys())
+        }
+
+        response_json, _ = self._client._put(self._build_path(key=key, property='metadata', queryparams=patch), metadata)
+        return response_json
+
+    def get_security(self, key: str) -> dict:
+        """
+        Get security for an asset.
+        """
+        response_json, _ = self._client._get(self._build_path(key=key, property='security'))
+        return response_json
+
+    def update_security(self, key: str, security: dict) -> dict:
+        """
+        Update security for an asset. Only keys passed will be updated.
+        """
+        patch = {
+            'patch': ','.join(security.keys()),
+        }
+
+        response_json, _ = self._client._put(self._build_path(key=key, property='security', queryparams=patch), security)
+        return response_json
+
+    def rename(self, key: str, filename: str) -> dict:
+        """
+        Renames an assets's filename.
+        """
+        response_json, _ = self._client._put(
+            self._build_path(key=key, property='filename'),
+            {'filename': filename}
+        )
+        return response_json
+
+    def delete(self, key: str) -> dict:
+        """
+        Delete an asset.
+        """
+        response_json, _ = self._client._delete(self._build_path(key=key))
+        return response_json

widen_client/entities/metadata.py

@@ -0,0 +1,134 @@
+from urllib.parse import quote
+
+from ..baseapi import BaseApi
+
+
+class Metadata(BaseApi):
+    def __init__(self, *args, **kwargs):
+        """
+        Initialize the endpoint.
+        """
+        self.endpoint = 'metadata'
+        super().__init__(*args, **kwargs)
+
+    def get(self, *args, **kwargs):
+        """
+        Get an entity. e.g. GET /path/to/endpoint/key
+        """
+        # Getting metadata not supported, use list/get_controlled_vocabulary instead
+        from .. import WidenAttributeError
+        raise WidenAttributeError
+
+    def exists(self, *args, **kwargs):
+        """
+        Check if an entity exists.
+        """
+        # Checking if metadata exists not supported, use get_controlled_vocabulary instead
+        from .. import WidenAttributeError
+        raise WidenAttributeError
+
+    def get_viewable_fields(self, field_types: str = 'all', display_name_after: str = None, display_name_starts_with: str = None, limit: int = 100) -> dict:
+        """
+        List all metadata fields that you have permission to see.
+
+        :param field_types: The field type that you want to query.
+        :param display_name_after: A filter that only returns metadata fields with display names alphabetically greater than this value.
+        :param display_name_starts_with: A filter that only returns metadata fields with display names that start with this value.
+        :param limit: The max number of metadata fields returned by this query. Must be between 1 and 100.
+        """
+        queryparams = {'field_types': field_types}
+
+        if display_name_after is not None:
+            queryparams.update({'display_name_after': display_name_after})
+        if display_name_starts_with is not None:
+            queryparams.update({'display_name_starts_with': display_name_starts_with})
+        if limit is not None:
+            queryparams.update({'limit': limit})
+
+        response_json, _ = self._client._get(self._build_path(property='fields/viewable'))
+        return response_json
+
+    def list_controlled_vocabulary_values(self, display_key: str) -> dict:
+        """
+        List all values from the controlled vocabulary for a metadata field.
+
+        :param display_key: Display key of the controlled vocabulary metadata field.
+        """
+        response_json, _ = self._client._get(self._build_path(property=f'{display_key}/vocabulary'))
+        return response_json
+
+    def add_controlled_vocabulary_value(self, display_key: str, value: str, index: int = None) -> dict:
+        """
+        Add a new value to the controlled vocabulary for a metadata field.
+
+        :param display_key: Display key of the controlled vocabulary metadata field.
+        :param value: The new controlled vocabulary value you wish to add.
+        :param index: Optional index of where to insert the new controlled vocabulary value. If omitted, the new value will be added to the end of the list
+        """
+        data = {'value': value}
+
+        if index is not None:
+            data.update({'index': index})
+
+        response_json, _ = self._client._post(self._build_path(property=f'{display_key}/vocabulary'), data=data)
+        return response_json
+
+    def get_controlled_vocabulary_value(self, display_key: str, existing_value: str) -> dict:
+        """
+        Get the existing value from the controlled vocabulary for a metadata field.
+        :param display_key: Display key of the controlled vocabulary metadata field.
+        :param existing_value: The controlled vocabulary value.
+        """
+        existing_value = quote(existing_value, safe='')  # encode possible slashes in vocabulary value
+        response_json, _ = self._client._get(self._build_path(property=f'{display_key}/vocabulary/{existing_value}'))
+        return response_json
+
+    def get_controlled_vocabulary_value_exists(self, display_key: str, value: str) -> bool:
+        """
+        Check if value exists as a controlled vocabulary for a metadata field.
+        :param display_key: Display key of the controlled vocabulary metadata field.
+        :param value: The controlled vocabulary value.
+        """
+        from .. import WidenError
+        from requests.exceptions import RequestException
+
+        value = quote(value, safe='')  # encode possible slashes in vocabulary value
+
+        try:
+            _, status_code = self._client._get(self._build_path(property=f'{display_key}/vocabulary/{value}'))
+        except (WidenError, RequestException):
+            return False
+        else:
+            return status_code == 200
+
+    def update_controlled_vocabulary_value(self, display_key: str, existing_value: str, value: str = None, index: int = None) -> dict:
+        """
+        Update an existing value from the controlled vocabulary for a metadata field.
+
+        :param display_key: Display key of the controlled vocabulary metadata field.
+        :param existing_value: The controlled vocabulary value you wish to update.
+        :param value: Optional new display name for this controlled vocabulary value. Either value, index, or both must be provided.
+        :param index: Optional index of where to re-order the updated controlled vocabulary value. Either value, index, or both must be provided.
+        """
+        data = {}
+
+        if value is None and index is None:
+            raise ValueError('Either value, index, or both must be provided.')
+        if value is not None:
+            data.update({'value': value})
+        if index is not None:
+            data.update({'index': index})
+
+        existing_value = quote(existing_value, safe='')  # encode possible slashes in vocabulary value
+        response_json, _ = self._client._put(self._build_path(property=f'{display_key}/vocabulary/{existing_value}'), data=data)
+        return response_json
+
+    def delete_controlled_vocabulary_value(self, display_key: str, existing_value: str) -> dict:
+        """
+        Delete an existing value from the controlled vocabulary for a metadata field.
+        :param display_key: Display key of the controlled vocabulary metadata field.
+        :param existing_value: The controlled vocabulary value you wish to delete.
+        """
+        existing_value = quote(existing_value, safe='')  # encode possible slashes in vocabulary value
+        response_json, _ = self._client._delete(self._build_path(property=f'{display_key}/vocabulary/{existing_value}'))
+        return response_json

widen_client/entities/uploads.py

@@ -0,0 +1,39 @@
+from typing import BinaryIO
+
+from ..baseapi import BaseApi
+
+
+class Uploads(BaseApi):
+    def __init__(self, *args, **kwargs):
+        """
+        Initialize the endpoint.
+        """
+        self.endpoint = 'uploads'
+        super().__init__(*args, **kwargs)
+
+    def list_profiles(self):
+        """
+        List profiles.
+        """
+        response_json, _ = self._client._get(self._build_path(property='profiles'))
+        return response_json
+
+    def upload_asset(self, profile: str, file: BinaryIO, filename: str) -> dict:
+        """
+        Uploads a new asset.
+
+        :param profile: Upload Profile Name.
+        :param file: Optional binary file for upload. Either the file, the url parameter, or the file id must be provided with this call.
+        :param filename: Filename (overrides name of MIME file).
+        """
+        post_data = {
+            'profile': profile,
+            'filename': filename,
+        }
+
+        files = {
+            'file': file,
+        }
+
+        response_json, _ = self._client._post(self._build_path(), post_data, files)
+        return response_json

widen_client-0.0.15.dist-info/METADATA

@@ -0,0 +1,67 @@
+Metadata-Version: 2.4
+Name: widen-client
+Version: 0.0.15
+Summary: Python client for interacting with Widen v2 API
+Author-email: Gagosian Gallery Engineering <engineering@gagosian.com>
+License: UNLICENSED
+        
+Project-URL: Homepage, https://github.com/gagosian/widen-client
+Project-URL: Repository, https://github.com/gagosian/widen-client
+Keywords: widen,dam,rest,client,wrapper
+Classifier: Environment :: Web Environment
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Topic :: Internet :: WWW/HTTP
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests>=2.32.5
+Dynamic: license-file
+
+# Widen Client
+A Python client for interacting with Widen v2 API.
+
+Documentation: https://widenv2.docs.apiary.io/#
+
+## Installation
+This client is privately hosted. To install, run
+
+```bash
+pipenv install -e git+ssh://git@github.com/gagosian/widen-client.git#egg=widen-client
+
+```
+
+## Usage
+```python
+from widen_client import Widen
+
+widen = Widen(access_token='...')
+
+widen.assets.search('dBnumber:CHUNG 2021.0001')
+
+widen.assets.get('46579cd6-f58d-49ed-b4af-ea32c84ab20f')
+
+widen.assets.get_metadata('46579cd6-f58d-49ed-b4af-ea32c84ab20f')
+
+widen.assets.update_metadata('46579cd6-f58d-49ed-b4af-ea32c84ab20f', {
+    'fields': {
+        'alternateCatalogNumber': [],
+        'artist': ['Prince, Richard'],
+        'artistEndYear': ['2004'],
+        'artworkParentheticalTitle': [''],
+        'artworkTitle': ['Untitled'],
+        'artworkType': ['sculpture'],
+        'description': ['This is not a dog.'],
+    }
+})
+```
+
+## Available Entities
+The following entities are available:
+
+- Assets (`/assets/`)
+- Metadata (`/metadata/`)

widen_client-0.0.15.dist-info/RECORD

@@ -0,0 +1,12 @@
+widen_client/__init__.py,sha256=98xlZqJ_CVlvjOuB-xc51lEtZpbVegSPmC_B90TxsZU,303
+widen_client/baseapi.py,sha256=j5TQCXZtJfzhJpht4tCaYtWGJ1dsoYGwig-z19GkSVE,1564
+widen_client/client.py,sha256=AA7dphFkCAbkGseABytWXYuQqRGMminbjsP7z4wr2Qo,13196
+widen_client/entities/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+widen_client/entities/assets.py,sha256=NSM5ENtGL8XUWNXegu6T2-xn10N5FCWb813KyiieuT4,3731
+widen_client/entities/metadata.py,sha256=O6pVK7XX3zekqks3timnYIDcMcrDpUxKsQO6IcYdmhM,6402
+widen_client/entities/uploads.py,sha256=BJsrkgkdViyBqh2MVkDsmwIcvgIO8p50Oa2e01gD57o,1100
+widen_client-0.0.15.dist-info/licenses/LICENSE,sha256=IkOii96WG8-llXw9Ctmq4BsLwELw09KJCJglpxsIxFw,11
+widen_client-0.0.15.dist-info/METADATA,sha256=YzlOjsO9J3JUso9s0DD6QRYEdRL7mBQcYShhAOiW7gE,1953
+widen_client-0.0.15.dist-info/WHEEL,sha256=qELbo2s1Yzl39ZmrAibXA2jjPLUYfnVhUNTlyF1rq0Y,92
+widen_client-0.0.15.dist-info/top_level.txt,sha256=4pzRQUeykfNuKG4ygxokWt8kRHpgVW_-PZhG1Pr4KQI,13
+widen_client-0.0.15.dist-info/RECORD,,

widen_client-0.0.15.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.10.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

widen_client-0.0.15.dist-info/licenses/LICENSE

@@ -0,0 +1 @@
+UNLICENSED

widen_client-0.0.15.dist-info/top_level.txt

@@ -0,0 +1 @@
+widen_client