instapost 0.1.1__tar.gz → 0.2.1__tar.gz

{instapost-0.1.1 → instapost-0.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: instapost
-Version: 0.1.1
+Version: 0.2.1
 Summary: A Python library for automating Instagram posting (images, reels, carousels)
 Project-URL: Homepage, https://blaya.ia.br
 Project-URL: Repository, https://github.com/pedroluz/instapost
@@ -96,7 +96,7 @@ poster.post_reel(video="./video.mp4", caption="New reel! 🎬", share_to_feed=Tr
 
 # Post a carousel
 poster.post_carousel(
-    media_urls=[
+    media_items=[
         {"media": "./photo1.jpg", "type": "IMAGE"},
         {"media": "./video.mp4", "type": "VIDEO"},
     ],

{instapost-0.1.1 → instapost-0.2.1}/README.md

@@ -59,7 +59,7 @@ poster.post_reel(video="./video.mp4", caption="New reel! 🎬", share_to_feed=Tr
 
 # Post a carousel
 poster.post_carousel(
-    media_urls=[
+    media_items=[
         {"media": "./photo1.jpg", "type": "IMAGE"},
         {"media": "./video.mp4", "type": "VIDEO"},
     ],

{instapost-0.1.1 → instapost-0.2.1}/instapost/__init__.py

@@ -19,4 +19,4 @@ __all__ = [
     "ContainerProcessingError",
     "ContainerTimeoutError",
 ]
-__version__ = "0.1.0"
+__version__ = "0.2.1"

{instapost-0.1.1 → instapost-0.2.1}/instapost/api/base.py

@@ -1,9 +1,12 @@
+import logging
 import requests
 import time
 from abc import ABC, abstractmethod
 
 from ..exceptions import ContainerProcessingError, ContainerTimeoutError
 
+logger = logging.getLogger(__name__)
+
 
 class BaseInstagramClient(ABC):
     """Base class for Instagram API clients."""
@@ -18,47 +21,65 @@ class BaseInstagramClient(ABC):
         """Make a request to the Graph API."""
         url = f"{self.BASE_URL}/{endpoint}"
         kwargs.setdefault("params", {})["access_token"] = self.access_token
+        logger.debug(f"Making {method} request to {endpoint}")
         response = requests.request(method, url, **kwargs)
         response.raise_for_status()
+        logger.debug(f"{method} request to {endpoint} successful")
         return response.json()
 
     def _create_container(self, params: dict) -> str:
         """Create a media container and return its ID."""
+        logger.info(f"Creating media container with params: {params}")
         result = self._request("POST", "me/media", params=params)
-        return result["id"]
+        container_id = result["id"]
+        logger.info(f"Media container created with ID: {container_id}")
+        return container_id
 
     def _publish_container(self, container_id: str) -> dict:
         """Publish a media container."""
-        return self._request(
+        logger.info(f"Publishing media container {container_id}")
+        result = self._request(
             "POST",
             "me/media_publish",
             params={"creation_id": container_id},
         )
+        logger.info(f"Media container {container_id} published successfully")
+        return result
 
     def _wait_for_container(self, container_id: str, timeout: int = 60, interval: int = 5) -> None:
         """Wait for a media container to finish processing."""
+        logger.info(f"Waiting for container {container_id} to finish processing (timeout: {timeout}s)")
         elapsed = 0
         while elapsed < timeout:
             result = self._request("GET", container_id, params={"fields": "status_code,status"})
             status = result.get("status_code")
+            logger.debug(f"Container {container_id} status: {status}")
 
             if status == "FINISHED":
+                logger.info(f"Container {container_id} finished processing")
                 return
             if status == "ERROR":
-                raise ContainerProcessingError(f"Container processing failed: {result.get('status')}")
+                error_msg = f"Container processing failed: {result.get('status')}"
+                logger.error(error_msg)
+                raise ContainerProcessingError(error_msg)
 
             time.sleep(interval)
             elapsed += interval
 
-        raise ContainerTimeoutError(f"Container {container_id} did not finish processing in {timeout}s")
+        error_msg = f"Container {container_id} did not finish processing in {timeout}s"
+        logger.error(error_msg)
+        raise ContainerTimeoutError(error_msg)
 
     def verify(self) -> dict:
         """Verify credentials and return account info."""
-        return self._request(
+        logger.info("Verifying Instagram credentials")
+        result = self._request(
             "GET",
             "me",
             params={"fields": "id,username,name"},
         )
+        logger.info(f"Credentials verified for user: {result.get('username')}")
+        return result
 
     def publish(self, container_id: str) -> dict:
         """
@@ -70,6 +91,7 @@ class BaseInstagramClient(ABC):
         Returns:
             API response with the published media ID.
         """
+        logger.info(f"Publishing container {container_id}")
         return self._publish_container(container_id)
 
     @abstractmethod

{instapost-0.1.1 → instapost-0.2.1}/instapost/client.py

@@ -1,3 +1,4 @@
+import logging
 from typing import Optional
 import os
 
@@ -7,6 +8,8 @@ from .posting.reel import ReelPoster
 from .posting.carousel import CarouselPoster
 from .media.uploader import MediaUploader
 
+logger = logging.getLogger(__name__)
+
 
 class InstagramPoster(BaseInstagramClient):
     """Unified client for posting images, reels, and carousels to Instagram."""
@@ -26,93 +29,102 @@ class InstagramPoster(BaseInstagramClient):
         raise NotImplementedError("Use post_image, post_reel, or post_carousel instead")
 
     # Image methods
-    def upload_image(self, image_url: str, caption: str = "") -> str:
+    def upload_image(self, image: str, caption: str = "") -> str:
         """Upload a single image and return container ID."""
-        return self._image.upload(image_url, caption)
+        return self._image.upload(image, caption)
 
-    def post_image(self, image_url: str, caption: str = "") -> dict:
+    def post_image(self, image: str, caption: str = "") -> dict:
         """Upload and publish a single image.
 
         Args:
-            image_url: URL or local file path to image
+            image: URL or local file path to image
             caption: Optional caption
 
         Returns:
             API response with published media ID
         """
+        image_display = image[:50] + "..." if len(image) > 50 else image
+        logger.info(f"Posting image: {image_display}")
         # Auto-upload if local file
-        if os.path.exists(image_url):
-            image_url = MediaUploader.upload_image(image_url)
+        if os.path.exists(image):
+            logger.info("Detected local file, uploading to Catbox first")
+            image = MediaUploader.upload_image(image)
 
-        return self._image.post(image_url, caption)
+        return self._image.post(image, caption)
 
     # Reel methods
     def upload_reel(
         self,
-        video_url: str,
+        video: str,
         caption: str = "",
-        cover_url: Optional[str] = None,
+        cover: Optional[str] = None,
         share_to_feed: bool = True,
         timeout: int = 120,
     ) -> str:
         """Upload a reel and return container ID."""
-        return self._reel.upload(video_url, caption, cover_url, share_to_feed, timeout)
+        return self._reel.upload(video, caption, cover, share_to_feed, timeout)
 
     def post_reel(
         self,
-        video_url: str,
+        video: str,
         caption: str = "",
-        cover_url: Optional[str] = None,
+        cover: Optional[str] = None,
         share_to_feed: bool = True,
         timeout: int = 120,
     ) -> dict:
         """Upload and publish a reel.
 
         Args:
-            video_url: URL or local file path to video
+            video: URL or local file path to video
             caption: Optional caption
-            cover_url: Optional URL or local path to cover image
+            cover: Optional URL or local path to cover image
             share_to_feed: Whether to also share to feed
             timeout: Video processing timeout in seconds
 
         Returns:
             API response with published media ID
         """
+        video_display = video[:50] + "..." if len(video) > 50 else video
+        logger.info(f"Posting reel: {video_display}")
         # Auto-upload if local files
-        if os.path.exists(video_url):
-            video_url = MediaUploader.upload_video(video_url)
+        if os.path.exists(video):
+            logger.info("Detected local video, uploading to Catbox first")
+            video = MediaUploader.upload_video(video)
 
-        if cover_url and os.path.exists(cover_url):
-            cover_url = MediaUploader.upload_image(cover_url)
+        if cover and os.path.exists(cover):
+            logger.info("Detected local cover image, uploading to Catbox first")
+            cover = MediaUploader.upload_image(cover)
 
-        return self._reel.post(video_url, caption, cover_url, share_to_feed, timeout)
+        return self._reel.post(video, caption, cover, share_to_feed, timeout)
 
     # Carousel methods
-    def upload_carousel(self, media_urls: list[dict], caption: str = "") -> str:
+    def upload_carousel(self, media_items: list[dict], caption: str = "") -> str:
         """Upload a carousel and return container ID."""
-        return self._carousel.upload(media_urls, caption)
+        return self._carousel.upload(media_items, caption)
 
-    def post_carousel(self, media_urls: list[dict], caption: str = "") -> dict:
+    def post_carousel(self, media_items: list[dict], caption: str = "") -> dict:
         """Upload and publish a carousel.
 
         Args:
-            media_urls: List of dicts with 'media' (local file path or publicly accessible URL)
-                       and 'type' keys. Type must be 'IMAGE' or 'VIDEO'
+            media_items: List of dicts with 'media' (local file path or publicly accessible URL)
+                        and 'type' keys. Type must be 'IMAGE' or 'VIDEO'
             caption: Optional caption
 
         Returns:
             API response with published media ID
         """
+        logger.info(f"Posting carousel with {len(media_items)} items")
         # Auto-upload local files
-        processed_urls = []
-        for item in media_urls:
+        processed_items = []
+        for item in media_items:
             media = item['media']
             if os.path.exists(media):
+                logger.info("Detected local file in carousel, uploading to Catbox first")
                 media = MediaUploader.upload(media)
 
-            processed_urls.append({
+            processed_items.append({
                 'media': media,
                 'type': item['type']
             })
 
-        return self._carousel.post(processed_urls, caption)
+        return self._carousel.post(processed_items, caption)

{instapost-0.1.1 → instapost-0.2.1}/instapost/media/uploader.py

@@ -3,10 +3,13 @@ Media upload utilities for converting local files to public URLs.
 Uses Catbox for all file uploads (images and videos).
 """
 
+import logging
 import os
 import requests
 from pathlib import Path
 
+logger = logging.getLogger(__name__)
+
 
 class MediaUploader:
     """Upload local media files to Catbox and return public URLs."""
@@ -33,17 +36,22 @@ class MediaUploader:
             ValueError: If file type is not supported
             requests.RequestException: If upload fails
         """
+        logger.info(f"Uploading media file: {file_path}")
         if not os.path.exists(file_path):
-            raise FileNotFoundError(f"Media file not found: {file_path}")
+            error_msg = f"Media file not found: {file_path}"
+            logger.error(error_msg)
+            raise FileNotFoundError(error_msg)
 
         file_ext = Path(file_path).suffix.lower()
 
         # Validate file type
         if file_ext not in (cls.SUPPORTED_IMAGES | cls.SUPPORTED_VIDEOS):
-            raise ValueError(
+            error_msg = (
                 f"Unsupported file type: {file_ext}. "
                 f"Supported: {cls.SUPPORTED_IMAGES | cls.SUPPORTED_VIDEOS}"
             )
+            logger.error(error_msg)
+            raise ValueError(error_msg)
 
         return cls._upload_to_catbox(file_path)
 
@@ -58,12 +66,17 @@ class MediaUploader:
         Returns:
             Public URL of the uploaded image
         """
+        logger.info(f"Uploading image: {image_path}")
         if not os.path.exists(image_path):
-            raise FileNotFoundError(f"Image file not found: {image_path}")
+            error_msg = f"Image file not found: {image_path}"
+            logger.error(error_msg)
+            raise FileNotFoundError(error_msg)
 
         file_ext = Path(image_path).suffix.lower()
         if file_ext not in cls.SUPPORTED_IMAGES:
-            raise ValueError(f"Unsupported image format: {file_ext}")
+            error_msg = f"Unsupported image format: {file_ext}"
+            logger.error(error_msg)
+            raise ValueError(error_msg)
 
         return cls._upload_to_catbox(image_path)
 
@@ -78,12 +91,17 @@ class MediaUploader:
         Returns:
             Public URL of the uploaded video
         """
+        logger.info(f"Uploading video: {video_path}")
         if not os.path.exists(video_path):
-            raise FileNotFoundError(f"Video file not found: {video_path}")
+            error_msg = f"Video file not found: {video_path}"
+            logger.error(error_msg)
+            raise FileNotFoundError(error_msg)
 
         file_ext = Path(video_path).suffix.lower()
         if file_ext not in cls.SUPPORTED_VIDEOS:
-            raise ValueError(f"Unsupported video format: {file_ext}")
+            error_msg = f"Unsupported video format: {file_ext}"
+            logger.error(error_msg)
+            raise ValueError(error_msg)
 
         return cls._upload_to_catbox(video_path)
 
@@ -101,6 +119,7 @@ class MediaUploader:
         Raises:
             requests.RequestException: If upload fails
         """
+        logger.debug(f"Uploading to Catbox: {file_path}")
         with open(file_path, 'rb') as f:
             files = {'fileToUpload': f}
             data = {'reqtype': 'fileupload'}
@@ -110,6 +129,9 @@ class MediaUploader:
         url = response.text.strip()
 
         if not url or url.startswith('error'):
-            raise requests.RequestException(f"Catbox upload failed: {url}")
+            error_msg = f"Catbox upload failed: {url}"
+            logger.error(error_msg)
+            raise requests.RequestException(error_msg)
 
+        logger.info(f"Successfully uploaded to Catbox: {url}")
         return url

{instapost-0.1.1 → instapost-0.2.1}/instapost/posting/carousel.py

@@ -1,5 +1,9 @@
+import logging
+
 from ..api.base import BaseInstagramClient
 
+logger = logging.getLogger(__name__)
+
 
 class CarouselPoster(BaseInstagramClient):
     """Post carousels (multiple images/videos) to Instagram."""
@@ -7,35 +11,40 @@ class CarouselPoster(BaseInstagramClient):
     MIN_ITEMS = 2
     MAX_ITEMS = 10
 
-    def upload(self, media_urls: list[dict], caption: str = "") -> str:
+    def upload(self, media_items: list[dict], caption: str = "") -> str:
         """
         Upload a carousel to Instagram.
 
         Args:
-            media_urls: List of dicts with 'media' (local file path or publicly accessible URL)
-                       and 'type' ('IMAGE' or 'VIDEO') keys.
+            media_items: List of dicts with 'media' (local file path or publicly accessible URL)
+                        and 'type' ('IMAGE' or 'VIDEO') keys.
             caption: Optional caption for the carousel.
 
         Returns:
             Container ID for publishing.
         """
-        if not self.MIN_ITEMS <= len(media_urls) <= self.MAX_ITEMS:
-            raise ValueError(f"Carousel must have between {self.MIN_ITEMS} and {self.MAX_ITEMS} items")
+        logger.info(f"Uploading carousel with {len(media_items)} items to Instagram")
+        if not self.MIN_ITEMS <= len(media_items) <= self.MAX_ITEMS:
+            error_msg = f"Carousel must have between {self.MIN_ITEMS} and {self.MAX_ITEMS} items"
+            logger.error(error_msg)
+            raise ValueError(error_msg)
 
-        children_ids = [self._create_child(media) for media in media_urls]
+        children_ids = [self._create_child(media) for media in media_items]
         return self._create_container({
             "media_type": "CAROUSEL",
             "children": ",".join(children_ids),
             "caption": caption,
         })
 
-    def post(self, media_urls: list[dict], caption: str = "") -> dict:
+    def post(self, media_items: list[dict], caption: str = "") -> dict:
         """Upload and publish a carousel."""
-        return self.publish(self.upload(media_urls, caption))
+        logger.info("Publishing carousel post")
+        return self.publish(self.upload(media_items, caption))
 
     def _create_child(self, media: dict) -> str:
         """Create a child container for a carousel item."""
         media_type = media.get("type", "IMAGE").upper()
+        logger.debug(f"Creating carousel child item of type {media_type}")
         params = {"is_carousel_item": "true"}
 
         if media_type == "IMAGE":

{instapost-0.1.1 → instapost-0.2.1}/instapost/posting/image.py

@@ -1,5 +1,9 @@
+import logging
+
 from ..api.base import BaseInstagramClient
 
+logger = logging.getLogger(__name__)
+
 
 class ImagePoster(BaseInstagramClient):
     """Post single images to Instagram."""
@@ -15,8 +19,11 @@ class ImagePoster(BaseInstagramClient):
         Returns:
             Container ID for publishing.
         """
+        image_display = image[:50] + "..." if len(image) > 50 else image
+        logger.info(f"Uploading image to Instagram: {image_display}")
         return self._create_container({"image_url": image, "caption": caption})
 
     def post(self, image: str, caption: str = "") -> dict:
         """Upload and publish a single image."""
+        logger.info("Publishing image post")
         return self.publish(self.upload(image, caption))

{instapost-0.1.1 → instapost-0.2.1}/instapost/posting/reel.py

@@ -1,7 +1,10 @@
+import logging
 from typing import Optional
 
 from ..api.base import BaseInstagramClient
 
+logger = logging.getLogger(__name__)
+
 
 class ReelPoster(BaseInstagramClient):
     """Post reels to Instagram."""
@@ -27,6 +30,8 @@ class ReelPoster(BaseInstagramClient):
         Returns:
             Container ID for publishing.
         """
+        video_display = video[:50] + "..." if len(video) > 50 else video
+        logger.info(f"Uploading reel to Instagram: {video_display}")
         params = {
             "media_type": "REELS",
             "video_url": video,
@@ -49,4 +54,5 @@ class ReelPoster(BaseInstagramClient):
         timeout: int = 120,
     ) -> dict:
         """Upload and publish a reel."""
+        logger.info("Publishing reel post")
         return self.publish(self.upload(video, caption, cover, share_to_feed, timeout))

{instapost-0.1.1 → instapost-0.2.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "instapost"
-version = "0.1.1"
+version = "0.2.1"
 description = "A Python library for automating Instagram posting (images, reels, carousels)"
 readme = "README.md"
 requires-python = ">=3.10"

{instapost-0.1.1 → instapost-0.2.1}/tests/test_client.py

@@ -99,7 +99,7 @@ class TestInstagramPoster:
                 with patch.object(client._reel, 'post', return_value={'media_id': 'post_cover'}):
                     result = client.post_reel(
                         temp_video_file,
-                        cover_url=temp_image_file,
+                        cover=temp_image_file,
                         share_to_feed=True,
                         timeout=120
                     )
@@ -114,7 +114,7 @@ class TestInstagramPoster:
             container_id = client.upload_reel(
                 'https://example.com/video.mp4',
                 caption='Test reel',
-                cover_url='https://example.com/cover.jpg',
+                cover='https://example.com/cover.jpg',
                 share_to_feed=False,
                 timeout=60
             )
@@ -125,54 +125,54 @@ class TestInstagramPoster:
     def test_upload_carousel(self):
         """Test uploading a carousel."""
         client = InstagramPoster(access_token='token', ig_user_id='user')
-        media_urls = [
+        media_items = [
             {'media': 'https://example.com/img1.jpg', 'type': 'IMAGE'},
             {'media': 'https://example.com/img2.jpg', 'type': 'IMAGE'},
         ]
 
         with patch.object(client._carousel, 'upload', return_value='carousel_123'):
-            container_id = client.upload_carousel(media_urls)
+            container_id = client.upload_carousel(media_items)
 
             assert container_id == 'carousel_123'
 
     def test_post_carousel_urls(self):
         """Test posting a carousel from URLs."""
         client = InstagramPoster(access_token='token', ig_user_id='user')
-        media_urls = [
+        media_items = [
             {'media': 'https://example.com/img1.jpg', 'type': 'IMAGE'},
             {'media': 'https://example.com/img2.jpg', 'type': 'IMAGE'},
         ]
 
         with patch.object(client._carousel, 'post', return_value={'media_id': 'carousel_post'}):
-            result = client.post_carousel(media_urls)
+            result = client.post_carousel(media_items)
 
             assert result == {'media_id': 'carousel_post'}
 
     def test_post_carousel_local_files(self, temp_image_file):
         """Test posting a carousel with local files (auto-upload)."""
         client = InstagramPoster(access_token='token', ig_user_id='user')
-        media_urls = [
+        media_items = [
             {'media': temp_image_file, 'type': 'IMAGE'},
             {'media': 'https://example.com/img2.jpg', 'type': 'IMAGE'},
         ]
 
         with patch('instapost.client.MediaUploader.upload', return_value='https://catbox.moe/img1.jpg'):
             with patch.object(client._carousel, 'post', return_value={'media_id': 'carousel_post_2'}):
-                result = client.post_carousel(media_urls)
+                result = client.post_carousel(media_items)
 
                 assert result == {'media_id': 'carousel_post_2'}
 
     def test_post_carousel_mixed_local_and_urls(self, temp_image_file):
         """Test posting carousel with mix of local files and URLs."""
         client = InstagramPoster(access_token='token', ig_user_id='user')
-        media_urls = [
+        media_items = [
             {'media': temp_image_file, 'type': 'IMAGE'},
             {'media': 'https://example.com/video.mp4', 'type': 'VIDEO'},
         ]
 
         with patch('instapost.client.MediaUploader.upload', return_value='https://catbox.moe/uploaded.jpg'):
             with patch.object(client._carousel, 'post', return_value={'media_id': 'mixed_carousel'}):
-                result = client.post_carousel(media_urls, caption='Mixed carousel')
+                result = client.post_carousel(media_items, caption='Mixed carousel')
 
                 assert result == {'media_id': 'mixed_carousel'}
 

{instapost-0.1.1 → instapost-0.2.1}/tests/test_posting.py

@@ -94,46 +94,46 @@ class TestCarouselPoster:
     def test_upload_carousel_valid(self):
         """Test uploading a valid carousel."""
         poster = CarouselPoster(access_token='token', ig_user_id='user')
-        media_urls = [
+        media_items = [
             {'media': 'https://example.com/img1.jpg', 'type': 'IMAGE'},
             {'media': 'https://example.com/img2.jpg', 'type': 'IMAGE'},
         ]
 
         with patch.object(poster, '_create_child', side_effect=['child_1', 'child_2']):
             with patch.object(poster, '_create_container', return_value='carousel_123'):
-                container_id = poster.upload(media_urls, caption='Carousel')
+                container_id = poster.upload(media_items, caption='Carousel')
 
                 assert container_id == 'carousel_123'
 
     def test_upload_carousel_too_few_items(self):
         """Test carousel with too few items."""
         poster = CarouselPoster(access_token='token', ig_user_id='user')
-        media_urls = [
+        media_items = [
             {'media': 'https://example.com/img1.jpg', 'type': 'IMAGE'},
         ]
 
         with pytest.raises(ValueError, match='between'):
-            poster.upload(media_urls)
+            poster.upload(media_items)
 
     def test_upload_carousel_too_many_items(self):
         """Test carousel with too many items."""
         poster = CarouselPoster(access_token='token', ig_user_id='user')
-        media_urls = [{'media': f'https://example.com/img{i}.jpg', 'type': 'IMAGE'} for i in range(12)]
+        media_items = [{'media': f'https://example.com/img{i}.jpg', 'type': 'IMAGE'} for i in range(12)]
 
         with pytest.raises(ValueError, match='between'):
-            poster.upload(media_urls)
+            poster.upload(media_items)
 
     def test_upload_carousel_mixed_media(self):
         """Test carousel with mixed image and video."""
         poster = CarouselPoster(access_token='token', ig_user_id='user')
-        media_urls = [
+        media_items = [
             {'media': 'https://example.com/img1.jpg', 'type': 'IMAGE'},
             {'media': 'https://example.com/video1.mp4', 'type': 'VIDEO'},
         ]
 
         with patch.object(poster, '_create_child', side_effect=['child_1', 'child_2']):
             with patch.object(poster, '_create_container', return_value='carousel_456'):
-                container_id = poster.upload(media_urls)
+                container_id = poster.upload(media_items)
 
                 assert container_id == 'carousel_456'