pushframe 5.0.0__py3-none-any.whl

pushframe/api/peopleApi.py

@@ -0,0 +1,25 @@
+from pushframe.api.baseApi import BaseApi
+from pushframe.models.person import Person
+
+
+class PeopleApi(BaseApi):
+
+    def get_people(self):
+        json_response = self._client.get('/people.json')
+        return [Person(**json_person) for json_person in json_response.get('people')]
+
+    def get_people_assets(self, cursor: str = None):
+        json_response = self._client.get('/people/all_assets.json', query_params={'cursor': cursor})
+
+        return json_response
+
+    def get_person(self, person_id: str):
+        # TODO: This may not be operational
+        json_response = self._client.get(f'/people/{person_id}.json')
+
+        return json_response
+
+    def get_person_assets(self, person_id: str):
+        # TODO: This may not be operational
+        json_response = self._client.get(f'/people/{person_id}/assets.json')
+        return json_response

pushframe/api/playlistApi.py

@@ -0,0 +1,9 @@
+from pushframe.api.baseApi import BaseApi
+
+
+class PlaylistApi(BaseApi):
+
+    def get_playlist_assets(self, playlist_id: str, frame_id: str, _filter: str = None, limit: int = None,
+                            cursor: str = None):
+        self._client.get(f'/playlists/{playlist_id}/assets.json',
+                         query_params={'frame_id': frame_id, 'filter': _filter, 'limit': limit, 'cursor': cursor})

pushframe/aura.py

@@ -0,0 +1,182 @@
+import sys
+import os
+import time
+
+from PIL import Image
+from loguru import logger
+from tqdm import tqdm
+
+from pushframe.api.accountApi import AccountApi
+from pushframe.api.activityApi import ActivityApi
+from pushframe.api.assetApi import AssetApi
+from pushframe.api.frameApi import FrameApi
+from pushframe.api.peopleApi import PeopleApi
+from pushframe.aws.s3client import S3Client
+from pushframe.aws.sqsclient import SQSClient
+from pushframe.client import Client, WriteEndpointError
+from pushframe.exif import ExifWriter
+from pushframe.export import get_image_from_asset
+from pushframe.models.asset import Asset, AssetPartialId
+from pushframe.utils.io import build_path, write_model
+
+# MOD-04 (Phase 19): process-level guard against the loguru sink leak.
+# `_init_logger()` used to add a stderr sink AND a `logs/file_{time}.log`
+# file sink on EVERY `Aura()` construction, so a process that builds several
+# instances (CLIs, tests via offline_aura) spawned one log file per instance
+# and accumulated duplicate sinks. The FIRST construction in a process
+# configures logging; subsequent ones are no-ops for sinks. This is a
+# module-level flag on purpose (NOT a per-instance one — distinct instances
+# were the leak), and it deliberately performs no wholesale sink teardown:
+# cli.py's _configure_cli_logging() stays the single reconfigure point.
+_LOGGER_READY = False
+
+
+class Aura:
+
+    def __init__(self, client: Client | None = None):
+        self._init_logger()
+        self._client = client or Client()
+        self.account_api = AccountApi(self._client)
+        self.frame_api = FrameApi(self._client)
+        self.people_api = PeopleApi(self._client)
+        self.activity_api = ActivityApi(self._client)
+        self.asset_api = AssetApi(self._client)
+        self.exif_writer = ExifWriter()
+
+    def login(self, email: str = None, password: str = None):
+        """
+
+        :param email: The email of the account to authenticate with, defaults to ENVIRON['AURA_EMAIL']
+        :param password: The password of the account to authenticate with, defaults to ENVIRON['AURA_PASSWORD']
+        :return: Authenticated Aura object
+        """
+        if email is None:
+            email = os.getenv('PUSHFRAME_EMAIL') or os.getenv('AURA_EMAIL')
+        if password is None:
+            password = os.getenv('PUSHFRAME_PASSWORD') or os.getenv('AURA_PASSWORD')
+
+        user = self.account_api.login(email, password)
+
+        self._client.add_default_headers({
+            'x-token-auth': user.auth_token,
+            'x-user-id': user.id
+        })
+
+        return self
+
+    def main(self):
+        pass
+
+    def get_all_assets(self, frame_id: str, limit: int = 1000, page_delay: float = 0.0):
+        paginated_assets, cursor = self.frame_api.get_assets(frame_id, limit=limit)
+        assets = paginated_assets
+        while cursor:
+            paginated_assets, cursor = self.frame_api.get_assets(frame_id, limit=limit, cursor=cursor)
+            if page_delay:
+                time.sleep(page_delay)
+            assets.extend(paginated_assets)
+
+        return assets
+
+    def dump_frame(self, frame_id: str, path: str, download_images: bool = True, download_activities: bool = True):
+        frame, _ = self.frame_api.get_frame(frame_id)
+        frame_dir = build_path(path, f'{frame.name}-{frame.id}/')
+
+        write_model(frame, build_path(frame_dir, 'frame.json'))
+
+        if download_activities:
+            activities = self.frame_api.get_activities(frame.id)
+            write_model(activities, build_path(frame_dir, 'activities.json'))
+
+        assets = self.get_all_assets(frame_id)
+        write_model(assets, build_path(frame_dir, 'assets.json'))
+
+        if download_images:
+            self.download_images_from_assets(assets, build_path(frame_dir, f'asset_images/'))
+
+    def download_images_from_assets(self, assets: list[Asset], base_path: str):
+        failed_to_retrieve = []
+        for asset in tqdm(assets):
+            try:
+                get_image_from_asset(asset, base_path, self.exif_writer)
+            except Exception as e:
+                failed_to_retrieve.append(asset)
+        if len(failed_to_retrieve) > 0:
+            logger.debug(f'Failed to retrieve {len(failed_to_retrieve)} assets.')
+
+    def clone(self, source_frame, target_frame):
+        # TODO: Read assets from one frame and immediately clones them to another (in memory)
+        pass
+
+    def upload_images(self):
+        # TODO: tqdm, for each asset, upload_image
+        # TODO: How do we know where the original dumped asset images are?
+        #       Could rebuild the file path or store it in assets.json
+        pass
+
+    def upload_image(self, frame_id: str, image_path: str, asset: Asset):
+        """
+        Uploads a single image to S3 and associates it with the given frame via the legacy
+        single-item path (`select_asset` + `batch_update`), distinct from the batched multi-file
+        path `sync.execute_plan` uses.
+
+        :param frame_id: The frame to associate the uploaded asset with.
+        :param image_path: Local filesystem path to the image file to upload.
+        :param asset: Asset metadata to update after the S3 upload lands.
+        :raises WriteEndpointError: if `batch_update` does not acknowledge this asset's
+            local_identifier -- REL-07/D-18: `batch_update`'s `unacknowledged` set is a real
+            per-item failure signal, not something this legacy caller may silently discard.
+        """
+        try:
+            image = Image.open(image_path)
+        except Exception as e:
+            logger.error(e)
+            return
+        local_identifier = asset.local_identifier
+        self.frame_api.select_asset(frame_id, AssetPartialId(local_identifier=local_identifier))
+        queue_url = self.get_sqs(frame_id)
+        self.sqsClient.receive_message(queue_url, wait_time_seconds=5)
+        self.frame_api.select_asset(frame_id, AssetPartialId(local_identifier=local_identifier))
+        client = S3Client()
+        filename, md5 = client.upload_file(
+            open(image_path, 'rb').read(), '.jpg')
+
+        asset.file_name = filename
+        asset.md5_hash = md5
+        asset.height = image.height
+        asset.width = image.width
+
+        batch_result = self.asset_api.batch_update(asset)
+        if batch_result.unacknowledged:
+            raise WriteEndpointError(
+                f"upload_image: frame {frame_id} -- batch_update did not acknowledge "
+                f"local_identifier(s) {batch_result.unacknowledged}"
+            )
+        message = self.sqsClient.receive_message(queue_url, wait_time_seconds=5)
+        print(message)
+
+    def get_sqs(self, frame_id: str):
+        self.sqsClient = SQSClient()
+        return self.sqsClient.get_queue_url(frame_id)
+
+    def _init_logger(self):
+        """Configure the process's loguru sinks exactly once (MOD-04, D-03):
+        the first Aura() construction registers the stderr + file sinks; any
+        further construction is a sink no-op. Performs no teardown — cli.py's
+        _configure_cli_logging() owns wholesale reconfiguration.
+        """
+        global _LOGGER_READY
+        if _LOGGER_READY:
+            return
+        # Ensure the loguru file sink's target dir exists before the first
+        # instantiation so it does not raise FileNotFoundError (D-08).
+        os.makedirs('logs/', exist_ok=True)
+        # (The old commented-out "set this to debug if needed" sink-teardown
+        # vestige is gone: with the process guard, tearing down every sink on
+        # a later construction would silence the process for good.)
+        logger.add(sys.stderr, level="INFO", format="<green>{time:YYYY-MM-DD HH:mm:ss.SSS}</green> | "
+                                                    "<level>{level: <8}</level> | "
+                                                    "<cyan>{name}</cyan>:<cyan>{function}</cyan>:<cyan>{line}</cyan> | "
+                                                    "<level>{message}</level> Context: {extra}")
+        logger.add('logs/file_{time}.log')
+        _LOGGER_READY = True

pushframe/aws/awsclient.py

@@ -0,0 +1,23 @@
+import boto3
+import botocore
+
+SESSION_CONFIG = botocore.config.Config(
+    user_agent="aws-sdk-android/2.13.1 Linux/5.4.61-android11 Dalvik/2.1.0/0 en_US"
+)
+
+
+# TODO: Convert this to use os.environ vars?
+class AWSClient:
+
+    def __init__(self, pool_id: str, region_name='us-east-1'):
+        # boto3.set_stream_logger('', logging.DEBUG)
+
+        self.region_name = region_name
+        self.cognito = boto3.client('cognito-identity', region_name=self.region_name)
+        if pool_id:
+            self.auth(pool_id)
+
+    def auth(self, pool_id):
+        ident_resp = self.cognito.get_id(IdentityPoolId=pool_id)
+        cred_resp = self.cognito.get_credentials_for_identity(IdentityId=ident_resp['IdentityId'])
+        self.credentials = cred_resp['Credentials']

pushframe/aws/s3client.py

@@ -0,0 +1,40 @@
+import base64
+import boto3
+import uuid
+import hashlib
+
+from pushframe.aws.awsclient import AWSClient
+from pushframe.utils.settings import AWS_S3_BUCKET, AWS_UPLOAD_IDENTITY_POOL_ID
+
+# MOD-02 (Phase 19): the bucket name and pool ID moved to settings.py
+# (env-overridable, unchanged defaults). Kept as aliases so existing
+# references keep working; no literal remains in this module.
+BUCKET_KEY = AWS_S3_BUCKET
+UPLOAD_IDENTITY_POOL_ID = AWS_UPLOAD_IDENTITY_POOL_ID
+AWS_UPLOAD_PART_SIZE = 16384
+
+
+def get_md5(data):
+    return base64.b64encode(hashlib.md5(data).digest()).decode('utf-8')
+
+
+class S3Client(AWSClient):
+    s3_client = None
+
+    def __init__(self, pool_id=None, region_name='us-east-1'):
+        super().__init__(pool_id if pool_id else UPLOAD_IDENTITY_POOL_ID, region_name)
+
+    def auth(self, pool_id):
+        super().auth(pool_id)
+        self.s3_client = boto3.client('s3', aws_access_key_id=self.credentials['AccessKeyId'],
+                                      aws_secret_access_key=self.credentials['SecretKey'],
+                                      aws_session_token=self.credentials['SessionToken'])
+
+    def upload_file(self, data, extension):
+        filename = f'{str(uuid.uuid4())}{extension}'
+        self.s3_client.put_object(Body=data, Bucket=BUCKET_KEY, Key=filename)
+
+        return filename, get_md5(data)
+
+    def get_file(self, filename):
+        return self.s3_client.head_object(Bucket=BUCKET_KEY, Key=filename)

pushframe/aws/sqsclient.py

@@ -0,0 +1,33 @@
+import boto3
+
+from pushframe.aws.awsclient import AWSClient
+from pushframe.utils.settings import AWS_SQS_IDENTITY_POOL_ID
+
+# MOD-02 (Phase 19): the pool ID moved to settings.py (env-overridable,
+# unchanged default). Kept as an alias so existing references keep working;
+# no literal remains in this module.
+SQS_IDENTITY_POOL_ID = AWS_SQS_IDENTITY_POOL_ID
+
+
+# TODO: Might want to thread this out, as the wait time could be an issue
+class SQSClient(AWSClient):
+    sqs_client: None
+
+    def __init__(self, pool_id=None, region_name='us-east-1'):
+        super().__init__(pool_id if pool_id else SQS_IDENTITY_POOL_ID, region_name)
+
+    def auth(self, pool_id):
+        super().auth(pool_id)
+        self.sqs_client = boto3.client('sqs', aws_access_key_id=self.credentials['AccessKeyId'],
+                                       aws_secret_access_key=self.credentials['SecretKey'],
+                                       aws_session_token=self.credentials['SessionToken'],
+                                       region_name=self.region_name)
+
+    def get_queue_url(self, frame_id: str):
+        return self.sqs_client.get_queue_url(QueueName=f'frame-{frame_id}-client').get('QueueUrl')
+
+    def receive_message(self, queue_url: str, max_num_messages: int = 10, wait_time_seconds: int = 20):
+        response = self.sqs_client.receive_message(QueueUrl=queue_url, MaxNumberOfMessages=max_num_messages,
+                                                   WaitTimeSeconds=wait_time_seconds, AttributeNames=['All'])
+
+        return response

pushframe/cache.py

@@ -0,0 +1,50 @@
+import json
+import os
+
+CACHE_DIR = 'cache/'
+
+# TODO: Silly caching, should probably rework.
+
+def save_to_cache(file_name, data):
+    path = os.path.join(CACHE_DIR, file_name + '.json')
+    with open(path, 'w') as f:
+        json.dump(data, f)
+
+
+def cache(file_name, use_arg=False):
+    def decorator(function):
+        def wrapper(*args, **kwargs):
+            if use_arg:
+                path = os.path.join(CACHE_DIR, file_name + "-" + args[1] + '.json')
+            else:
+                path = os.path.join(CACHE_DIR, file_name + '.json')
+            if os.path.isfile(path):
+                with open(path, 'r') as f:
+                    ret = json.load(f)
+            else:
+                with open(path, 'w') as f:
+                    ret = function(*args, **kwargs)
+                    json.dump(ret, f)
+            return ret
+
+        return wrapper
+
+    return decorator
+
+
+def async_cache(file_name):
+    def decorator(function):
+        async def wrapper(*args, **kwargs):
+            path = os.path.join(CACHE_DIR, file_name + '.json')
+            if os.path.isfile(path):
+                with open(path, 'r') as f:
+                    ret = json.load(f)
+            else:
+                with open(path, 'w') as f:
+                    ret = await function(*args, **kwargs)
+                    json.dump(ret, f)
+            return ret
+
+        return wrapper
+
+    return decorator