feat: Integrate OneUp API for social media publishing

- Implementation of OneUpClient for API interactions
- Refactor publisher.py to use OneUp for scheduling/publishing
- Update GCS utils to support signed URL generation for OneUp
- Add OneUp API specification file

social_media_publishers/oneup_api_spec.txt

@@ -0,0 +1,389 @@
+Authentication
+Overview
+To interact with the OneUp API, you’ll need to authenticate using your personal API key. This key identifies your account and must be included in every API request.
+
+Step 1: Generate Your API Key
+Go to https://www.oneupapp.io/api-access.
+Log in to your OneUp account.
+Click Generate API Key.
+Copy your generated API key — you’ll use it in your API requests.
+Step 2: Use Your API Key in Requests
+Include your API key as a query parameter named apiKey in all your API calls.
+
+Example Request:
+
+GET https://www.oneupapp.io/api/listcategory?apiKey=YOUR_API_KEY
+
+Example Response:
+
+{
+  "message": "OK",
+  "error": false,
+  "data": [
+    {
+      "id": 49839,
+      "category_name": "AAA testingg",
+      "isPaused": 0,
+      "created_at": "2020-12-09 14:37:45"
+    }
+  ]
+}
+
+✅ Result: The API authenticates your key and returns data linked to your account.
+
+List Categories
+Overview
+The List Categories endpoint allows you to retrieve all categories associated with your OneUp account. Each category is used to group and manage your connected social accounts, not posts. You can use these categories to identify which accounts belong together under the same group.
+
+Base URL:
+
+https://www.oneupapp.io
+
+Endpoint
+GET /api/listcategory?apiKey=YOUR_API_KEY
+
+Example:
+
+GET https://www.oneupapp.io/api/listcategory?apiKey=621544d93ffe2db52b01
+
+Request Parameters
+Parameter	Required	Description
+apiKey	Yes	Your personal API key generated from the API Access page.
+Sample Request
+curl -X GET "https://www.oneupapp.io/api/listcategory?apiKey=YOUR_API_KEY"
+
+Sample Response
+{
+  "message": "OK",
+  "error": false,
+  "data": [
+    {
+      "id": 49839,
+      "category_name": "AAA testingg",
+      "isPaused": 0,
+      "created_at": "2020-12-09 14:37:45"
+    },
+    {
+      "id": 63889,
+      "category_name": "Client #2",
+      "isPaused": 0,
+      "created_at": "2021-10-05 18:29:04"
+    }
+  ]
+}
+
+✅ Result: The response returns all categories linked to your account. Each category includes an id, category_name, and creation details — allowing you to later fetch the accounts grouped under that category.
+
+List Category Accounts
+Overview
+The List Category Accounts endpoint allows you to retrieve all social accounts associated with a specific category. Each category can have one or more connected accounts, such as Facebook Pages, Twitter profiles, Google Business and more.
+
+Base URL:
+
+https://www.oneupapp.io
+
+Endpoint
+GET /api/listcategoryaccount?apiKey=YOUR_API_KEY&category_id=CATEGORY_ID
+
+Example:
+
+GET https://www.oneupapp.io/api/listcategoryaccount?apiKey=621544d93ffe2db52b01&category_id=49839
+
+
+Request Parameters
+Parameter	Required	Description
+apiKey	Yes	Your personal API key generated from the API Access page.
+category_id	Yes	The unique ID of the category whose connected accounts you want to retrieve.
+Sample Request
+curl -X GET "https://www.oneupapp.io/api/listcategoryaccount?apiKey=YOUR_API_KEY&category_id=CATEGORY_ID"
+
+
+Sample Response
+{
+  "message": "OK",
+  "error": false,
+  "data": [
+    {
+      "category_id": 49839,
+      "social_network_name": "kumarvishi",
+      "social_network_id": "pin_kumarvishi",
+      "social_network_type": "Pinterest"
+    },
+    {
+      "category_id": 49839,
+      "social_network_name": "OneUp (United States)",
+      "social_network_id": "accounts/116185162672310389659/locations/1366069594757511498",
+      "social_network_type": "GBP"
+    }
+  ]
+}
+
+✅ Result: The response lists all the social media accounts linked to the specified category. Each item includes:
+
+social_network_name — The display name of the connected social account.
+social_network_id — The unique identifier used when scheduling or publishing posts.
+social_network_type — The type of network (e.g., Facebook, Pinterest, GBP, Twitter, etc.).
+Usage Example
+First, use the List Categories endpoint to get your desired category_id.
+Then, use this endpoint to find all accounts linked to that category.
+Finally, use the social_network_id values when creating or scheduling posts.
+
+List Social Accounts
+Overview
+The List Social Accounts endpoint allows you to retrieve all social media accounts connected to your OneUp account. This endpoint lists every account, regardless of whether it belongs to a specific category or not.
+
+Base URL:
+
+https://www.oneupapp.io
+
+Endpoint
+GET /api/listsocialaccounts?apiKey=YOUR_API_KEY
+
+Example:
+
+GET https://www.oneupapp.io/api/listsocialaccounts?apiKey=621544d93ffe2db52b01
+
+Request Parameters
+Parameter	Required	Description
+apiKey	Yes	Your personal API key generated from the API Access page.
+Sample Request
+curl -X GET "https://www.oneupapp.io/api/listsocialaccounts?apiKey=YOUR_API_KEY"
+
+Sample Response
+{
+  "message": "OK",
+  "error": false,
+  "data": [
+    {
+      "username": "SaaS_Growth_Guy",
+      "full_name": "SaaS growth tip guy",
+      "is_expired": 0,
+      "social_network_type": "X",
+      "need_refresh": false
+    },
+    {
+      "username": "Davis William",
+      "full_name": "Z Davis",
+      "is_expired": 0,
+      "social_network_type": "Facebook",
+      "need_refresh": false
+    }
+  ]
+}
+
+✅ Result: The response returns all the social accounts linked to your OneUp account. Each object includes:
+
+username — The handle or username of the account.
+full_name — The display name associated with the account.
+is_expired — Indicates whether the account connection has expired (0 = active, 1 = expired).
+social_network_type — The type of social network (e.g., Facebook, X, Pinterest, GBP, etc.).
+need_refresh — Indicates if the account requires reauthorization.
+
+Usage Example
+This endpoint is useful when you want to:
+
+Retrieve a full list of all connected social media accounts.
+Identify which accounts may need to be refreshed or reconnected.
+Use the social_network_type and username to display connected networks in your app dashboard.
+
+Create Text Post
+Overview
+The Create Text Post endpoint allows you to schedule and publish text-based posts to one or multiple connected social accounts under a specific category. You can set the post content, assign it to a category, and define the date and time for scheduling.
+
+Base URL:
+
+https://www.oneupapp.io
+
+Endpoint
+POST /api/scheduletextpost
+
+Request Parameters
+Parameter	Required	Description
+apiKey	Yes	Your personal API key generated from the API Access page.
+category_id	Yes	The ID of the category that groups your target social accounts.
+social_network_id	Yes	A JSON array of social network IDs where the post will be published. You can also set the value to ALL to publish the post across all accounts enabled for the selected category.
+scheduled_date_time	Yes	The date and time (in YYYY-MM-DD HH:MM format) when the post should be published.
+title	No	The title of your post.
+content	Yes	The text content of your post.
+first_comment	No	The first comment to be added to the post (optional and only for Facebook, Instagram, LinkedIn, and YouTube).
+Sample Request
+curl --location --request POST \
+"https://www.oneupapp.io/api/scheduletextpost" \
+--data-urlencode "apiKey=621544d93ffe2db52b01" \
+--data-urlencode "category_id=49839" \
+--data-urlencode 'social_network_id=["pin_kumarvishi","accounts/116185162672310389659/locations/1366069594757511498"]' \
+--data-urlencode "scheduled_date_time=2025-10-23 14:00" \
+--data-urlencode "title=Hello World Title" \
+--data-urlencode "content=Hello World! This is a scheduled post."
+
+
+Sample Response
+{
+  "message": "1 new Posts Scheduled.",
+  "error": false,
+  "data": []
+}
+
+✅ Result: Your post has been successfully scheduled! The message confirms that the post is queued for publishing at the specified date and time.
+
+Platform Support & Limitations
+Network	Character Limit	Notes
+Facebook	10,000	Full text supported with formatting
+X(Twitter)	280	25,000 for premium accounts
+LinkedIn	3,000	Supports formatting like bold, italic
+Instagram	2,200	For feed post captions
+Google Business	1,500	For business updates
+Pinterest	500	For pin descriptions
+Threads	500	Maximum length
+Bluesky	300	Maximum length
+Tips & Notes
+Make sure your target social accounts are active and not expired before scheduling.
+The social_network_id must exactly match the account IDs retrieved from the List Category Accounts or List Social Accounts endpoints.
+For immediate publishing, you can set the scheduled_date_time to the current timestamp.
+Avoid overloading with too many simultaneous posts to prevent API rate limiting.
+
+Create Image Post
+Overview
+The Create Image Post endpoint allows you to schedule and publish image-based posts to one or multiple connected social accounts under a specific category. You can set the post content, attach one or more images, assign it to a category, and define the date and time for scheduling.
+
+Base URL:
+
+https://www.oneupapp.io
+
+Endpoint
+POST /api/scheduleimagepost
+
+Request Parameters
+Parameter	Required	Description
+apiKey	Yes	Your personal API key generated from the API Access page.
+category_id	Yes	The ID of the category that groups your target social accounts.
+social_network_id	Yes	A JSON array of social network IDs where the post will be published. You can also set the value to ALL to publish the post across all accounts enabled for the selected category.
+scheduled_date_time	Yes	The date and time (in YYYY-MM-DD HH:MM format) when the post should be published.
+title	No	The title of your post.
+content	Yes	The text content of your post.
+image_url	Yes	The URL(s) of the image(s). Separate multiple images with ~~.
+first_comment	No	The first comment to be added to the post (optional and only for Facebook, Instagram, LinkedIn, and YouTube).
+Platform-Specific Parameters
+Some social networks support additional parameters for specific image post types:
+
+Instagram:
+
+instagram: A JSON object with the following option:
+isStory (boolean): Set to true to publish as an Instagram Story. Default: false
+Facebook:
+
+facebook: A JSON object with the following option:
+isStory (boolean): Set to true to publish as a Facebook Story. Default: false
+Snapchat:
+
+snapchat: A JSON object with the following option:
+isSpotLight (boolean): Set to true to publish as a Snapchat Spotlight. Default: false
+TikTok:
+
+tiktok: A JSON object with the following option:
+autoAddMusic (boolean): Set to true to automatically add music to the image post. Default: true
+Example with platform-specific parameters:
+
+curl --location --request POST \
+"https://www.oneupapp.io/api/scheduleimagepost" \
+--data-urlencode "apiKey=621544d93ffe2db52b01" \
+--data-urlencode "category_id=49839" \
+--data-urlencode 'social_network_id=["113024478527731"]' \
+--data-urlencode "scheduled_date_time=2026-12-12 13:13" \
+--data-urlencode "title=My Image Post" \
+--data-urlencode "content=Image post" \
+--data-urlencode "image_url=https://cdn.filestackcontent.com/BT933lwUSEKkmpfI9O57" \
+--data-urlencode 'instagram={"isStory":true}'
+
+Sample Response
+{
+  "message": "1 new Posts Scheduled.",
+  "error": false,
+  "data": []
+}
+
+✅ Result: Your image post (with one or multiple images) has been successfully scheduled! The message confirms that the post is queued for publishing at the specified date and time.
+
+Platform Photo Upload Limits
+Platform	Max Photos	Photo Size Limit	Caption Support	Notes
+Facebook	20	No restriction	Yes	Supports alt text, no restrictions on photo size.
+Instagram	10	8 MB	Yes	Minimum resolution: 320×320 px, automatically cropped.
+TikTok	35	No restriction	No	Cannot mix photos with GIFs or videos.
+Threads	20	8 MB	No	Cannot mix photos with GIFs or videos.
+X(Twitter)	4	5 MB	No	Supports only up to 4 photos per post.
+LinkedIn	9	No restriction	No	Photos and GIFs are supported, cannot mix with videos.
+Bluesky	4	1 MB	No	Supports up to 4 images per post, alt text available.
+Tips & Notes
+Make sure your target social accounts are active and not expired before scheduling.
+The social_network_id must match the account IDs retrieved from the List Category Accounts or List Social Accounts endpoints.
+Ensure all image_urls are publicly accessible and point directly to image files.
+Use ~~ to separate multiple images in the image_url parameter.
+Avoid overloading with too many simultaneous posts to prevent API rate limiting.
+When using platform-specific parameters, ensure the JSON is properly formatted and URL-encoded in the request.
+
+Create Video Post
+Overview
+The Create Video Post endpoint allows you to schedule and publish video-based posts to one or multiple connected social accounts under a specific category. You can set the post content, attach a video URL, assign it to a category, and define the date and time for scheduling.
+
+Base URL:
+
+https://www.oneupapp.io
+
+Endpoint
+POST /api/schedulevideopost
+
+Request Parameters
+Parameter	Required	Description
+apiKey	Yes	Your personal API key generated from the API Access page.
+category_id	Yes	The ID of the category that groups your target social accounts.
+social_network_id	Yes	A JSON array of social network IDs where the post will be published. You can also set the value to ALL to publish the post across all accounts enabled for the selected category.
+scheduled_date_time	Yes	The date and time (in YYYY-MM-DD HH:MM format) when the post should be published.
+title	No	The title of your post.
+content	Yes	The text content of your post.
+video_url	Yes	The URL to the video you want to attach to the post.
+thumbnail_url	No	The URL of the thumbnail image for video posts (optional and only for video posts).
+first_comment	No	The first comment to be added to the post (optional and only for Facebook, Instagram, LinkedIn, and YouTube).
+Platform-Specific Parameters
+Some social networks support additional parameters for specific video post types:
+
+Instagram:
+
+instagram: A JSON object with the following option:
+isStory (boolean): Set to true to publish as an Instagram Story. Default: false
+Facebook:
+
+facebook: A JSON object with the following option:
+isStory (boolean): Set to true to publish as a Facebook Story. Default: false
+Snapchat:
+
+snapchat: A JSON object with the following option:
+isSpotLight (boolean): Set to true to publish as a Snapchat Spotlight. Default: false
+Example with platform-specific parameters:
+
+curl --location --request POST \
+"https://www.oneupapp.io/api/schedulevideopost" \
+--data-urlencode "apiKey=621544d93ffe2db52b01" \
+--data-urlencode "category_id=49839" \
+--data-urlencode 'social_network_id=["17841408823790514"]' \
+--data-urlencode "scheduled_date_time=2026-12-12 13:13" \
+--data-urlencode "title=My Video Post" \
+--data-urlencode "content=Video post from API" \
+--data-urlencode "video_url=https://cdn.filestackcontent.com/tpVlPE0qT7u4TwyPoA1M" \
+--data-urlencode 'instagram={"isStory":true}'
+
+Sample Response
+{
+  "message": "1 new Posts Scheduled.",
+  "error": false,
+  "data": []
+}
+
+✅ Result: Your video post has been successfully scheduled! The message confirms that the post is queued for publishing at the specified date and time.
+
+Tips & Notes
+Ensure your target social accounts are active and not expired before scheduling.
+The social_network_id must exactly match the account IDs retrieved from the List Category Accounts or List Social Accounts endpoints.
+The video_url must be publicly accessible and point directly to a video file.
+For immediate publishing, set scheduled_date_time to the current timestamp.
+Avoid overloading with too many simultaneous posts to prevent API rate limiting.
+When using platform-specific parameters, ensure the JSON is properly formatted and URL-encoded in the request.

social_media_publishers/oneup_client.py

@@ -0,0 +1,125 @@
+import requests
+from typing import Dict, Any, List, Optional
+from src.utils import logger
+from src.config import get_config_value
+
+class OneUpClient:
+    """
+    Client for interacting with the OneUp API.
+    Docs: https://www.oneupapp.io/api-doc
+    """
+    BASE_URL = "https://www.oneupapp.io/api"
+
+    def __init__(self, api_key: str = None):
+        self.api_key = api_key or get_config_value("ONEUP_API_KEY")
+        if not self.api_key:
+            raise ValueError("ONEUP_API_KEY is required but not found in config/env")
+
+    def _get_headers(self) -> Dict[str, str]:
+        """Header not typically used for auth in OneUp (query param), but good practice."""
+        return {}
+
+    def _make_request(self, method: str, endpoint: str, params: Dict[str, Any] = None, data: Dict[str, Any] = None) -> Dict[str, Any]:
+        """Common request handler with error checking."""
+        url = f"{self.BASE_URL}{endpoint}"
+        if params is None:
+            params = {}
+        
+        # Always inject apiKey
+        params["apiKey"] = self.api_key
+
+        try:
+            response = requests.request(method, url, params=params, data=data) 
+            # Note: OneUp API often uses query params even for POSTs according to docs, 
+            # or x-www-form-urlencoded. Docs say: --data-urlencode
+            # requests 'data' arg sends form-encoded by default.
+            
+            response.raise_for_status()
+            result = response.json()
+            
+            if result.get("error"):
+                raise Exception(f"OneUp API Error: {result.get('message', 'Unknown error')}")
+                
+            return result
+        except requests.exceptions.RequestException as e:
+            logger.error(f"❌ OneUp API Request Failed ({endpoint}): {e}")
+            if e.response:
+                logger.error(f"Response: {e.response.text}")
+            raise
+
+    def get_categories(self) -> List[Dict[str, Any]]:
+        """List all categories."""
+        response = self._make_request("GET", "/listcategory")
+        return response.get("data", [])
+
+    def get_accounts_in_category(self, category_id: int) -> List[Dict[str, Any]]:
+        """List accounts in a specific category."""
+        params = {"category_id": category_id}
+        response = self._make_request("GET", "/listcategoryaccount", params=params)
+        return response.get("data", [])
+
+    def schedule_video_post(
+        self,
+        category_id: int,
+        social_network_ids: List[str],
+        video_url: str,
+        title: str = "",
+        content: str = "",
+        scheduled_date_time: str = None, # YYYY-MM-DD HH:MM
+        publish_now: bool = False
+    ) -> Dict[str, Any]:
+        """
+        Schedule a video post.
+        
+        Args:
+            category_id: Target category ID
+            social_network_ids: List of account IDs or ["ALL"]
+            video_url: Public URL of the video
+            title: Post title
+            content: Post text/caption
+            scheduled_date_time: "YYYY-MM-DD HH:MM"
+            publish_now: If True, uses current time to publish immediately (overrides scheduled_date_time)
+        """
+        from datetime import datetime
+
+        if publish_now:
+            scheduled_date_time = datetime.now().strftime("%Y-%m-%d %H:%M")
+        elif not scheduled_date_time:
+            raise ValueError("Must provide either scheduled_date_time or publish_now=True")
+
+        import json
+        
+        # OneUp expects social_network_id as a JSON array string
+        # e.g. '["all"]' or '["id1", "id2"]'
+        # If the user passes ["ALL"] or ["all"], we respect that to post to all accounts in category
+        social_network_id_str = json.dumps(social_network_ids)
+
+        data = {
+            "category_id": category_id,
+            "social_network_id": social_network_id_str, # This needs to be passed in body/params
+            "scheduled_date_time": scheduled_date_time,
+            "title": title,
+            "content": content,
+            "video_url": video_url
+        }
+        
+        # NOTE: The docs example shows data-urlencode for everything including apiKey.
+        # But we pass apiKey in query params via _make_request helper.
+        # We'll pass the rest in 'data' which requests handles as form-encoded.
+        
+        return self._make_request("POST", "/schedulevideopost", data=data)
+
+if __name__ == "__main__":
+    # Test block
+    try:
+        client = OneUpClient()
+        cats = client.get_categories()
+        print(f"Categories: {len(cats)}")
+        for c in cats:
+            print(f"- {c['id']}: {c['category_name']}")
+            accounts = client.get_accounts_in_category(c['id'])
+            print(f"  Accounts: {len(accounts)}")
+            for a in accounts:
+                print(f"  - {a.get('social_network_name')} ({a.get('social_network_type')})")
+    except Exception as e:
+        print(f"Test failed: {e}")

social_media_publishers/publisher.py

@@ -1,8 +1,7 @@
 """
 publisher.py
-Unified social media publisher for all platforms.
-Lists videos from GCS, publishes to all platforms, logs to Google Sheets.
-Runs 3x daily via GitHub Actions.
+Unified social media publisher using OneUp API.
+Lists videos from GCS, generates public URLs, and publishes via OneUp.
 """
 
 import sys
@@ -18,38 +17,12 @@ from src.config import get_config_value
 from src.google_src.gcs_utils import list_gcs_files, find_and_download_gcs_file, upload_file_to_gcs
 from src.google_src.google_sheet import GoogleSheetReader
 from src.utils import logger
-
-# Initialize configuration
-# Config is lazily loaded via ConfigProxy
-
-# Available platforms to publish to (can be filtered via env var)
-ALL_PLATFORMS = ["youtube", "tiktok", "instagram", "facebook"]
-
-def get_active_platforms() -> List[str]:
-    """Get list of active platforms from env var or default to all."""
-    platforms_env = get_config_value("SOCIAL_MEDIA_PUBLISH_PLATFORMS")
-    if platforms_env:
-        requested = [p.strip().lower() for p in platforms_env.split(",") if p.strip()]
-        return [p for p in requested if p in ALL_PLATFORMS]
-    return ALL_PLATFORMS
-
-PLATFORMS = get_active_platforms()
+from social_media_publishers.oneup_client import OneUpClient
 
 # GSheet columns for publisher logs
 LOG_HEADER = ["Timestamp", "Platform", "Published File", "Published URL", "Account", "Status", "Error"]
 
 
-def get_upload_limit() -> Optional[int]:
-    """Get upload limit from env var. Returns None if no limit set."""
-    limit = get_config_value("SOCIAL_MEDIA_PUBLISHER_UPLOAD_LIMIT")
-    if limit:
-        try:
-            return int(limit)
-        except ValueError:
-            return None
-    return None
-
-
 def get_publisher_logs_worksheet() -> GoogleSheetReader:
     """Get GoogleSheetReader for publisher logs worksheet."""
     worksheet_name = get_config_value("publisher_logs_worksheet")
@@ -77,157 +50,96 @@ def load_published_files() -> set:
 
 def log_publish_result(
     gcs_filename: str,
-    platform: str,
     result: Dict[str, Any],
-    account: str = ""
+    account_info: str = "OneUp"
 ):
     """Log publish result to Google Sheets."""
     try:
         reader = get_publisher_logs_worksheet()
         
-        status = "success" if result.get("success") else "error"
-        published_url = result.get("url", result.get("video_url", ""))
-        error_msg = result.get("error", "")
+        # OneUp returns error inside the dict sometimes, checking success key if exists or manual check
+        # OneUp response: {"message": "...", "error": false, ...}
+        
+        is_error = result.get("error", False)
+        status = "success" if not is_error else "error"
+        error_msg = result.get("message") if is_error else ""
+        
+        # Determine published URL (OneUp doesn't return the post URL immediately always, 
+        # so we log the message or generic success)
+        published_url = "Scheduled/Published via OneUp"
         
         reader.create_or_update_sheet(
             header=LOG_HEADER,
             values=[{
                 "Timestamp": datetime.now().isoformat(),
-                "Platform": platform,
+                "Platform": "OneUp (All)",
                 "Published File": gcs_filename,
                 "Published URL": published_url,
-                "Account": account,
+                "Account": account_info,
                 "Status": status,
                 "Error": error_msg
             }]
         )
-        logger.info(f"✓ Logged {platform} publish result to GSheet")
+        logger.info(f"✓ Logged result to GSheet")
     except Exception as e:
         logger.error(f"❌ Failed to log to GSheet: {e}")
 
 
-def get_connected_accounts(platform: str) -> List[Dict[str, Any]]:
-    """Get list of connected accounts for a platform."""
-    try:
-        from social_media_publishers.factory import PublisherFactory
-        creator = PublisherFactory.get_auth_creator(platform)
-        return creator.list_connected_accounts()
-    except Exception as e:
-        logger.warning(f"⚠️ Could not list {platform} accounts: {e}")
-        return []
-
-
-def get_last_used_account(platform: str) -> Optional[str]:
-    """Get the last used account for a platform from GSheet logs."""
-    try:
-        reader = get_publisher_logs_worksheet()
-        df = reader.get_dataframe()
-        
-        if "Platform" in df.columns and "Account" in df.columns:
-            # Filter by platform and successful publishes
-            platform_df = df[df["Platform"] == platform]
-            if "Status" in df.columns:
-                platform_df = platform_df[platform_df["Status"] == "success"]
-            
-            if not platform_df.empty:
-                # Get the most recent account used
-                last_account = platform_df.iloc[-1]["Account"]
-                return last_account if last_account else None
-        return None
-    except Exception as e:
-        logger.warning(f"⚠️ Could not get last used account for {platform}: {e}")
-        return None
-
-
-def get_next_account_round_robin(platform: str, accounts: List[Dict[str, Any]]) -> Dict[str, Any]:
+def run_publisher():
     """
-    Get the next account in round-robin order for a platform.
-    Tracks last used account from GSheet and rotates to the next one.
+    Main publisher workflow using OneUp:
+    1. Initialize OneUp Client.
+    2. Get first category and target accounts ["ALL"].
+    3. List videos from GCS.
+    4. Check which are already published.
+    5. For each unpublished video:
+       - Download (to verify/process if needed, or simply get GCS public link).
+       - Ensure public URL exists (upload to GCS public bucket/path).
+       - Publish via OneUp (publish_now=True).
+       - Log results.
     """
-    if not accounts:
-        return None
-    
-    if len(accounts) == 1:
-        return accounts[0]
-    
-    # Get last used account
-    last_used = get_last_used_account(platform)
-    
-    if not last_used:
-        # No previous publish, use first account
-        logger.info(f"🔄 {platform}: No previous publish, using first account")
-        return accounts[0]
-    
-    # Find the index of the last used account
-    account_names = [acc.get("name", "") for acc in accounts]
+    logger.info("🚀 Starting OneUp Publisher Integration...")
     
+    # Initialize Client
     try:
-        last_index = account_names.index(last_used)
-        # Get next account (wrap around)
-        next_index = (last_index + 1) % len(accounts)
-        logger.info(f"🔄 {platform}: Round-robin from '{last_used}' to '{account_names[next_index]}'")
-        return accounts[next_index]
-    except ValueError:
-        # Last used account not found in current list, use first
-        logger.info(f"🔄 {platform}: Last account not found, using first account")
-        return accounts[0]
-
+        client = OneUpClient()
+    except Exception as e:
+        logger.error(f"❌ Failed to initialize OneUpClient: {e}")
+        return
 
-def publish_to_platform(
-    platform: str,
-    video_path: str,
-    gcs_filename: str,
-    account_id: str,
-    caption: str = ""
-) -> Dict[str, Any]:
-    """Publish video to a specific platform."""
+    # 1. Get Category (Default: First one)
     try:
-        from social_media_publishers.factory import PublisherFactory
+        categories = client.get_categories()
+        if not categories:
+            logger.error("❌ No categories found in OneUp account.")
+            return
         
-        publisher = PublisherFactory.get_publisher(platform)
-        publisher.authenticate(account_id=account_id)
+        target_category = categories[0]
+        category_id = target_category['id']
+        category_name = target_category['category_name']
+        logger.info(f"✅ Selected Category: {category_name} (ID: {category_id})")
         
-        # Instagram needs public URL, not local file
-        if platform == "instagram":
-            uploaded = upload_file_to_gcs(
-                video_path,
-                account_name="final_data",
-                generate_signed_url=False,
-                fallback_to_drive=False,
-                save_in_drive_also=False
-            )
-            content_path = uploaded.get("public_url", video_path)
-        else:
-            content_path = video_path
-        
-        # Prepare metadata
-        metadata = {
-            "title": caption or "Check this out! 🔥",
-            "description": caption or "#shorts #viral",
-            "caption": caption or "Check this out! 🔥",
-            "privacy_status": "public" if get_config_value('video_publish_public') else "private",
-            "privacy_level": "PUBLIC_TO_EVERYONE" if get_config_value('video_publish_public') else "SELF_ONLY",  # TikTok
-        }
-        
-        result = publisher.publish(content_path, metadata)
-        return result
+    except Exception as e:
+        logger.error(f"❌ Failed to fetch categories: {e}")
+        return
+
+    # 2. Target Accounts
+    # Strategy: "all the accounts in the category" -> pass ["ALL"]
+    # We can fetch accounts just to log them for visibility
+    try:
+        accounts = client.get_accounts_in_category(category_id)
+        account_names = [f"{a.get('social_network_name')} ({a.get('social_network_type')})" for a in accounts]
+        logger.info(f"👥 Target Accounts in Category ({len(accounts)}): {', '.join(account_names)}")
         
+        if not accounts:
+            logger.warning("⚠️ No accounts found in this category. Publishing might fail.")
+            
     except Exception as e:
-        logger.error(f"❌ {platform} publish failed: {e}")
-        return {"error": str(e)}
+        logger.warning(f"⚠️ Could not list accounts (proceeding with 'ALL'): {e}")
 
+    target_social_network_ids = ["ALL"] # As per requirement/spec
 
-def run_publisher():
-    """
-    Main publisher workflow:
-    1. List videos from GCS
-    2. Check which are already published (from GSheet)
-    3. Publish unpublished videos to all platforms
-    4. Log results to GSheet
-    """
-    logger.info("🚀 Starting unified publisher...")
-    
-    # Get all videos from GCS
+    # 3. Get / Filter Videos
     gcs_files = list_gcs_files()
     logger.info(f"📁 Found {len(gcs_files)} videos in GCS")
     
@@ -235,41 +147,15 @@ def run_publisher():
         logger.info("✅ No videos to publish")
         return
     
-    # Load already published files
     published = load_published_files()
-    
-    # Filter to unpublished videos
     unpublished = [f for f in gcs_files if f not in published]
     logger.info(f"🆕 {len(unpublished)} unpublished videos to process")
     
     if not unpublished:
         logger.info("✅ All videos already published")
         return
-    
-    # Get connected accounts for each platform (with round-robin selection)
-    platform_accounts = {}
-    all_platform_accounts = {}  # Store all accounts for round-robin
-    upload_limit = get_upload_limit()
-    platform_upload_counts = {}  # Track uploads per platform (int)
-
-    for platform in PLATFORMS:
-        accounts = get_connected_accounts(platform)
-        if accounts:
-            all_platform_accounts[platform] = accounts
-            # Select next account using round-robin
-            next_account = get_next_account_round_robin(platform, accounts)
-            platform_accounts[platform] = next_account
-            platform_upload_counts[platform] = 0
-            limit_str = f"limit: {upload_limit}" if upload_limit is not None else "no limit"
-            logger.info(f"✓ {platform}: {next_account.get('name', 'connected')} ({limit_str})")
-        else:
-            logger.warning(f"⚠️ No connected account for {platform}")
-    
-    if not platform_accounts:
-        logger.error("❌ No connected accounts found for any platform")
-        return
-    
-    # Process each unpublished video
+        
+    # 4. Publish Workflow
     success_count = 0
     
     for idx, gcs_filename in enumerate(unpublished):
@@ -277,120 +163,80 @@ def run_publisher():
         logger.info(f"📺 [{idx+1}/{len(unpublished)}] Processing: {gcs_filename}")
         logger.info(f"{'='*50}")
         
-
-        
-        # Download video from GCS
-        local_path = find_and_download_gcs_file(gcs_filename)
-        if not local_path or not os.path.exists(local_path):
-            logger.error(f"❌ Failed to download: {gcs_filename}")
-            continue
-        
-        # Generate caption from filename
-        basename = os.path.basename(gcs_filename)
-        caption = os.path.splitext(basename)[0].replace("_", " ")[:100]
-        
-        # Publish to each platform
-        video_success = False
-        for platform, account_info in list(platform_accounts.items()):
-            # Check upload limit
-            if upload_limit is not None and platform_upload_counts.get(platform, 0) >= upload_limit:
-                logger.info(f"⏭️ {platform}: Upload limit reached ({upload_limit}), skipping")
+        try:
+            # We need a PUBLIC URL for OneUp. 
+            # Existing GCS files might be private.
+            # We will download it and re-upload to a public path (or generate a signed URL if OneUp accepts it).
+            # OneUp spec says: "video_url must be publicly accessible".
+            # Signed URLs work but are temporary. Public bucket is better.
+            
+            # Download first to a local temp path
+            local_path = find_and_download_gcs_file(gcs_filename)
+            if not local_path or not os.path.exists(local_path):
+                logger.error(f"❌ Failed to download: {gcs_filename}")
                 continue
             
-            account_id = account_info.get("name", "")
+            # Generate Caption
+            basename = os.path.basename(gcs_filename)
+            caption = os.path.splitext(basename)[0].replace("_", " ")[:200]
             
-            logger.info(f"📤 Publishing to {platform} ({account_id})...")
+            # Re-upload to GCS (Public)
+            # We use a specific public bucket if configured, or same bucket but rely on public URL construction
+            # reusing existing logic for Instagram
+            logger.info("☁️ Uploading valid public link for OneUp...")
             
-            result = publish_to_platform(
-                platform=platform,
-                video_path=local_path,
-                gcs_filename=gcs_filename,
-                account_id=account_id,
-                caption=caption
+            uploaded = upload_file_to_gcs(
+                local_path,
+                account_name="final_data",
+                bucket_name=get_config_value("GCS_BUCKET_NAME_PUBLIC_FOR_SOCIAL_PUBLISH") or get_config_value("GCS_BUCKET_NAME"),
+                generate_signed_url=True,  # User requested signed URL preference
+                fallback_to_drive=False,
+                save_in_drive_also=False
             )
             
-            # Log result
-            log_publish_result(gcs_filename, platform, result, account_id)
+            video_url = uploaded.get("signed_url")
+            if not video_url:
+                # If public_url is empty, maybe try 'url' (signed)
+                video_url = uploaded.get("url")
+                logger.warning("⚠️ Using signed URL (might expire). Ensure bucket is public for best results.")
             
-            if result.get("success"):
-                logger.info(f"✅ {platform}: {result.get('url', 'Published')}")
-                video_success = True
-                platform_upload_counts[platform] = platform_upload_counts.get(platform, 0) + 1
-            else:
-                logger.warning(f"⚠️ {platform}: {result.get('error', 'Failed')}")
-        
-        # Stop if all platforms reached limit
-        if upload_limit is not None:
-            active_platforms = [p for p in platform_accounts if platform_upload_counts.get(p, 0) < upload_limit]
-            if not active_platforms:
-                logger.info("🏁 All platforms reached upload limits. Stopping.")
-                break
-        
-        if video_success:
+            logger.info(f"🔗 Video URL: {video_url}")
+            
+            # Publish
+            logger.info("📤 Sending to OneUp...")
+            result = client.schedule_video_post(
+                category_id=category_id,
+                social_network_ids=target_social_network_ids,
+                video_url=video_url,
+                title=caption,
+                content=caption,
+                publish_now=True
+            )
+            
+            logger.info(f"✅ OneUp Response: {result.get('message')}")
+            
+            # Log success
+            log_publish_result(gcs_filename, result, f"Category: {category_name}")
             success_count += 1
-        
-        # Cleanup downloaded file
-        try:
+            
+            # Cleanup
             if os.path.exists(local_path):
                 os.remove(local_path)
-        except:
-            pass
-    
-    logger.info(f"\n🏁 Publishing complete. {success_count}/{len(unpublished)} videos processed successfully.")
-
+                
+        except Exception as e:
+            logger.error(f"❌ Failed to publish {gcs_filename}: {e}")
+            log_publish_result(gcs_filename, {"error": True, "message": str(e)}, "Error")
 
-def pre_check():
-    """Validate required environment variables defined in publisher.env."""
-    
-    # Path to publisher.env (one level up from this file, then in root)
-    # publisher.py is in social_media_publishers/
-    # publisher.env is in root/
-    env_path = os.path.join(os.path.dirname(__file__), '..', 'publisher.env')
-    
-    if not os.path.exists(env_path):
-        logger.warning(f"⚠️ publisher.env not found at {env_path}. Skipping dynamic validation.")
-        return
+    logger.info(f"\n🏁 Publishing complete. {success_count}/{len(unpublished)} videos processed.")
 
-    missing = []
-    
-    try:
-        with open(env_path, 'r') as f:
-            for line in f:
-                line = line.strip()
-                if not line or line.startswith('#'):
-                    continue
-                
-                # Extract key (before the first =)
-                if '=' in line:
-                    key = line.split('=')[0].strip()
-                    # Use get_config_value because not all keys are mapped in config.py
-                    if key and not get_config_value(key):
-                        missing.append(key)
-                        
-    except Exception as e:
-        logger.error(f"❌ Failed to read publisher.env: {e}")
-        sys.exit(1)
 
-    if missing:
-        logger.error(f"❌ Missing required environment variables: {', '.join(missing)}")
-        sys.exit(1)
-        
-    logger.info("✅ Environment validation passed")
+def pre_check():
+    """Environment check."""
+    if not get_config_value("ONEUP_API_KEY"):
+         logger.error("❌ ONEUP_API_KEY is missing in configuration.")
+         sys.exit(1)
 
 
 if __name__ == "__main__":
     pre_check()
-    
-    # Get limit from env (workflow input)
-    limit = get_upload_limit()
-    
-    if limit is not None:
-        logger.info(f"🚀 Starting Publisher Workflow (Limit: {limit} per platform)...")
-    else:
-        logger.info("🚀 Starting Publisher Workflow (No Limit)...")
-        
-    try:
-        run_publisher()
-    except Exception as e:
-        logger.error(f"❌ Publisher Failed: {e}")
-        sys.exit(1)
+    run_publisher()

src/google_src/gcs_utils.py

@@ -176,6 +176,7 @@ def upload_file_to_gcs(
                 )
                 logger.info(f"✅ Signed URL generated")
                 result["url"] = signed_url
+                result["signed_url"] = signed_url
             except Exception as e:
                 logger.warning(f"⚠️ Failed to generate signed URL (using public URL): {e}")