instapost 0.2.0__tar.gz → 0.2.1__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: instapost
-Version: 0.2.0
+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

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

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

{instapost-0.2.0 → 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.2.0 → 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."""
@@ -40,8 +43,11 @@ class InstagramPoster(BaseInstagramClient):
         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):
+            logger.info("Detected local file, uploading to Catbox first")
             image = MediaUploader.upload_image(image)
 
         return self._image.post(image, caption)
@@ -78,11 +84,15 @@ class InstagramPoster(BaseInstagramClient):
         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):
+            logger.info("Detected local video, uploading to Catbox first")
             video = MediaUploader.upload_video(video)
 
         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, caption, cover, share_to_feed, timeout)
@@ -103,11 +113,13 @@ class InstagramPoster(BaseInstagramClient):
         Returns:
             API response with published media ID
         """
+        logger.info(f"Posting carousel with {len(media_items)} items")
         # Auto-upload local files
         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_items.append({

{instapost-0.2.0 → 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.2.0 → 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."""
@@ -19,8 +23,11 @@ class CarouselPoster(BaseInstagramClient):
         Returns:
             Container ID for publishing.
         """
+        logger.info(f"Uploading carousel with {len(media_items)} items to Instagram")
         if not self.MIN_ITEMS <= len(media_items) <= self.MAX_ITEMS:
-            raise ValueError(f"Carousel must have between {self.MIN_ITEMS} and {self.MAX_ITEMS} 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_items]
         return self._create_container({
@@ -31,11 +38,13 @@ class CarouselPoster(BaseInstagramClient):
 
     def post(self, media_items: list[dict], caption: str = "") -> dict:
         """Upload and publish a carousel."""
+        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.2.0 → 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.2.0 → 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.2.0 → instapost-0.2.1}/pyproject.toml

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