pushframe 5.0.0__py3-none-any.whl

pushframe/__init__.py

@@ -0,0 +1,4 @@
+# pushframe — unofficial community CLI for Aura Frames (not affiliated).
+# Version single source for the CLI surface (REL-02); pyproject keeps the
+# packaging metadata version and tests/test_version.py enforces lockstep.
+__version__ = "5.0.0"

pushframe/api/accountApi.py

@@ -0,0 +1,72 @@
+from pushframe.api.baseApi import BaseApi
+from pushframe.models.user import User
+from pushframe.utils import settings
+
+
+class AccountApi(BaseApi):
+
+    def login(self, email: str, password: str) -> User:
+        """
+        Authenticates with the API.
+
+        :param email: Registered email
+        :param password: Registered password (plaintext)
+        :return: Hydrated user object
+        """
+        login_payload = {
+            'user': {
+                'email': email,
+                'password': password
+            },
+            'locale': settings.LOCALE,
+            'app_identifier': settings.AURA_APP_IDENTIFIER,
+            'identifier_for_vendor': settings.DEVICE_IDENTIFIER,
+            'client_device_id': settings.DEVICE_IDENTIFIER
+        }
+
+        json_response = self._client.post('/login.json', login_payload)
+        if json_response.get('error') or not json_response.get('result'):
+            # A drifted/failed login must surface loudly rather than silently
+            # hydrating a model from an empty/error response (D-06).
+            raise RuntimeError(
+                f"Aura login failed: {json_response.get('message') or json_response.get('error') or 'no result returned'}"
+            )
+
+        return User(**json_response.get('result').get('current_user'))
+
+    def register(self, email: str, password: str, name: str) -> User:
+        """
+        Registers an account.
+
+        :param email: Email to register with
+        :param password: Password (plaintext) to register with
+        :param name: Display name
+        :return: Hydrated user object for the registered user.
+        """
+        register_payload = {
+            'email': email,
+            'name': name,
+            'password': password,
+            'identifier_for_vendor': settings.DEVICE_IDENTIFIER,
+            'smart_suggestions_off': True,
+            'auto_upload_off': True,
+            'locale': settings.LOCALE,
+            'client_device_id': settings.DEVICE_IDENTIFIER
+        }
+
+        json_response = self._client.post('/account/register.json', data=register_payload)
+
+        if json_response.get('error') or not json_response.get('result'):
+            # TODO: Error handling
+            pass
+
+        return User(**json_response.get('result').get('current_user'))
+
+    def delete(self) -> bool:
+        """
+        Deletes the currently logged in user.
+        :return: Boolean describing if the user was successfully deleted.
+        """
+        json_response = self._client.delete(f'/account/delete')
+
+        return json_response.get('result').get('success') and not json_response.get('error')

pushframe/api/activityApi.py

@@ -0,0 +1,87 @@
+from pushframe.api.baseApi import BaseApi
+
+from pushframe.models.activity import Activity, Comment
+from pushframe.models.asset import Asset, AssetSetting
+from pushframe.models.user import User
+
+
+class ActivityApi(BaseApi):
+
+    def get_comments(self, activity_id: str) -> tuple[list[Comment], int, list[User]]:
+        """
+        Gets all comments on an activity.
+
+        :param activity_id: Activity id to retrieve comments
+        :return: A list of comments, the number of new (unseen)
+            comments, and a list of user data associated to the comments.
+        """
+        json_response = self._client.get(f'/activities/{activity_id}/comments.json')
+        return (
+            [Comment(**json_comment) for json_comment in json_response.get('comments')],
+            json_response.get('new_count'),
+            [User(**json_user) for json_user in json_response.get('users')]
+        )
+
+    def create_comment(self, activity_id: str, content: str) -> tuple[Activity, Comment]:
+        """
+        Creates a comment on an activity.
+        :param activity_id: Activity id
+        :param content: The text content of the comment.
+        :return: The hydrated activity and the hydrated comment.
+        """
+        json_response = self._client.post(f'/activities/{activity_id}/create_comment.json', data={'content': content})
+
+        return Activity(**json_response.get('activity')), Comment(**json_response.get('comment'))
+
+    def remove_comment(self, activity_id: str, comment_id: str):
+        """
+        Removes a comment from an activity.
+        :param activity_id: Activity id
+        :param comment_id: Comment id associated to the activity
+        :return: The hydrated activity with the comment removed.
+        """
+        json_response = self._client.post(f'/activities/{activity_id}/remove_comment.json',
+                                          data={'comment_id': comment_id})
+
+        return Activity(**json_response.get('activity'))
+
+    def get_activity_assets(self, activity_id: str, limit: int = 1000, cursor: str = None):
+        """
+        Gets assets associated to an activity. The results are paginated with `limit` results per page. To obtain the next set
+        of pages, pass in the cursor from the response.
+
+        TODO: The API doesn't seem to produce a cursor.
+
+        :param activity_id: Activity id
+        :param limit: Maximum number of assets per page / callout.
+        :param cursor: The cursor from the previous page.
+        :return: A list of assets and a list of asset settings.
+        """
+        json_response = self._client.get(f'/activities/{activity_id}/assets.json',
+                                         query_params={'limit': limit, 'cursor': cursor})
+        return (
+            [Asset(**json_asset) for json_asset in json_response.get('assets')],
+            [AssetSetting(**json_asset_setting) for json_asset_setting in json_response.get('asset_settings')]
+        )
+
+    def post_activity(self, activity_id: str, frame_id: str, data: dict):
+        """
+        TODO: Unknown
+        :param activity_id:
+        :param frame_id:
+        :param data:
+        :return:
+        """
+        json_response = self._client.post(f'/activities/{activity_id}/copy.json', data=data,
+                                          query_params={'frame_id': frame_id})
+        return json_response
+
+    def delete_activity(self, activity_id: str) -> None:
+        """
+        Deletes the activity. TODO: Better description
+        :param activity_id: Activity to remove
+        """
+        self._client.delete(f'/activities/{activity_id}')
+
+        # Response is typically an empty JSON object.
+        return None

pushframe/api/assetApi.py

@@ -0,0 +1,194 @@
+import typing
+
+from loguru import logger
+from pydantic import ValidationError
+
+from pushframe.api.baseApi import BaseApi
+from pushframe.client import WriteEndpointError
+
+# TODO: Untested
+from pushframe.models.asset import Asset, AssetPartial, AssetPartialId
+
+
+class BatchUpdateResult(typing.NamedTuple):
+    """Result of `AssetApi.batch_update`.
+
+    A `NamedTuple` so `unacknowledged` is reachable by name
+    (`result.unacknowledged`) while the value stays usable positionally.
+
+    `unacknowledged` is the sent-but-not-acknowledged local_identifier set --
+    the honest name for the fact that a `batch_update` response can silently
+    drop requested ids (REL-07, D-18). A non-empty `unacknowledged` is a
+    per-item failure signal for the caller to attribute, NOT an error
+    condition for `batch_update` itself to raise on -- see the docstring
+    below.
+    """
+    ids: list[str]
+    successes: list[AssetPartialId]
+    unacknowledged: list[str]
+
+
+class AssetApi(BaseApi):
+
+    def batch_update(self, assets: Asset | AssetPartial | list[Asset | AssetPartial]) -> BatchUpdateResult:
+        """
+        Posts new metadata to the API for one or more assets. This does not appear to affect the
+        frame; however subsequent calls to retrieve the asset(s) will have the modified metadata.
+
+        Primarily used to update an asset after the image has been uploaded to S3.
+
+        This is a native Pushd BATCH endpoint: the official app sends the whole collection of
+        assets to update in a single `{"assets": [...]}` call rather than one call per asset. A
+        single `Asset`/`AssetPartial` is accepted for backward compatibility (normalized to a
+        one-element list).
+
+        `successes` in the response (each carrying `id` + `local_identifier`) is the per-file
+        source of truth for batch callers: match each sent item's `local_identifier` against
+        `successes[].local_identifier` to attribute success/failure per item -- a partial
+        `successes` list (fewer entries than sent) is the NORMAL, expected signal in batch mode
+        that the caller must attribute per-item, not an error to raise on. Only the `error`
+        envelope (a whole-call failure) raises here.
+
+        The returned `BatchUpdateResult.unacknowledged` is that same per-item signal computed
+        once, here, as the sent local_identifiers (in sent order) that never appear among the
+        parsed `successes` entries -- returned to the caller rather than raised, since a partial
+        `successes` list is this endpoint's normal batch behavior, not an error. Every caller,
+        not just `execute_plan`, can read it -- `Aura.upload_image` now does too.
+
+        Each entry in the inbound `successes` array is parsed strictly (`AssetPartialId`'s
+        cross-field validator still applies), but a single malformed entry is skipped and logged
+        rather than raised (D-19): the API is undocumented and its shape drifts, so one junk row
+        in an otherwise-good response must not cost the whole chunk's per-file attribution.
+
+        :param assets: A single `Asset`/`AssetPartial`, or a list of them, to update in one call.
+        :return: A `BatchUpdateResult` of sent remote ids, parsed `AssetPartialId` successes (may
+            be a partial subset of what was sent -- see above), and the unacknowledged
+            local_identifier set.
+        """
+        items = assets if isinstance(assets, list) else [assets]
+
+        json_response = self._client.put(f'/assets/batch_update.json', data={
+            "assets": [
+                item.dict(
+                    include={
+                        'data_uti': True,
+                        'favorite': True,
+                        'file_name': True,
+                        'height': True,
+                        'local_identifier': True,
+                        'location': True,
+                        'md5_hash': True,
+                        'modified_at': True,
+                        'orientation': True,
+                        'selected': True,
+                        'taken_at': True,
+                        'upload_priority': True,
+                        'width': True
+                    })
+                for item in items
+            ]
+        })
+        if json_response.get('error'):
+            raise WriteEndpointError(f"batch_update failed: {json_response.get('error')}")
+
+        ids = json_response.get('ids') or []
+        raw_successes = json_response.get('successes') or []
+
+        successes: list[AssetPartialId] = []
+        for entry in raw_successes:
+            # D-19: strict outbound, tolerant inbound. The outbound
+            # AssetPartialId validator (pushframe/models/asset.py) is left
+            # untouched; here on the inbound side, one malformed row must
+            # not crash the whole chunk -- the API is undocumented and its
+            # shape drifts (Phase 10's smart_adds regression is the
+            # precedent), so a single junk entry in a 50-item response is
+            # skipped and logged rather than costing the whole chunk's
+            # per-file attribution through execute_plan's generic
+            # `except Exception` branch.
+            try:
+                successes.append(AssetPartialId(**entry))
+            except ValidationError as e:
+                keys = sorted(entry.keys()) if isinstance(entry, dict) else type(entry).__name__
+                # T-11-06: pydantic v2's default ValidationError str/repr embeds
+                # each error's raw input_value (confirmed: constructing
+                # AssetPartialId(**{'user_id': '...'}) puts the whole dict --
+                # including user_id -- in str(e)). include_input=False strips
+                # that before it reaches the log sink; only keys + error
+                # type/message are logged, never entry values.
+                safe_errors = e.errors(include_url=False, include_input=False)
+                logger.warning(f"batch_update: skipping malformed successes entry (keys={keys}): {safe_errors}")
+
+        acknowledged = {s.local_identifier for s in successes if s.local_identifier}
+        unacknowledged = [
+            item.local_identifier for item in items
+            if item.local_identifier and item.local_identifier not in acknowledged
+        ]
+
+        return BatchUpdateResult(ids, successes, unacknowledged)
+
+    def get_asset_by_local_identifier(self, local_id: str):
+        """
+        Retrieves an asset given a local id.
+        :param local_id: A local id string.
+        :return: The retrieved asset, related child albums, and any smart adds related to the asset.
+        """
+        json_response = self._client.get(f'/assets/asset_for_local_identifier.json',
+                                         query_params={'local_identifier': local_id})
+
+        return Asset(**json_response.get('asset')), json_response.get('child_albums'), json_response.get('smart_adds')
+
+    def update_taken_at_date(self, asset: Asset) -> Asset:
+        """
+        Updates an asset's taken_date and taken_at_granularity. This will modify the date displayed in the frame and
+        from future responses.
+        :param asset: Asset with new taken_at or taken_at_granularity
+        :return: The asset with modified dates
+        """
+        # Asset.id is a required str (never None for a server-hydrated
+        # Asset), so this always uses the id-based request shape.
+        request = {
+            'taken_at': asset.taken_at,
+            'taken_at_granularity': asset.taken_at_granularity,
+            'id': asset.id,
+        }
+
+        json_response = self._client.post(f'/assets/update_taken_at_date.json', data=request)
+        return Asset(**json_response)
+
+    def delete_asset(self, asset: Asset):
+        """
+        Deletes the asset. **Currently unknown if this is used, most deletions occur by removing
+        the activity; maybe this deletes it from S3/Glacier** see :func:`FrameApi.remove_asset`
+
+        :param asset: Asset for removal
+        :return: TODO
+        """
+        # Asset.id is a required str (never None for a server-hydrated
+        # Asset), so this always uses the id-based delete endpoint.
+        json_response = self._client.delete(f'/assets/{asset.id}.json')
+
+        if json_response.get('error'):
+            raise WriteEndpointError(f"delete_asset failed: {json_response.get('error')}")
+
+        return json_response
+
+    def crop_asset(self, asset: Asset) -> Asset:
+        """
+        Crops an asset, modifying `rotation_cw`, `user_landscape_rect`, `user_portrait_rect` and related
+        aspect ratio rects.
+        :param asset: Asset containing new rotation/rect data.
+        :return: The asset with modified crop fields.
+        """
+        json_response = self._client.post(f'/assets/crop.json', data=asset.dict(
+            include={
+                'id': True,
+                'local_identifier': True,
+                'user_id': True,
+                'rotation_cw': True,
+                'user_landscape_16_10_rect': True,
+                'user_landscape_rect': True,
+                'user_portrait_4_5_rect': True,
+                'user_portrait_rect': True
+            }))
+
+        return Asset(**json_response.get('asset'))

pushframe/api/baseApi.py

@@ -0,0 +1,6 @@
+from pushframe.client import Client
+
+
+class BaseApi:
+    def __init__(self, client: Client):
+        self._client = client

pushframe/api/frameApi.py

@@ -0,0 +1,271 @@
+import uuid
+
+from pushframe.api.baseApi import BaseApi
+from pushframe.models.activity import Activity
+from pushframe.models.asset import Asset, AssetPartialId
+from pushframe.models.frame import Frame, FramePartial
+
+from pushframe.utils.dt import get_utc_now, format_dt_to_aura
+
+
+def _apply_asset_settings(assets: list[Asset], asset_settings) -> None:
+    """Overwrite each asset's `selected` with this frame's visibility, taken
+    from the `asset_settings` array that rides alongside `assets` in the
+    /frames/{id}/assets.json response.
+
+    Visibility is per-frame state, so it lives in `asset_settings` (keyed by
+    `asset_id`, carrying `selected` and its mirror `hidden`), NOT on the asset
+    itself. Live-confirmed in Phase 10: after `exclude_asset` hid a photo, its
+    `asset_settings.selected` flipped to `false` while the asset-level
+    `selected` stayed `true`. Reading the asset-level field would classify
+    every photo as visible forever and silently never hide anything, so the
+    join happens once here at the API boundary rather than in each caller.
+
+    An asset with no matching settings row keeps whatever `selected` the API
+    sent (it has no per-frame override to apply). Mutates `assets` in place.
+    """
+    if not asset_settings:
+        return
+
+    visibility = {
+        row['asset_id']: row['selected']
+        for row in asset_settings
+        if row.get('asset_id') is not None and row.get('selected') is not None
+    }
+    for asset in assets:
+        if asset.id in visibility:
+            asset.selected = visibility[asset.id]
+
+
+class FrameApi(BaseApi):
+
+    def get_frames(self) -> list[Frame]:
+        """
+        Gets all frames available for the active user.
+        :return: List of all frames the active user owns or is collaborating on.
+        """
+        json_response = self._client.get('/frames.json')
+        return [Frame(**frame_data) for frame_data in json_response.get('frames')]
+
+    def get_frame(self, frame_id: str) -> tuple[Frame, int]:
+        """
+        Gets frame data for a given `frame_id`
+        :param frame_id: Frame id to retrieve
+        :return: The hydrated frame and the frame's total asset count.
+        """
+        json_response = self._client.get(f'/frames/{frame_id}.json')
+        frame_data = json_response.get('frame')
+        # The live API moved the asset count: it used to be the top-level
+        # `total_asset_count` and is now `frame.num_assets` (Phase 2 live drift).
+        # Prefer the legacy key, fall back to the new location so either API
+        # shape yields a count.
+        total_asset_count = json_response.get('total_asset_count')
+        if total_asset_count is None and frame_data:
+            total_asset_count = frame_data.get('num_assets')
+        return Frame(**frame_data), total_asset_count
+
+    def get_assets(self, frame_id: str, limit: int = 1000, cursor: str = None) -> tuple[list[Asset], str]:
+        """
+        Gets assets for a `frame_id`. The results are paginated with `limit` results per page. To obtain the next set
+        of pages, pass in the cursor from the response.
+
+        Returns BOTH visible and hidden assets: the request sends `filter=all`
+        because the server otherwise defaults to `filter=selected` and silently
+        drops every hidden asset from the page (live-confirmed Phase 10 --
+        omitting the filter returned 154 assets where `filter=all` returned
+        157). Hidden assets must stay in the listing so a hidden photo still
+        counts as present for md5 dedup and is never re-uploaded (D-06).
+
+        Each returned `Asset.selected` carries THIS FRAME's visibility, joined
+        from the response's parallel `asset_settings` array (see
+        `_apply_asset_settings`). The asset-level `selected` field the API
+        sends is NOT per-frame visibility -- live probing showed it stays
+        `true` even while the photo is hidden on the frame -- so it is
+        overwritten here, at the boundary, and every downstream consumer can
+        read `asset.selected` as the real signal (D-01/D-05).
+
+        :param frame_id: Frame ID to retrieve assets
+        :param limit: Maximum number of assets per page / callout.
+        :param cursor: The cursor from the previous page.
+        :return: List of all the assets (visible and hidden), and the next page's cursor
+            (will be `None` if there are no more pages)
+        """
+        json_response = self._client.get(f'/frames/{frame_id}/assets.json',
+                                         query_params={'limit': limit, 'cursor': cursor, 'filter': 'all'})
+        if json_response.get('error'):
+            # Surface API drift instead of silently swallowing it (D-06):
+            # a drifted/failed asset page must not be processed as success.
+            raise RuntimeError(
+                f"get_assets failed for frame {frame_id}: "
+                f"{json_response.get('message') or json_response.get('error')}"
+            )
+        assets = [Asset(**asset_data) for asset_data in json_response.get('assets')]
+        _apply_asset_settings(assets, json_response.get('asset_settings'))
+        return assets, json_response.get('next_page_cursor')
+
+    def get_activities(self, frame_id: str, cursor: str = None):
+        """
+        Gets activities associated to a frame. This appears to be paginated, although
+        :param frame_id: Frame id to retrieve associated activities
+        :param cursor: Cursor of the previous page TODO: **UNUSED?**
+        :return: A list of activities, the cursor for the next page
+        """
+        json_response = self._client.get(f'/frames/{frame_id}/activities.json', query_params={'cursor': cursor})
+        return [Activity(**json_activity) for json_activity in
+                json_response.get('activities')], json_response.get('next_page_cursor')
+
+    def show_asset(self, frame_id: str, asset_id: str, goto_time: str) -> bool:
+        """
+        Forces the frame to display the asset.
+
+        :param frame_id: Frame id to control
+        :param asset_id: Asset id to display on the frame
+        :param goto_time: TODO: Unknown, appears to be the current datetime -- does setting it to the future queue the
+                            asset?
+        :return: Boolean describing if the frame was able to process the request.
+        """
+        json_response = self._client.post(f'/frames/{frame_id}/goto.json', data={
+            'asset_id': asset_id,
+            'frame_id': frame_id,
+            'goto_time': goto_time if goto_time else format_dt_to_aura(get_utc_now()),
+            'swipe_direction': 0,
+            'impression_id': uuid.uuid4(),
+            'select_asset': True
+        })
+
+        return json_response.get('showing')
+
+    def update_frame(self, frame_id: str, frame_partial: FramePartial):
+        """
+        Updates a frame by id. This cannot update the frame id.
+            TODO: Should we assume that FramePartial has `id` set and use that instead of `frame_id`?
+
+        :param frame_id: Frame to update
+        :param frame_partial: `FramePartial` containing changes to the frame.
+        :return: Returns the hydrated frame with changes.
+        """
+        json_response = self._client.put(f'/frames/{frame_id}.json',
+                                         data={'frame': frame_partial.dict(exclude_unset=True)})
+        return Frame(**json_response.get('frame'))
+
+    def select_asset(self, frame_id: str, asset_partial_ids: AssetPartialId | list[AssetPartialId]) -> int:
+        """
+        Associates one or more assets to a frame. This is typically done immediately before the
+        asset(s) are uploaded to S3.
+
+        This is a native Pushd BATCH endpoint: the official app sends the whole collection of
+        assets to associate in a single `{"assets": [...]}` call rather than one call per asset.
+        A single `AssetPartialId` is accepted for backward compatibility (normalized to a
+        one-element list) and legacy single-item callers are unaffected.
+
+        :param frame_id: Frame id
+        :param asset_partial_ids: A single `AssetPartialId`, or a list of them, to associate to
+            the frame in one call.
+        :return: The number of assets that failed to be associated to the frame. NOTE: this is a
+            count only -- in batch mode (a list of more than one item) there is no per-item
+            signal in this response, so a caller cannot learn WHICH item(s) failed from
+            select_asset alone.
+        """
+        items = asset_partial_ids if isinstance(asset_partial_ids, list) else [asset_partial_ids]
+
+        json_response = self._client.post(f'/frames/{frame_id}/select_asset.json',
+                                          data={'assets': [item.to_request_format() for item in items]})
+        if json_response.get('error'):
+            raise RuntimeError(f"select_asset failed for frame {frame_id}: {json_response.get('error')}")
+
+        number_failed = json_response.get('number_failed')
+        if number_failed:
+            raise RuntimeError(f"select_asset reported {number_failed} failure(s) for frame {frame_id}")
+
+        return number_failed
+
+    def exclude_asset(self, frame_id: str, asset_partial_ids: AssetPartialId | list[AssetPartialId]) -> int:
+        """
+        Hides one or more assets on the frame: they stop displaying in the slideshow but are
+        NOT deleted -- they remain in `get_assets(filter='all')` and still show in the app.
+        Live-confirmed in Phase 10 (the frame's asset total was unchanged across a hide, and
+        the asset's `asset_settings.selected` flipped to false / `hidden` to true).
+
+        `select_asset` is the exact inverse -- it un-hides. There is no `include_asset`
+        endpoint and none is needed.
+
+        This is a native Pushd BATCH endpoint (service method `excludeAssets`): the official
+        app sends the whole collection in a single `{"assets": [...]}` call rather than one
+        call per asset, live-confirmed in Phase 10 by hiding two assets in one request. A
+        single `AssetPartialId` is accepted for backward compatibility (normalized to a
+        one-element list).
+
+        The URL deliberately has NO `.json` suffix -- unlike every sibling endpoint here.
+        That matches what the decompiled app posts and is live-confirmed working; it is not
+        a bug, so do not "fix" it.
+
+        :param frame_id: Frame id
+        :param asset_partial_ids: A single `AssetPartialId`, or a list of them, to hide on
+            the frame in one call.
+        :return: The number of assets that failed to be hidden. NOTE: this is a count only --
+            in batch mode there is no per-item signal in this response, so a caller cannot
+            learn WHICH item(s) failed from exclude_asset alone.
+        """
+        items = asset_partial_ids if isinstance(asset_partial_ids, list) else [asset_partial_ids]
+
+        json_response = self._client.post(f'/frames/{frame_id}/exclude_asset',
+                                          data={'assets': [item.to_request_format() for item in items]})
+        if json_response.get('error'):
+            raise RuntimeError(f"exclude_asset failed for frame {frame_id}: {json_response.get('error')}")
+
+        number_failed = json_response.get('number_failed')
+        if number_failed:
+            raise RuntimeError(f"exclude_asset reported {number_failed} failure(s) for frame {frame_id}")
+
+        return number_failed
+
+    def remove_asset(self, frame_id: str, asset_partial_ids: AssetPartialId | list[AssetPartialId]) -> int:
+        """
+        Disassociates one or more assets from a frame. This does not seem to remove the asset(s)
+        from S3/Glacier.
+
+        This is a native Pushd BATCH endpoint: the official app sends the whole collection of
+        assets to remove in a single `{"assets": [...]}` call rather than one call per asset. A
+        single `AssetPartialId` is accepted for backward compatibility (normalized to a
+        one-element list). Per-item delete attribution degrades to per-chunk in batch mode: a
+        nonzero `number_failed` or a raised error fails the WHOLE batch's deletes, since this
+        endpoint returns only a count, never which item(s) failed.
+
+        :param frame_id: Frame id containing the asset(s).
+        :param asset_partial_ids: A single `AssetPartialId`, or a list of them, to remove from
+            the frame in one call.
+        :return: The number of assets that failed to be removed from the frame. NOTE: this is a
+            count only -- there is no per-item signal in this response.
+        """
+        items = asset_partial_ids if isinstance(asset_partial_ids, list) else [asset_partial_ids]
+
+        json_response = self._client.post(f'/frames/{frame_id}/remove_asset.json',
+                                          data={'assets': [item.to_request_format() for item in items]})
+        if json_response.get('error'):
+            raise RuntimeError(f"remove_asset failed for frame {frame_id}: {json_response.get('error')}")
+
+        number_failed = json_response.get('number_failed')
+        if number_failed:
+            raise RuntimeError(f"remove_asset reported {number_failed} failure(s) for frame {frame_id}")
+
+        return number_failed
+
+    def reconfigure(self, frame_id: str):
+        """
+        TODO: Unknown
+        :param frame_id:
+        :return:
+        """
+        return self._client.post(f'/frames/{frame_id}/reconfigure.json', data=None)
+
+    def add_playlist(self, frame_id: str, playlist_params: any):
+        # TODO: Implement
+        json_response = self._client.post(f'/frames/{frame_id}/add_playlist.json', data={})
+
+        return json_response
+
+    def remove_playlist(self, frame_id: str, playlist_params: any):
+        # TODO: Implement
+        json_response = self._client.post(f'/frames/{frame_id}/remove_playlist.json', data={})
+
+        return json_response

pushframe/api/notificationApi.py

@@ -0,0 +1,15 @@
+from pushframe.api.baseApi import BaseApi
+
+
+# TODO: Test
+class NotificationAPI(BaseApi):
+
+    def get_notification_settings(self):
+        json_response = self._client.get('f/notifications/settings/')
+
+        return json_response
+
+    def update_notification(self, update_settings: any):
+        json_response = self._client.post(f'/notifications/update_setting', data=update_settings)
+
+        return json_response