fix: add cookies in gemini image temporary

Author: dsdanielpark

gemini/src/model/image.py

@@ -17,31 +17,41 @@ class GeminiImage(BaseModel):
     @classmethod
     def validate_images(cls, images):
         if not images:
-            raise ValueError("Input is empty. Please provide images to proceed.")
+            raise ValueError(
+                "Input is empty. Please provide images infomation to proceed."
+            )
+
+    # Async downloader
+    @classmethod
+    async def save(
+        cls,
+        images: List["GeminiImage"],
+        save_path: str = "cached",
+        cookies: Optional[dict] = None,
+    ) -> Optional[Path]:
+        cls.validate_images(images)
+        image_data = await cls.fetch_images_dict(images, cookies)
+        await cls.save_images(image_data, save_path)
 
     @staticmethod
-    async def fetch_bytes(url: HttpUrl) -> Optional[bytes]:
+    async def fetch_bytes(
+        url: HttpUrl, cookies: Optional[dict] = None
+    ) -> Optional[bytes]:
         try:
             async with httpx.AsyncClient(follow_redirects=True) as client:
-                response = await client.get(str(url))
+                response = await client.get(str(url), cookies=cookies)
                 response.raise_for_status()
                 return response.content
         except Exception as e:
             print(f"Failed to download {url}: {str(e)}")
             return None
 
     @classmethod
-    async def save(
-        cls, images: List["GeminiImage"], save_path: str = "cached"
-    ) -> Optional[Path]:
-        cls.validate_images(images)
-        image_data = await cls.fetch_images_dict(images)
-        await cls.save_images(image_data, save_path)
-
-    @classmethod
-    async def fetch_images_dict(cls, images: List["GeminiImage"]) -> Dict[str, bytes]:
+    async def fetch_images_dict(
+        cls, images: List["GeminiImage"], cookies: Optional[dict] = None
+    ) -> Dict[str, bytes]:
         cls.validate_images(images)
-        tasks = [cls.fetch_bytes(image.url) for image in images]
+        tasks = [cls.fetch_bytes(image.url, cookies=cookies) for image in images]
         results = await asyncio.gather(*tasks)
         return {image.title: result for image, result in zip(images, results) if result}
 
@@ -59,24 +69,27 @@ async def save_images(image_data: Dict[str, bytes], save_path: str = "cached"):
             except Exception as e:
                 print(f"Error saving {title}: {str(e)}")
 
+    # Sync downloader
     @staticmethod
-    def fetch_bytes_sync(url: HttpUrl) -> Optional[bytes]:
-        """Synchronously fetches the bytes data of an image from the given URL.
+    def save_sync(
+        images: List["GeminiImage"],
+        cookies: Optional[dict] = None,
+        save_path: str = "cached",
+    ) -> Optional[Path]:
+        """Synchronously saves the image to the specified path.
 
         Args:
-            url (str): The URL of the image.
+            path (str): The directory where the image will be saved.
+            filename (str, optional): The filename for the saved image. If not provided,
+                a filename is generated based on the image title.
+            cookies (dict, optional): Cookies to be used for downloading the image.
 
         Returns:
-            Optional[bytes]: The bytes data of the image, or None if fetching fails.
+            Optional[Path]: The path where the image is saved, or None if saving fails.
         """
-        try:
-            with httpx.Client(follow_redirects=True) as client:
-                response = client.get(str(url))
-                response.raise_for_status()
-                return response.content
-        except Exception as e:
-            print(f"Failed to download {url}: {str(e)}")
-            return None
+        image_data = GeminiImage.fetch_images_dict_sync(images, cookies)
+        GeminiImage.validate_images(image_data)
+        GeminiImage.save_images_sync(image_data, save_path)
 
     @staticmethod
     def fetch_bytes_sync(
@@ -95,27 +108,6 @@ def fetch_bytes_sync(
             print(f"Failed to download {url}: {str(e)}")
             pass
 
-    @staticmethod
-    def save_sync(
-        images: List["GeminiImage"],
-        cookies: Optional[dict] = None,
-        save_path: str = "cached",
-    ) -> Optional[Path]:
-        """Synchronously saves the image to the specified path.
-
-        Args:
-            path (str): The directory where the image will be saved.
-            filename (str, optional): The filename for the saved image. If not provided,
-                a filename is generated based on the image title.
-            cookies (dict, optional): Cookies to be used for downloading the image.
-
-        Returns:
-            Optional[Path]: The path where the image is saved, or None if saving fails.
-        """
-        image_data = GeminiImage.fetch_images_dict_sync(images, cookies)
-        GeminiImage.validate_images(image_data)
-        GeminiImage.save_images_sync(image_data, save_path)
-
     @staticmethod
     def fetch_images_dict_sync(
         images: List["GeminiImage"], cookies: Optional[dict] = None