gemini-webapi 1.14.3__py3-none-any.whl → 1.15.0__py3-none-any.whl

gemini_webapi/client.py

@@ -1,6 +1,4 @@
 import asyncio
-import functools
-import itertools
 import re
 from asyncio import Task
 from pathlib import Path
@@ -9,7 +7,8 @@ from typing import Any, Optional
 import orjson as json
 from httpx import AsyncClient, ReadTimeout, Response
 
-from .constants import Endpoint, ErrorCode, Headers, Model, GRPC
+from .components import GemMixin
+from .constants import Endpoint, ErrorCode, Headers, Model
 from .exceptions import (
     AuthError,
     APIError,
@@ -26,7 +25,6 @@ from .types import (
     Candidate,
     ModelOutput,
     Gem,
-    GemJar,
     RPCData,
 )
 from .utils import (
@@ -35,60 +33,13 @@ from .utils import (
     rotate_1psidts,
     get_access_token,
     load_browser_cookies,
+    running,
     rotate_tasks,
     logger,
 )
 
 
-def running(retry: int = 0) -> callable:
-    """
-    Decorator to check if client is running before making a request.
-
-    Parameters
-    ----------
-    retry: `int`, optional
-        Max number of retries when `gemini_webapi.APIError` is raised.
-    """
-
-    def decorator(func):
-        @functools.wraps(func)
-        async def wrapper(client: "GeminiClient", *args, retry=retry, **kwargs):
-            try:
-                if not client.running:
-                    await client.init(
-                        timeout=client.timeout,
-                        auto_close=client.auto_close,
-                        close_delay=client.close_delay,
-                        auto_refresh=client.auto_refresh,
-                        refresh_interval=client.refresh_interval,
-                        verbose=False,
-                    )
-                    if client.running:
-                        return await func(client, *args, **kwargs)
-
-                    # Should not reach here
-                    raise APIError(
-                        f"Invalid function call: GeminiClient.{func.__name__}. Client initialization failed."
-                    )
-                else:
-                    return await func(client, *args, **kwargs)
-            except APIError as e:
-                # Image generation takes too long, only retry once
-                if isinstance(e, ImageGenerationError):
-                    retry = min(1, retry)
-
-                if retry > 0:
-                    await asyncio.sleep(1)
-                    return await wrapper(client, *args, retry=retry - 1, **kwargs)
-
-                raise
-
-        return wrapper
-
-    return decorator
-
-
-class GeminiClient:
+class GeminiClient(GemMixin):
     """
     Async httpx client interface for gemini.google.com.
 
@@ -125,7 +76,7 @@ class GeminiClient:
         "close_task",
         "auto_refresh",
         "refresh_interval",
-        "_gems",
+        "_gems",  # From GemMixin
         "kwargs",
     ]
 
@@ -136,6 +87,7 @@ class GeminiClient:
         proxy: str | None = None,
         **kwargs,
     ):
+        super().__init__()
         self.cookies = {}
         self.proxy = proxy
         self.running: bool = False
@@ -147,7 +99,6 @@ class GeminiClient:
         self.close_task: Task | None = None
         self.auto_refresh: bool = True
         self.refresh_interval: float = 540
-        self._gems: GemJar | None = None
         self.kwargs = kwargs
 
         # Validate cookies
@@ -285,119 +236,6 @@ class GeminiClient:
                 self.cookies["__Secure-1PSIDTS"] = new_1psidts
             await asyncio.sleep(self.refresh_interval)
 
-    @property
-    def gems(self) -> GemJar:
-        """
-        Returns a `GemJar` object containing cached gems.
-        Only available after calling `GeminiClient.fetch_gems()`.
-
-        Returns
-        -------
-        :class:`GemJar`
-            Refer to `gemini_webapi.types.GemJar`.
-
-        Raises
-        ------
-        `RuntimeError`
-            If `GeminiClient.fetch_gems()` has not been called before accessing this property.
-        """
-
-        if self._gems is None:
-            raise RuntimeError(
-                "Gems not fetched yet. Call `GeminiClient.fetch_gems()` method to fetch gems from gemini.google.com."
-            )
-
-        return self._gems
-
-    async def fetch_gems(self, include_hidden: bool = False, **kwargs) -> GemJar:
-        """
-        Get a list of available gems from gemini, including system predefined gems and user-created custom gems.
-
-        Note that network request will be sent every time this method is called.
-        Once the gems are fetched, they will be cached and accessible via `GeminiClient.gems` property.
-
-        Parameters
-        ----------
-        include_hidden: `bool`, optional
-            There are some predefined gems that by default are not shown to users (and therefore may not work properly).
-            Set this parameter to `True` to include them in the fetched gem list.
-
-        Returns
-        -------
-        :class:`GemJar`
-            Refer to `gemini_webapi.types.GemJar`.
-        """
-
-        response = await self._batch_execute(
-            [
-                RPCData(
-                    rpcid=GRPC.LIST_GEMS,
-                    payload="[4]" if include_hidden else "[3]",
-                    identifier="system",
-                ),
-                RPCData(
-                    rpcid=GRPC.LIST_GEMS,
-                    payload="[2]",
-                    identifier="custom",
-                ),
-            ],
-            **kwargs,
-        )
-
-        try:
-            response_json = json.loads(response.text.split("\n")[2])
-
-            predefined_gems, custom_gems = [], []
-
-            for part in response_json:
-                if part[-1] == "system":
-                    predefined_gems = json.loads(part[2])[2]
-                elif part[-1] == "custom":
-                    if custom_gems_container := json.loads(part[2]):
-                        custom_gems = custom_gems_container[2]
-
-            if not predefined_gems and not custom_gems:
-                raise Exception
-        except Exception:
-            await self.close()
-            logger.debug(f"Invalid response: {response.text}")
-            raise APIError(
-                "Failed to fetch gems. Invalid response data received. Client will try to re-initialize on next request."
-            )
-
-        self._gems = GemJar(
-            itertools.chain(
-                (
-                    (
-                        gem[0],
-                        Gem(
-                            id=gem[0],
-                            name=gem[1][0],
-                            description=gem[1][1],
-                            prompt=gem[2] and gem[2][0] or None,
-                            predefined=True,
-                        ),
-                    )
-                    for gem in predefined_gems
-                ),
-                (
-                    (
-                        gem[0],
-                        Gem(
-                            id=gem[0],
-                            name=gem[1][0],
-                            description=gem[1][1],
-                            prompt=gem[2] and gem[2][0] or None,
-                            predefined=False,
-                        ),
-                    )
-                    for gem in custom_gems
-                ),
-            )
-        )
-
-        return self._gems
-
     @running(retry=2)
     async def generate_content(
         self,
@@ -454,7 +292,9 @@ class GeminiClient:
             model = Model.from_name(model)
 
         if isinstance(gem, Gem):
-            gem = gem.id
+            gem_id = gem.id
+        else:
+            gem_id = gem
 
         if self.auto_close:
             await self.reset_close_task()
@@ -487,7 +327,7 @@ class GeminiClient:
                                     None,
                                     chat and chat.metadata,
                                 ]
-                                + (gem and [None] * 16 + [gem] or [])
+                                + (gem_id and [None] * 16 + [gem_id] or [])
                             ).decode(),
                         ]
                     ).decode(),
@@ -611,10 +451,21 @@ class GeminiClient:
                         generated_images = [
                             GeneratedImage(
                                 url=generated_image[0][3][3],
-                                title=f"[Generated Image {generated_image[3][6]}]",
-                                alt=len(generated_image[3][5]) > image_index
-                                and generated_image[3][5][image_index]
-                                or generated_image[3][5][0],
+                                title=(
+                                    f"[Generated Image {generated_image[3][6]}]"
+                                    if generated_image[3][6]
+                                    else "[Generated Image]"
+                                ),
+                                alt=(
+                                    generated_image[3][5][image_index]
+                                    if generated_image[3][5]
+                                    and len(generated_image[3][5]) > image_index
+                                    else (
+                                        generated_image[3][5][0]
+                                        if generated_image[3][5]
+                                        else ""
+                                    )
+                                ),
                                 proxy=self.proxy,
                                 cookies=self.cookies,
                             )
@@ -667,7 +518,6 @@ class GeminiClient:
 
         return ChatSession(geminiclient=self, **kwargs)
 
-    @running(retry=2)
     async def _batch_execute(self, payloads: list[RPCData], **kwargs) -> Response:
         """
         Execute a batch of requests to Gemini API.
@@ -703,12 +553,10 @@ class GeminiClient:
                 "consider setting a higher `timeout` value when initializing GeminiClient."
             )
 
+        # ? Seems like batch execution will immediately invalidate the current access token,
+        # ? causing the next request to fail with 401 Unauthorized.
         if response.status_code != 200:
-            logger.debug(
-                f"Batch execution failed with status code {response.status_code}. "
-                f"RPC: {', '.join({payload.rpcid.name for payload in payloads})}; "
-                f"Invalid response: {response.text}"
-            )
+            await self.close()
             raise APIError(
                 f"Batch execution failed with status code {response.status_code}"
             )

gemini_webapi/components/__init__.py

@@ -0,0 +1,3 @@
+# flake8: noqa
+
+from .gem_mixin import GemMixin

gemini_webapi/components/gem_mixin.py

@@ -0,0 +1,288 @@
+import itertools
+
+import orjson as json
+
+from ..constants import GRPC
+from ..exceptions import APIError
+from ..types import Gem, GemJar, RPCData
+from ..utils import running, logger
+
+
+class GemMixin:
+    """
+    Mixin class providing gem-related functionality for GeminiClient.
+    """
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self._gems: GemJar | None = None
+
+    @property
+    def gems(self) -> GemJar:
+        """
+        Returns a `GemJar` object containing cached gems.
+        Only available after calling `GeminiClient.fetch_gems()`.
+
+        Returns
+        -------
+        :class:`GemJar`
+            Refer to `gemini_webapi.types.GemJar`.
+
+        Raises
+        ------
+        `RuntimeError`
+            If `GeminiClient.fetch_gems()` has not been called before accessing this property.
+        """
+
+        if self._gems is None:
+            raise RuntimeError(
+                "Gems not fetched yet. Call `GeminiClient.fetch_gems()` method to fetch gems from gemini.google.com."
+            )
+
+        return self._gems
+
+    @running(retry=2)
+    async def fetch_gems(self, include_hidden: bool = False, **kwargs) -> GemJar:
+        """
+        Get a list of available gems from gemini, including system predefined gems and user-created custom gems.
+
+        Note that network request will be sent every time this method is called.
+        Once the gems are fetched, they will be cached and accessible via `GeminiClient.gems` property.
+
+        Parameters
+        ----------
+        include_hidden: `bool`, optional
+            There are some predefined gems that by default are not shown to users (and therefore may not work properly).
+            Set this parameter to `True` to include them in the fetched gem list.
+
+        Returns
+        -------
+        :class:`GemJar`
+            Refer to `gemini_webapi.types.GemJar`.
+        """
+
+        response = await self._batch_execute(
+            [
+                RPCData(
+                    rpcid=GRPC.LIST_GEMS,
+                    payload="[4]" if include_hidden else "[3]",
+                    identifier="system",
+                ),
+                RPCData(
+                    rpcid=GRPC.LIST_GEMS,
+                    payload="[2]",
+                    identifier="custom",
+                ),
+            ],
+            **kwargs,
+        )
+
+        try:
+            response_json = json.loads(response.text.split("\n")[2])
+
+            predefined_gems, custom_gems = [], []
+
+            for part in response_json:
+                if part[-1] == "system":
+                    predefined_gems = json.loads(part[2])[2]
+                elif part[-1] == "custom":
+                    if custom_gems_container := json.loads(part[2]):
+                        custom_gems = custom_gems_container[2]
+
+            if not predefined_gems and not custom_gems:
+                raise Exception
+        except Exception:
+            await self.close()
+            logger.debug(f"Invalid response: {response.text}")
+            raise APIError(
+                "Failed to fetch gems. Invalid response data received. Client will try to re-initialize on next request."
+            )
+
+        self._gems = GemJar(
+            itertools.chain(
+                (
+                    (
+                        gem[0],
+                        Gem(
+                            id=gem[0],
+                            name=gem[1][0],
+                            description=gem[1][1],
+                            prompt=gem[2] and gem[2][0] or None,
+                            predefined=True,
+                        ),
+                    )
+                    for gem in predefined_gems
+                ),
+                (
+                    (
+                        gem[0],
+                        Gem(
+                            id=gem[0],
+                            name=gem[1][0],
+                            description=gem[1][1],
+                            prompt=gem[2] and gem[2][0] or None,
+                            predefined=False,
+                        ),
+                    )
+                    for gem in custom_gems
+                ),
+            )
+        )
+
+        return self._gems
+
+    @running(retry=2)
+    async def create_gem(self, name: str, prompt: str, description: str = "") -> Gem:
+        """
+        Create a new custom gem.
+
+        Parameters
+        ----------
+        name: `str`
+            Name of the custom gem.
+        prompt: `str`
+            System instructions for the custom gem.
+        description: `str`, optional
+            Description of the custom gem (has no effect on the model's behavior).
+
+        Returns
+        -------
+        :class:`Gem`
+            The created gem.
+        """
+
+        response = await self._batch_execute(
+            [
+                RPCData(
+                    rpcid=GRPC.CREATE_GEM,
+                    payload=json.dumps(
+                        [
+                            [
+                                name,
+                                description,
+                                prompt,
+                                None,
+                                None,
+                                None,
+                                None,
+                                None,
+                                0,
+                                None,
+                                1,
+                                None,
+                                None,
+                                None,
+                                [],
+                            ]
+                        ]
+                    ).decode(),
+                )
+            ]
+        )
+
+        try:
+            response_json = json.loads(response.text.split("\n")[2])
+            gem_id = json.loads(response_json[0][2])[0]
+        except Exception:
+            await self.close()
+            logger.debug(f"Invalid response: {response.text}")
+            raise APIError(
+                "Failed to create gem. Invalid response data received. Client will try to re-initialize on next request."
+            )
+
+        return Gem(
+            id=gem_id,
+            name=name,
+            description=description,
+            prompt=prompt,
+            predefined=False,
+        )
+
+    @running(retry=2)
+    async def update_gem(
+        self, gem: Gem | str, name: str, prompt: str, description: str = ""
+    ) -> Gem:
+        """
+        Update an existing custom gem.
+
+        Parameters
+        ----------
+        gem: `Gem | str`
+            Gem to update, can be either a `gemini_webapi.types.Gem` object or a gem id string.
+        name: `str`
+            New name for the custom gem.
+        prompt: `str`
+            New system instructions for the custom gem.
+        description: `str`, optional
+            New description of the custom gem (has no effect on the model's behavior).
+
+        Returns
+        -------
+        :class:`Gem`
+            The updated gem.
+        """
+
+        if isinstance(gem, Gem):
+            gem_id = gem.id
+        else:
+            gem_id = gem
+
+        await self._batch_execute(
+            [
+                RPCData(
+                    rpcid=GRPC.UPDATE_GEM,
+                    payload=json.dumps(
+                        [
+                            gem_id,
+                            [
+                                name,
+                                description,
+                                prompt,
+                                None,
+                                None,
+                                None,
+                                None,
+                                None,
+                                0,
+                                None,
+                                1,
+                                None,
+                                None,
+                                None,
+                                [],
+                                0,
+                            ],
+                        ]
+                    ).decode(),
+                )
+            ]
+        )
+
+        return Gem(
+            id=gem_id,
+            name=name,
+            description=description,
+            prompt=prompt,
+            predefined=False,
+        )
+
+    @running(retry=2)
+    async def delete_gem(self, gem: Gem | str, **kwargs) -> None:
+        """
+        Delete a custom gem.
+
+        Parameters
+        ----------
+        gem: `Gem | str`
+            Gem to delete, can be either a `gemini_webapi.types.Gem` object or a gem id string.
+        """
+
+        if isinstance(gem, Gem):
+            gem_id = gem.id
+        else:
+            gem_id = gem
+
+        await self._batch_execute(
+            [RPCData(rpcid=GRPC.DELETE_GEM, payload=json.dumps([gem_id]).decode())],
+            **kwargs,
+        )

gemini_webapi/constants.py

@@ -20,6 +20,9 @@ class GRPC(StrEnum):
 
     # Gem methods
     LIST_GEMS = "CNgdBe"
+    CREATE_GEM = "oMH3Zd"
+    UPDATE_GEM = "kHv0Vd"
+    DELETE_GEM = "UXcSJb"
 
 
 class Headers(Enum):

gemini_webapi/types/image.py

@@ -30,10 +30,10 @@ class Image(BaseModel):
     proxy: str | None = None
 
     def __str__(self):
-        return f"{self.title}({self.url}) - {self.alt}"
-
-    def __repr__(self):
-        return f"Image(title='{self.title}', url='{len(self.url) <= 20 and self.url or self.url[:8] + '...' + self.url[-12:]}', alt='{self.alt}')"
+        return (
+            f"Image(title='{self.title}', alt='{self.alt}', "
+            f"url='{len(self.url) <= 20 and self.url or self.url[:8] + '...' + self.url[-12:]}')"
+        )
 
     async def save(
         self,

gemini_webapi/utils/__init__.py

@@ -2,6 +2,7 @@
 
 from asyncio import Task
 
+from .decorators import running
 from .upload_file import upload_file, parse_file_name
 from .rotate_1psidts import rotate_1psidts
 from .get_access_token import get_access_token

gemini_webapi/utils/decorators.py

@@ -0,0 +1,52 @@
+import asyncio
+import functools
+
+from ..exceptions import APIError, ImageGenerationError
+
+
+def running(retry: int = 0) -> callable:
+    """
+    Decorator to check if GeminiClient is running before making a request.
+
+    Parameters
+    ----------
+    retry: `int`, optional
+        Max number of retries when `gemini_webapi.APIError` is raised.
+    """
+
+    def decorator(func):
+        @functools.wraps(func)
+        async def wrapper(client, *args, retry=retry, **kwargs):
+            try:
+                if not client.running:
+                    await client.init(
+                        timeout=client.timeout,
+                        auto_close=client.auto_close,
+                        close_delay=client.close_delay,
+                        auto_refresh=client.auto_refresh,
+                        refresh_interval=client.refresh_interval,
+                        verbose=False,
+                    )
+                    if client.running:
+                        return await func(client, *args, **kwargs)
+
+                    # Should not reach here
+                    raise APIError(
+                        f"Invalid function call: GeminiClient.{func.__name__}. Client initialization failed."
+                    )
+                else:
+                    return await func(client, *args, **kwargs)
+            except APIError as e:
+                # Image generation takes too long, only retry once
+                if isinstance(e, ImageGenerationError):
+                    retry = min(1, retry)
+
+                if retry > 0:
+                    await asyncio.sleep(1)
+                    return await wrapper(client, *args, retry=retry - 1, **kwargs)
+
+                raise
+
+        return wrapper
+
+    return decorator

{gemini_webapi-1.14.3.dist-info → gemini_webapi-1.15.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gemini-webapi
-Version: 1.14.3
+Version: 1.15.0
 Summary: ✨ An elegant async Python wrapper for Google Gemini web app
 Author: UZQueen
 License:                     GNU AFFERO GENERAL PUBLIC LICENSE
@@ -678,7 +678,7 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: httpx[http2]~=0.28.1
 Requires-Dist: loguru~=0.7.3
-Requires-Dist: orjson~=3.10.18
+Requires-Dist: orjson~=3.11.1
 Requires-Dist: pydantic~=2.11.5
 Dynamic: license-file
 
@@ -734,6 +734,10 @@ A reverse-engineered asynchronous python wrapper for [Google Gemini](https://gem
   - [Continue previous conversations](#continue-previous-conversations)
   - [Select language model](#select-language-model)
   - [Apply system prompt with Gemini Gems](#apply-system-prompt-with-gemini-gems)
+  - [Manage Custom Gems](#manage-custom-gems)
+    - [Create a custom gem](#create-a-custom-gem)
+    - [Update an existing gem](#update-an-existing-gem)
+    - [Delete a custom gem](#delete-a-custom-gem)
   - [Retrieve model's thought process](#retrieve-models-thought-process)
   - [Retrieve images in response](#retrieve-images-in-response)
   - [Generate images with Imagen4](#generate-images-with-imagen4)
@@ -963,6 +967,75 @@ async def main():
     print(response2)
 ```
 
+### Manage Custom Gems
+
+You can create, update, and delete your custom gems programmatically with the API. Note that predefined system gems cannot be modified or deleted.
+
+#### Create a custom gem
+
+Create a new custom gem with a name, system prompt (instructions), and optional description:
+
+```python
+async def main():
+    # Create a new custom gem
+    new_gem = await client.create_gem(
+        name="Python Tutor",
+        prompt="You are a helpful Python programming tutor.",
+        description="A specialized gem for Python programming"
+    )
+
+    print(f"Custom gem created: {new_gem}")
+
+    # Use the newly created gem in a conversation
+    response = await client.generate_content(
+        "Explain how list comprehensions work in Python",
+        gem=new_gem
+    )
+    print(response.text)
+
+asyncio.run(main())
+```
+
+#### Update an existing gem
+
+> [!NOTE]
+>
+> When updating a gem, you must provide all parameters (name, prompt, description) even if you only want to change one of them.
+
+```python
+async def main():
+    # Get a custom gem (assuming you have one named "Python Tutor")
+    await client.fetch_gems()
+    python_tutor = client.gems.get(name="Python Tutor")
+
+    # Update the gem with new instructions
+    updated_gem = await client.update_gem(
+        gem=python_tutor,  # Can also pass gem ID string
+        name="Advanced Python Tutor",
+        prompt="You are an expert Python programming tutor.",
+        description="An advanced Python programming assistant"
+    )
+
+    print(f"Custom gem updated: {updated_gem}")
+
+asyncio.run(main())
+```
+
+#### Delete a custom gem
+
+```python
+async def main():
+    # Get the gem to delete
+    await client.fetch_gems()
+    gem_to_delete = client.gems.get(name="Advanced Python Tutor")
+
+    # Delete the gem
+    await client.delete_gem(gem_to_delete)  # Can also pass gem ID string
+    print(f"Custom gem deleted: {gem_to_delete.name}")
+
+asyncio.run(main())
+```
+
 ### Retrieve model's thought process
 
 When using models with thinking capabilities, the model's thought process will be populated in `ModelOutput.thoughts`.

{gemini_webapi-1.14.3.dist-info → gemini_webapi-1.15.0.dist-info}/RECORD

@@ -1,21 +1,24 @@
 gemini_webapi/__init__.py,sha256=7ELCiUoI10ea3daeJxnv0UwqLVKpM7rxsgOZsPMstO8,150
-gemini_webapi/client.py,sha256=XrPG5LtJDYpEOMyjL8zxRO9ExFwp9EO5UpsNxhouSvk,31820
-gemini_webapi/constants.py,sha256=M2fbQSSVhF0ROv_9CTR4n8sDOujJmLRxwA6ARQ0Uf7k,2519
+gemini_webapi/client.py,sha256=G0nmRCeEmT0BpqgYY4zxb_ozFDmb39JqtddKpIN6JlA,26870
+gemini_webapi/constants.py,sha256=VE3URBOjORTXu7fTHAkjGgOHphGNlx1iA1T9EHdapnE,2597
 gemini_webapi/exceptions.py,sha256=qkXrIpr0L7LtGbq3VcTO8D1xZ50pJtt0dDRp5I3uDSg,1038
+gemini_webapi/components/__init__.py,sha256=wolxuAJJ32-jmHOKgpsesexP7hXea1JMo5vI52wysTI,48
+gemini_webapi/components/gem_mixin.py,sha256=WPJkYDS4yQpLMBNQ94LQo5w59RgkllWaSiHsFG1k5GU,8795
 gemini_webapi/types/__init__.py,sha256=1DU4JEw2KHQJbtOgOuvoEXtzQCMwAkyo0koSFVdT9JY,192
 gemini_webapi/types/candidate.py,sha256=67BhY75toE5mVuB21cmHcTFtw332V_KmCjr3-9VTbJo,1477
 gemini_webapi/types/gem.py,sha256=3Ppjq9V22Zp4Lb9a9ZnDviDKQpfSQf8UZxqOEjeEWd4,4070
 gemini_webapi/types/grpc.py,sha256=S64h1oeC7ZJC50kmS_C2CQ7WVTanhJ4kqTFx5ZYayXI,917
-gemini_webapi/types/image.py,sha256=xCPaMzstIM5C09ZkJ0545vVPAsrF3y89XnRJrEWGz5k,5436
+gemini_webapi/types/image.py,sha256=NhW1QY2Agzb6UbrIjZLnqxqukabDSGbmoCsVguzko10,5395
 gemini_webapi/types/modeloutput.py,sha256=h07kQOkL5r-oPLvZ59uVtO1eP4FGy5ZpzuYQzAeQdr8,1196
-gemini_webapi/utils/__init__.py,sha256=cJ9HQYxr8l0CsY61TFlho-5DdPxCaEOpRfjxPX-eils,320
+gemini_webapi/utils/__init__.py,sha256=RIU1MBqYNjih0XMMt7wCxAA-X9KVF53nDbAjaxaGTo8,352
+gemini_webapi/utils/decorators.py,sha256=AuY6sU1_6_ZqeL92dTAi3eRPQ7zubB5VuBZEiz16aBM,1741
 gemini_webapi/utils/get_access_token.py,sha256=eNn1omFO41wWXco1eM-KXR2CEi0Tb-chlph7H-PCNjg,6137
 gemini_webapi/utils/load_browser_cookies.py,sha256=A5n_VsB7Rm8ck5lpy856UNJEhv30l3dvQ3j0g3ln1fE,1535
 gemini_webapi/utils/logger.py,sha256=0VcxhVLhHBRDQutNCpapP1y_MhPoQ2ud1uIFLqxC3Z8,958
 gemini_webapi/utils/rotate_1psidts.py,sha256=NyQ9OYPLBOcvpc8bodvEYDIVFrsYN0kdfc831lPEctM,1680
 gemini_webapi/utils/upload_file.py,sha256=SJOMr6kryK_ClrKmqI96fqZBNFOMPsyAvFINAGAU3rk,1468
-gemini_webapi-1.14.3.dist-info/licenses/LICENSE,sha256=hIahDEOTzuHCU5J2nd07LWwkLW7Hko4UFO__ffsvB-8,34523
-gemini_webapi-1.14.3.dist-info/METADATA,sha256=GNbHaHKIyQD0t3_MhkaxjHufYV7B5S1X5YUDG9-8e5o,59157
-gemini_webapi-1.14.3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-gemini_webapi-1.14.3.dist-info/top_level.txt,sha256=dtWtug_ZrmnUqCYuu8NmGzTgWglHeNzhHU_hXmqZGWE,14
-gemini_webapi-1.14.3.dist-info/RECORD,,
+gemini_webapi-1.15.0.dist-info/licenses/LICENSE,sha256=hIahDEOTzuHCU5J2nd07LWwkLW7Hko4UFO__ffsvB-8,34523
+gemini_webapi-1.15.0.dist-info/METADATA,sha256=KwfKZ9MwLiae-xnxzRT6YH4p7olvTqZudmqZa234v0g,61279
+gemini_webapi-1.15.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+gemini_webapi-1.15.0.dist-info/top_level.txt,sha256=dtWtug_ZrmnUqCYuu8NmGzTgWglHeNzhHU_hXmqZGWE,14
+gemini_webapi-1.15.0.dist-info/RECORD,,