gemini-webapi 1.17.3__py3-none-any.whl → 1.18.1__py3-none-any.whl

gemini_webapi/utils/parsing.py

@@ -1,3 +1,5 @@
+import re
+import reprlib
 from typing import Any
 
 import orjson as json
@@ -5,63 +7,201 @@ import orjson as json
 from .logger import logger
 
 
-def get_nested_value(data: list, path: list[int], default: Any = None) -> Any:
+_LENGTH_MARKER_PATTERN = re.compile(r"(\d+)\n")
+
+
+def _get_char_count_for_utf16_units(
+    s: str, start_idx: int, utf16_units: int
+) -> tuple[int, int]:
+    """
+    Calculate the number of Python characters (code points) and actual UTF-16
+    units found.
+    """
+
+    count = 0
+    units = 0
+    limit = len(s)
+
+    while units < utf16_units and (start_idx + count) < limit:
+        char = s[start_idx + count]
+        u = 2 if ord(char) > 0xFFFF else 1
+        if units + u > utf16_units:
+            break
+        units += u
+        count += 1
+
+    return count, units
+
+
+def get_nested_value(
+    data: Any, path: list[int | str], default: Any = None, verbose: bool = False
+) -> Any:
     """
-    Safely get a value from a nested list by a sequence of indices.
+    Safely navigate through a nested structure (list or dict) using a sequence of keys/indices.
 
     Parameters
     ----------
-    data: `list`
-        The nested list to traverse.
-    path: `list[int]`
-        A list of indices representing the path to the desired value.
-    default: `Any`, optional
-        The default value to return if the path is not found.
+    data: `Any`
+        The nested structure to traverse.
+    path: `list[int | str]`
+        A list of indices or keys representing the path.
+    default: `Any`
+        Value to return if the path is invalid.
+    verbose: `bool`
+        If True, log debug information when the path cannot be fully traversed.
     """
 
     current = data
 
     for i, key in enumerate(path):
-        try:
-            current = current[key]
-        except (IndexError, TypeError, KeyError):
-            current_repr = repr(current)
-            if len(current_repr) > 200:
-                current_repr = f"{current_repr[:197]}..."
+        found = False
+        if isinstance(key, int):
+            if isinstance(current, list) and -len(current) <= key < len(current):
+                current = current[key]
+                found = True
+        elif isinstance(key, str):
+            if isinstance(current, dict) and key in current:
+                current = current[key]
+                found = True
+
+        if not found:
+            if verbose:
+                logger.debug(
+                    f"Safe navigation: path {path} ended at index {i} (key '{key}'), "
+                    f"returning default. Context: {reprlib.repr(current)}"
+                )
+            return default
+
+    return current if current is not None else default
 
+
+def _parse_with_length_markers(content: str) -> list | None:
+    """
+    Parse streaming responses using length markers as hints.
+    Google's format: [length]\n[json_payload]\n
+    The length value includes the newline after the number and the newline after the JSON.
+    """
+
+    pos = 0
+    total_len = len(content)
+    collected_chunks = []
+
+    while pos < total_len:
+        while pos < total_len and content[pos].isspace():
+            pos += 1
+
+        if pos >= total_len:
+            break
+
+        match = _LENGTH_MARKER_PATTERN.match(content, pos=pos)
+        if not match:
+            break
+
+        length_val = match.group(1)
+        length = int(length_val)
+
+        # Content starts immediately after the digits.
+        # Google uses UTF-16 code units (JavaScript .length) for the length marker.
+        start_content = match.start() + len(length_val)
+        char_count, units_found = _get_char_count_for_utf16_units(
+            content, start_content, length
+        )
+        end_hint = start_content + char_count
+        pos = end_hint
+
+        if units_found < length:
             logger.debug(
-                f"Safe navigation: path {path} ended at index {i} (key '{key}'), "
-                f"returning default. Context: {current_repr}"
+                f"Chunk at pos {start_content} is truncated. Expected {length} UTF-16 units, got {units_found}."
             )
+            break
 
-            return default
+        chunk = content[start_content:end_hint].strip()
+        if not chunk:
+            continue
 
-    if current is None and default is not None:
-        return default
+        try:
+            parsed = json.loads(chunk)
+            if isinstance(parsed, list):
+                collected_chunks.extend(parsed)
+            else:
+                collected_chunks.append(parsed)
+        except json.JSONDecodeError:
+            logger.warning(
+                f"Failed to parse chunk at pos {start_content} with length {length}. "
+                f"Snippet: {reprlib.repr(chunk)}"
+            )
 
-    return current
+    return collected_chunks if collected_chunks else None
 
 
-def extract_json_from_response(text: str) -> list:
+def parse_stream_frames(buffer: str) -> tuple[list[Any], str]:
     """
-    Clean and extract the JSON content from a Google API response.
+    Parse as many JSON frames as possible from an accumulated buffer.
+
+    This function implements Google's length-prefixed framing protocol. Each frame starts
+    with a length marker (number of characters) followed by a newline and the JSON content.
+    If a frame is partially received, it stays in the buffer for the next call.
 
     Parameters
     ----------
-    text: `str`
-        The raw response text from a Google API.
+    buffer: `str`
+        The accumulated string buffer containing raw streaming data from the API.
 
     Returns
     -------
-    `list`
-        The extracted JSON array or object (should be an array).
-
-    Raises
-    ------
-    `TypeError`
-        If the input is not a string.
-    `ValueError`
-        If no JSON object is found or the response is empty.
+    `tuple[list[Any], str]`
+        A tuple containing:
+        - A list of parsed JSON objects (envelopes) extracted from the buffer.
+        - The remaining unparsed part of the buffer (incomplete frames).
+    """
+
+    pos = 0
+    total_len = len(buffer)
+    parsed_objects = []
+
+    while pos < total_len:
+        while pos < total_len and buffer[pos].isspace():
+            pos += 1
+
+        if pos >= total_len:
+            break
+
+        match = _LENGTH_MARKER_PATTERN.match(buffer, pos=pos)
+        if not match:
+            # If we have a prefix but no length marker yet, wait for more data
+            break
+
+        length_val = match.group(1)
+        length = int(length_val)
+        start_content = match.start() + len(length_val)
+        char_count, units_found = _get_char_count_for_utf16_units(
+            buffer, start_content, length
+        )
+
+        if units_found < length:
+            # Chunk is truncated, wait for more data
+            break
+
+        end_pos = start_content + char_count
+        chunk = buffer[start_content:end_pos].strip()
+        pos = end_pos
+
+        if chunk:
+            try:
+                parsed = json.loads(chunk)
+                if isinstance(parsed, list):
+                    parsed_objects.extend(parsed)
+                else:
+                    parsed_objects.append(parsed)
+            except json.JSONDecodeError:
+                logger.debug(f"Streaming: Failed to parse chunk: {reprlib.repr(chunk)}")
+
+    return parsed_objects, buffer[pos:]
+
+
+def extract_json_from_response(text: str) -> list:
+    """
+    Extract and normalize JSON content from a Google API response.
     """
 
     if not isinstance(text, str):
@@ -69,12 +209,42 @@ def extract_json_from_response(text: str) -> list:
             f"Input text is expected to be a string, got {type(text).__name__} instead."
         )
 
-    # Find the first line which is valid JSON
-    for line in text.splitlines():
+    content = text
+    if content.startswith(")]}'"):
+        content = content[4:]
+
+    content = content.lstrip()
+
+    # Extract with a length marker
+    result = _parse_with_length_markers(content)
+    if result is not None:
+        return result
+
+    # Extract the entire content
+    content_stripped = content.strip()
+    try:
+        parsed = json.loads(content_stripped)
+        return parsed if isinstance(parsed, list) else [parsed]
+    except json.JSONDecodeError:
+        pass
+
+    # Extract with NDJSON
+    collected_lines = []
+    for line in content_stripped.splitlines():
+        line = line.strip()
+        if not line:
+            continue
         try:
-            return json.loads(line.strip())
+            parsed = json.loads(line)
         except json.JSONDecodeError:
             continue
 
-    # If no JSON is found, raise ValueError
+        if isinstance(parsed, list):
+            collected_lines.extend(parsed)
+        elif isinstance(parsed, dict):
+            collected_lines.append(parsed)
+
+    if collected_lines:
+        return collected_lines
+
     raise ValueError("Could not find a valid JSON object or array in the response.")

gemini_webapi/utils/rotate_1psidts.py

@@ -2,27 +2,29 @@ import os
 import time
 from pathlib import Path
 
-from httpx import AsyncClient
+from httpx import AsyncClient, Cookies
 
 from ..constants import Endpoint, Headers
 from ..exceptions import AuthError
 
 
-async def rotate_1psidts(cookies: dict, proxy: str | None = None) -> str:
+async def rotate_1psidts(
+    cookies: dict | Cookies, proxy: str | None = None
+) -> tuple[str | None, Cookies | None]:
     """
     Refresh the __Secure-1PSIDTS cookie and store the refreshed cookie value in cache file.
 
     Parameters
     ----------
-    cookies : `dict`
+    cookies : `dict | httpx.Cookies`
         Cookies to be used in the request.
     proxy: `str`, optional
         Proxy URL.
 
     Returns
     -------
-    `str`
-        New value of the __Secure-1PSIDTS cookie.
+    `tuple[str | None, httpx.Cookies | None]`
+        New value of the __Secure-1PSIDTS cookie and the full updated cookies jar.
 
     Raises
     ------
@@ -38,22 +40,39 @@ async def rotate_1psidts(cookies: dict, proxy: str | None = None) -> str:
         or (Path(__file__).parent / "temp")
     )
     path.mkdir(parents=True, exist_ok=True)
-    filename = f".cached_1psidts_{cookies['__Secure-1PSID']}.txt"
+
+    # Safely get __Secure-1PSID value for filename
+    if isinstance(cookies, Cookies):
+        # Prefer .google.com domain to avoid CookieConflict
+        secure_1psid = cookies.get(
+            "__Secure-1PSID", domain=".google.com"
+        ) or cookies.get("__Secure-1PSID")
+    else:
+        secure_1psid = cookies.get("__Secure-1PSID")
+
+    if not secure_1psid:
+        return None, None
+
+    filename = f".cached_1psidts_{secure_1psid}.txt"
     path = path / filename
 
     # Check if the cache file was modified in the last minute to avoid 429 Too Many Requests
-    if not (path.is_file() and time.time() - os.path.getmtime(path) <= 60):
-        async with AsyncClient(proxy=proxy) as client:
-            response = await client.post(
-                url=Endpoint.ROTATE_COOKIES.value,
-                headers=Headers.ROTATE_COOKIES.value,
-                cookies=cookies,
-                data='[000,"-0000000000000000000"]',
-            )
-            if response.status_code == 401:
-                raise AuthError
-            response.raise_for_status()
-
-            if new_1psidts := response.cookies.get("__Secure-1PSIDTS"):
-                path.write_text(new_1psidts)
-                return new_1psidts
+    if path.is_file() and time.time() - os.path.getmtime(path) <= 60:
+        return path.read_text(), None
+
+    async with AsyncClient(http2=True, proxy=proxy) as client:
+        response = await client.post(
+            url=Endpoint.ROTATE_COOKIES,
+            headers=Headers.ROTATE_COOKIES.value,
+            cookies=cookies,
+            content='[000,"-0000000000000000000"]',
+        )
+        if response.status_code == 401:
+            raise AuthError
+        response.raise_for_status()
+
+        if new_1psidts := response.cookies.get("__Secure-1PSIDTS"):
+            path.write_text(new_1psidts)
+            return new_1psidts, response.cookies
+
+        return None, response.cookies

gemini_webapi/utils/upload_file.py

@@ -1,22 +1,38 @@
+import io
+import random
 from pathlib import Path
 
 from httpx import AsyncClient
-from pydantic import validate_call
+from pydantic import ConfigDict, validate_call
 
 from ..constants import Endpoint, Headers
 
 
-@validate_call
-async def upload_file(file: str | Path, proxy: str | None = None) -> str:
+def _generate_random_name(extension: str = ".txt") -> str:
+    """
+    Generate a random filename using a large integer for better performance.
+    """
+
+    return f"input_{random.randint(1000000, 9999999)}{extension}"
+
+
+@validate_call(config=ConfigDict(arbitrary_types_allowed=True))
+async def upload_file(
+    file: str | Path | bytes | io.BytesIO,
+    proxy: str | None = None,
+    filename: str | None = None,
+) -> str:
     """
     Upload a file to Google's server and return its identifier.
 
     Parameters
     ----------
-    file : `str` | `Path`
-        Path to the file to be uploaded.
+    file : `str` | `Path` | `bytes` | `io.BytesIO`
+        Path to the file or file content to be uploaded.
     proxy: `str`, optional
         Proxy URL.
+    filename: `str`, optional
+        Name of the file to be uploaded. Required if file is bytes or BytesIO.
 
     Returns
     -------
@@ -30,28 +46,43 @@ async def upload_file(file: str | Path, proxy: str | None = None) -> str:
         If the upload request failed.
     """
 
-    with open(file, "rb") as f:
-        file = f.read()
+    if isinstance(file, (str, Path)):
+        file_path = Path(file)
+        if not file_path.is_file():
+            raise ValueError(f"{file_path} is not a valid file.")
+        if not filename:
+            filename = file_path.name
+        file_content = file_path.read_bytes()
+    elif isinstance(file, io.BytesIO):
+        file_content = file.getvalue()
+        if not filename:
+            filename = _generate_random_name()
+    elif isinstance(file, bytes):
+        file_content = file
+        if not filename:
+            filename = _generate_random_name()
+    else:
+        raise ValueError(f"Unsupported file type: {type(file)}")
 
-    async with AsyncClient(proxy=proxy) as client:
+    async with AsyncClient(http2=True, proxy=proxy) as client:
         response = await client.post(
-            url=Endpoint.UPLOAD.value,
+            url=Endpoint.UPLOAD,
             headers=Headers.UPLOAD.value,
-            files={"file": file},
+            files={"file": (filename, file_content)},
             follow_redirects=True,
         )
         response.raise_for_status()
         return response.text
 
 
-def parse_file_name(file: str | Path) -> str:
+def parse_file_name(file: str | Path | bytes | io.BytesIO) -> str:
     """
-    Parse the file name from the given path.
+    Parse the file name from the given path or generate a random one for in-memory data.
 
     Parameters
     ----------
-    file : `str` | `Path`
-        Path to the file.
+    file : `str` | `Path` | `bytes` | `io.BytesIO`
+        Path to the file or file content.
 
     Returns
     -------
@@ -59,8 +90,10 @@ def parse_file_name(file: str | Path) -> str:
         File name with extension.
     """
 
-    file = Path(file)
-    if not file.is_file():
-        raise ValueError(f"{file} is not a valid file.")
+    if isinstance(file, (str, Path)):
+        file = Path(file)
+        if not file.is_file():
+            raise ValueError(f"{file} is not a valid file.")
+        return file.name
 
-    return file.name
+    return _generate_random_name()

{gemini_webapi-1.17.3.dist-info → gemini_webapi-1.18.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gemini-webapi
-Version: 1.17.3
+Version: 1.18.1
 Summary: ✨ An elegant async Python wrapper for Google Gemini web app
 Author: UZQueen
 License:                     GNU AFFERO GENERAL PUBLIC LICENSE
@@ -676,10 +676,10 @@ Classifier: Programming Language :: Python :: 3.12
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: httpx~=0.28.1
+Requires-Dist: httpx[http2]~=0.28.1
 Requires-Dist: loguru~=0.7.3
-Requires-Dist: orjson~=3.11.1
-Requires-Dist: pydantic~=2.12.2
+Requires-Dist: orjson~=3.11.7
+Requires-Dist: pydantic~=2.12.5
 Dynamic: license-file
 
 <p align="center">
@@ -717,6 +717,7 @@ A reverse-engineered asynchronous python wrapper for [Google Gemini](https://gem
 - **System Prompt** - Supports customizing model's system prompt with [Gemini Gems](https://gemini.google.com/gems/view).
 - **Extension Support** - Supports generating contents with [Gemini extensions](https://gemini.google.com/extensions) on, like YouTube and Gmail.
 - **Classified Outputs** - Categorizes texts, thoughts, web images and AI generated images in the response.
+- **Streaming Mode** - Supports stream generation, yielding partial outputs as they are generated.
 - **Official Flavor** - Provides a simple and elegant interface inspired by [Google Generative AI](https://ai.google.dev/tutorials/python_quickstart)'s official API.
 - **Asynchronous** - Utilizes `asyncio` to run generating tasks and return outputs efficiently.
 
@@ -732,6 +733,8 @@ A reverse-engineered asynchronous python wrapper for [Google Gemini](https://gem
   - [Generate contents with files](#generate-contents-with-files)
   - [Conversations across multiple turns](#conversations-across-multiple-turns)
   - [Continue previous conversations](#continue-previous-conversations)
+  - [Delete previous conversations from Gemini history](#delete-previous-conversations-from-gemini-history)
+  - [Streaming mode](#streaming-mode)
   - [Select language model](#select-language-model)
   - [Apply system prompt with Gemini Gems](#apply-system-prompt-with-gemini-gems)
   - [Manage Custom Gems](#manage-custom-gems)
@@ -901,6 +904,45 @@ async def main():
 asyncio.run(main())
 ```
 
+### Delete previous conversations from Gemini history
+
+You can delete a specific chat from Gemini history on the server by calling `GeminiClient.delete_chat` with the chat id.
+
+```python
+async def main():
+    # Start a new chat session
+    chat = client.start_chat()
+    await chat.send_message("This is a temporary conversation.")
+
+    # Delete the chat
+    await client.delete_chat(chat.cid)
+    print(f"Chat deleted: {chat.cid}")
+
+asyncio.run(main())
+```
+
+### Streaming mode
+
+For longer responses, you can use streaming mode to receive partial outputs as they are generated. This provides a more responsive user experience, especially for real-time applications like chatbots.
+
+The `generate_content_stream` method yields `ModelOutput` objects where the `text_delta` attribute contains only the **new characters** received since the last yield, making it easy to display incremental updates.
+
+```python
+async def main():
+    async for chunk in client.generate_content_stream(
+        "What's the difference between 'await' and 'async for'?"
+    ):
+        print(chunk.text_delta, end="", flush=True)
+
+    print()
+
+asyncio.run(main())
+```
+
+> [!TIP]
+>
+> You can also use streaming mode in multi-turn conversations with `ChatSession.send_message_stream`.
+
 ### Select language model
 
 You can specify which language model to use by passing `model` argument to `GeminiClient.generate_content` or `GeminiClient.start_chat`. The default value is `unspecified`.
@@ -909,8 +951,8 @@ Currently available models (as of November 20, 2025):
 
 - `unspecified` - Default model
 - `gemini-3.0-pro` - Gemini 3.0 Pro
-- `gemini-2.5-pro` - Gemini 2.5 Pro
-- `gemini-2.5-flash` - Gemini 2.5 Flash
+- `gemini-3.0-flash` - Gemini 3.0 Flash
+- `gemini-3.0-flash-thinking` - Gemini 3.0 Flash Thinking
 
 ```python
 from gemini_webapi.constants import Model
@@ -918,9 +960,9 @@ from gemini_webapi.constants import Model
 async def main():
     response1 = await client.generate_content(
         "What's you language model version? Reply version number only.",
-        model=Model.G_2_5_FLASH,
+        model=Model.G_3_0_FLASH,
     )
-    print(f"Model version ({Model.G_2_5_FLASH.model_name}): {response1.text}")
+    print(f"Model version ({Model.G_3_0_FLASH.model_name}): {response1.text}")
 
     chat = client.start_chat(model="gemini-2.5-pro")
     response2 = await chat.send_message("What's you language model version? Reply version number only.")
@@ -957,7 +999,7 @@ System prompt can be applied to conversations via [Gemini Gems](https://gemini.g
 ```python
 async def main():
     # Fetch all gems for the current account, including both predefined and user-created ones
-    await client.fetch_gems(include_hidden=False)
+    await client.fetch_gems(include_hidden=False, language="en")
 
     # Once fetched, gems will be cached in `GeminiClient.gems`
     gems = client.gems
@@ -968,7 +1010,7 @@ async def main():
 
     response1 = await client.generate_content(
         "what's your system prompt?",
-        model=Model.G_2_5_FLASH,
+        model=Model.G_3_0_FLASH,
         gem=coding_partner,
     )
     print(response1.text)

gemini_webapi-1.18.1.dist-info/RECORD

@@ -0,0 +1,25 @@
+gemini_webapi/__init__.py,sha256=7ELCiUoI10ea3daeJxnv0UwqLVKpM7rxsgOZsPMstO8,150
+gemini_webapi/client.py,sha256=qD6XwOkrzk1FXmUdcaq_-xoJjVpVkxAuXDy2-7vCf4A,42123
+gemini_webapi/constants.py,sha256=VluH20wYib_9z1LPTFHQvv__mBUTNudVcb6YJWMrGt0,3546
+gemini_webapi/exceptions.py,sha256=qkXrIpr0L7LtGbq3VcTO8D1xZ50pJtt0dDRp5I3uDSg,1038
+gemini_webapi/components/__init__.py,sha256=wolxuAJJ32-jmHOKgpsesexP7hXea1JMo5vI52wysTI,48
+gemini_webapi/components/gem_mixin.py,sha256=cSyxDyGmr-O2WK9XF1I74l3uIDGAKG4M2EOukDBkvS4,9763
+gemini_webapi/types/__init__.py,sha256=1DU4JEw2KHQJbtOgOuvoEXtzQCMwAkyo0koSFVdT9JY,192
+gemini_webapi/types/candidate.py,sha256=5Gy2UiOgwlsrFZ7wQsuHyS2jmKsgQLGkSHbqbPTEnqg,1549
+gemini_webapi/types/gem.py,sha256=3Ppjq9V22Zp4Lb9a9ZnDviDKQpfSQf8UZxqOEjeEWd4,4070
+gemini_webapi/types/grpc.py,sha256=S64h1oeC7ZJC50kmS_C2CQ7WVTanhJ4kqTFx5ZYayXI,917
+gemini_webapi/types/image.py,sha256=DYHSSwKxd8-ipaeFeyHuHt95eh1D681irCq0oIqspYA,6240
+gemini_webapi/types/modeloutput.py,sha256=L-qI1a9sPTFFNbxBgDm6FKTKjMJQxiRxNLthr7owUy8,1422
+gemini_webapi/utils/__init__.py,sha256=w_OwRm9gD8j2DP7ReomhGWx3sbnPGyRC-8DXt5DZXhc,376
+gemini_webapi/utils/decorators.py,sha256=iTTVIgG1fxOVMluy9fKeVrTmj4_K1h1q4lVLCjFaLhc,3462
+gemini_webapi/utils/get_access_token.py,sha256=6EcLhcpS8_-hxodBvQwu76PECVBnQQtzt9AYqSi0ps8,8162
+gemini_webapi/utils/load_browser_cookies.py,sha256=OHCfe27DpV_rloIDgW9Xpeb0mkfzbYONNiholw0ElXU,1791
+gemini_webapi/utils/logger.py,sha256=0VcxhVLhHBRDQutNCpapP1y_MhPoQ2ud1uIFLqxC3Z8,958
+gemini_webapi/utils/parsing.py,sha256=iNrczcArdaCQ9_xD0isf4LDEwSTbBjq_frgvMdqm1Tk,7291
+gemini_webapi/utils/rotate_1psidts.py,sha256=7W_D5NGJ9_dpF0EgVaU_ykL1ebvQK7P28bQN2HVlX5M,2359
+gemini_webapi/utils/upload_file.py,sha256=TiLnXdNvY8NRFZih-wp_BpDA6LxAVQDQakzmq2Ur9Ak,2781
+gemini_webapi-1.18.1.dist-info/licenses/LICENSE,sha256=hIahDEOTzuHCU5J2nd07LWwkLW7Hko4UFO__ffsvB-8,34523
+gemini_webapi-1.18.1.dist-info/METADATA,sha256=y4Kg_-Dn4PZDk2xtBmjtBAUnDI6fqHb0F-NHAQ91sTk,63301
+gemini_webapi-1.18.1.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+gemini_webapi-1.18.1.dist-info/top_level.txt,sha256=dtWtug_ZrmnUqCYuu8NmGzTgWglHeNzhHU_hXmqZGWE,14
+gemini_webapi-1.18.1.dist-info/RECORD,,

{gemini_webapi-1.17.3.dist-info → gemini_webapi-1.18.1.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.9.0)
+Generator: setuptools (80.10.2)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

gemini_webapi-1.17.3.dist-info/RECORD

@@ -1,25 +0,0 @@
-gemini_webapi/__init__.py,sha256=7ELCiUoI10ea3daeJxnv0UwqLVKpM7rxsgOZsPMstO8,150
-gemini_webapi/client.py,sha256=OJSScOnl6rUbDOJ7hz-jn_1u13_HdjczPJsstOgNTGw,29254
-gemini_webapi/constants.py,sha256=-UHHwSoY4pzEfRTGpfb8UMgCNVbgSc3RLSOZpVOyNpM,3409
-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=9miYAu3htBjNScCWfBJ49b_RtWDW9XFWO1NRJDvLgM8,6173
-gemini_webapi/types/modeloutput.py,sha256=h07kQOkL5r-oPLvZ59uVtO1eP4FGy5ZpzuYQzAeQdr8,1196
-gemini_webapi/utils/__init__.py,sha256=k8hV2zn6tD_BEpd1Xya6ED0deijsmzb1e9XxdFhJzIE,418
-gemini_webapi/utils/decorators.py,sha256=uzIXoZOC0_Om19bbVXf_nw2w2NhI2qJL1o45FU6o6fI,1780
-gemini_webapi/utils/get_access_token.py,sha256=twZtTtvOnGxHhikCOj1HGErj2r5dT_BNcvqv5A0dtXg,7194
-gemini_webapi/utils/load_browser_cookies.py,sha256=OHCfe27DpV_rloIDgW9Xpeb0mkfzbYONNiholw0ElXU,1791
-gemini_webapi/utils/logger.py,sha256=0VcxhVLhHBRDQutNCpapP1y_MhPoQ2ud1uIFLqxC3Z8,958
-gemini_webapi/utils/parsing.py,sha256=wDQsK1RcfrPr7c6w1JpxoPjLtkFIkcPmTX8jjfleJf0,2080
-gemini_webapi/utils/rotate_1psidts.py,sha256=SIqkqjZrEAyXB38qTEY9apxHVwczpFut4I0A77eWIFk,1790
-gemini_webapi/utils/upload_file.py,sha256=z5p03l6oQP74wzF0MF-Kbnav5k1nb7uYyzx-f8pxSVI,1456
-gemini_webapi-1.17.3.dist-info/licenses/LICENSE,sha256=hIahDEOTzuHCU5J2nd07LWwkLW7Hko4UFO__ffsvB-8,34523
-gemini_webapi-1.17.3.dist-info/METADATA,sha256=Ld5hDcwuox-uqslhP83-gzyYVEZa7wgOs5hX2NcG7Y4,61756
-gemini_webapi-1.17.3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-gemini_webapi-1.17.3.dist-info/top_level.txt,sha256=dtWtug_ZrmnUqCYuu8NmGzTgWglHeNzhHU_hXmqZGWE,14
-gemini_webapi-1.17.3.dist-info/RECORD,,