rnet-oauth 1.0.1__tar.gz

rnet_oauth-1.0.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 rNet Ai
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

rnet_oauth-1.0.1/PKG-INFO

@@ -0,0 +1,143 @@
+Metadata-Version: 2.4
+Name: rnet-oauth
+Version: 1.0.1
+Summary: RNet OAuth Python client library
+Author: rNet Ai
+License-Expression: MIT
+Project-URL: Homepage, https://rnetai.org
+Project-URL: Repository, https://github.com/rNetAi/rnet-oauth-python
+Keywords: oauth2,rnet,authentication
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# RNet OAuth Python Library
+
+A Python backend library for integrating **RNet OAuth** and **AI Provider** services. This library allows users to authenticate via RNet and pay for AI model token costs directly using their RNet account.
+
+## Features
+
+- **OAuth2 PKCE Support**: Secure authorization code flow with automatic code verifier and challenge generation.
+- **Token Management**: Exchange authorization codes for tokens and refresh expired tokens.
+- **UserInfo Endpoint**: Fetch the authenticated user's RNet profile with an access token.
+- **AI Integration**: Easy methods to chat with AI models using standard or streaming responses.
+
+## Installation
+
+```bash
+pip install rnet-oauth
+```
+
+## Quick Start
+
+### 1. Initialize the Clients
+```python
+from rnet_oauth import RNetAuth, RNetAi
+
+auth = RNetAuth(
+    client_id='client-id',
+    client_secret='client-secret',
+    redirect_uri='redirect-uri'
+)
+ai = RNetAi()
+```
+
+### 2. Generate Authorization URL (OAuth2 PKCE)
+```python
+# 1. Generate PKCE
+pkce = auth.generate_pkce()
+verifier = pkce['verifier']
+challenge = pkce['challenge']
+
+# 2. Get Authorization URL
+# challenge: PKCE code challenge (optional)
+# state: An optional string to maintain state between the request and callback (recommended for security)
+auth_url = auth.get_authorization_url(challenge, state='optional-state')
+```
+
+### 3. Exchange Code for Tokens
+```python
+# 3. Exchange code for tokens
+tokens = auth.exchange_code_for_token(code, verifier)
+access_token = tokens['access_token']
+```
+
+### 4. Get User Info
+```python
+user_info = auth.get_user_info(access_token)
+print(user_info['email'])
+print(user_info['name'])
+```
+
+The UserInfo response comes from RNet's `/userinfo` endpoint and may include:
+`sub`, `email`, `email_verified`, `name`, `preferred_username`, `user_id`, `role`, and `status`.
+
+### 5. Chat with AI
+```python
+response = ai.chat({
+    "contents": [
+        {
+            "role": "user",
+            "parts": [{"text": "Hello!"}]
+        }
+    ]
+}, access_token, "gemini-2.5-flash-lite")
+```
+
+### 6. Streaming AI Response (Untested)
+```python
+for chunk in ai.chat_stream({
+    "contents": [
+        {
+            "role": "user",
+            "parts": [{"text": "Hello!"}]
+        }
+    ]
+}, access_token, "gemini-2.5-flash-lite"):
+    print(chunk)
+```
+
+### 7. File Upload (Untested)
+```python
+with open("document.pdf", "rb") as f:
+    file_buffer = f.read()
+
+# Upload to Gemini
+gemini_upload = ai.gemini_file_upload(access_token, "gemini-2.5-flash-lite", file_buffer, "application/pdf", "document.pdf")
+print(gemini_upload['fileReference']) # Use this in chat payload
+
+# Upload to OpenAI
+openai_upload = ai.openai_file_upload(access_token, "gpt-4o", file_buffer, "application/pdf", "document.pdf")
+```
+
+### 8. File Deletion (Untested)
+```python
+# Gemini files auto-delete after 48 hours, so there is no delete method.
+# Delete an OpenAI file:
+ai.openai_file_delete(access_token, "gpt-4o", openai_upload['fileReference'])
+```
+
+### 9. AI Chat with File & Tools (Untested)
+```python
+payload = {
+    "contents": [
+        {
+            "role": "user",
+            "parts": [
+                { "text": "Based on this document, what is my name? Also search the web for the current weather in London." },
+                { "fileData": { "fileUri": gemini_upload['fileReference'], "mimeType": gemini_upload['mimeType'] } }
+            ]
+        }
+    ],
+    "tools": [
+        { "googleSearch": {} } # Enable Google Search tool
+    ]
+}
+
+response = ai.chat(payload, access_token, "gemini-2.5-flash-lite")
+print(response)
+```
+
+## License
+MIT

rnet_oauth-1.0.1/README.md

@@ -0,0 +1,129 @@
+# RNet OAuth Python Library
+
+A Python backend library for integrating **RNet OAuth** and **AI Provider** services. This library allows users to authenticate via RNet and pay for AI model token costs directly using their RNet account.
+
+## Features
+
+- **OAuth2 PKCE Support**: Secure authorization code flow with automatic code verifier and challenge generation.
+- **Token Management**: Exchange authorization codes for tokens and refresh expired tokens.
+- **UserInfo Endpoint**: Fetch the authenticated user's RNet profile with an access token.
+- **AI Integration**: Easy methods to chat with AI models using standard or streaming responses.
+
+## Installation
+
+```bash
+pip install rnet-oauth
+```
+
+## Quick Start
+
+### 1. Initialize the Clients
+```python
+from rnet_oauth import RNetAuth, RNetAi
+
+auth = RNetAuth(
+    client_id='client-id',
+    client_secret='client-secret',
+    redirect_uri='redirect-uri'
+)
+ai = RNetAi()
+```
+
+### 2. Generate Authorization URL (OAuth2 PKCE)
+```python
+# 1. Generate PKCE
+pkce = auth.generate_pkce()
+verifier = pkce['verifier']
+challenge = pkce['challenge']
+
+# 2. Get Authorization URL
+# challenge: PKCE code challenge (optional)
+# state: An optional string to maintain state between the request and callback (recommended for security)
+auth_url = auth.get_authorization_url(challenge, state='optional-state')
+```
+
+### 3. Exchange Code for Tokens
+```python
+# 3. Exchange code for tokens
+tokens = auth.exchange_code_for_token(code, verifier)
+access_token = tokens['access_token']
+```
+
+### 4. Get User Info
+```python
+user_info = auth.get_user_info(access_token)
+print(user_info['email'])
+print(user_info['name'])
+```
+
+The UserInfo response comes from RNet's `/userinfo` endpoint and may include:
+`sub`, `email`, `email_verified`, `name`, `preferred_username`, `user_id`, `role`, and `status`.
+
+### 5. Chat with AI
+```python
+response = ai.chat({
+    "contents": [
+        {
+            "role": "user",
+            "parts": [{"text": "Hello!"}]
+        }
+    ]
+}, access_token, "gemini-2.5-flash-lite")
+```
+
+### 6. Streaming AI Response (Untested)
+```python
+for chunk in ai.chat_stream({
+    "contents": [
+        {
+            "role": "user",
+            "parts": [{"text": "Hello!"}]
+        }
+    ]
+}, access_token, "gemini-2.5-flash-lite"):
+    print(chunk)
+```
+
+### 7. File Upload (Untested)
+```python
+with open("document.pdf", "rb") as f:
+    file_buffer = f.read()
+
+# Upload to Gemini
+gemini_upload = ai.gemini_file_upload(access_token, "gemini-2.5-flash-lite", file_buffer, "application/pdf", "document.pdf")
+print(gemini_upload['fileReference']) # Use this in chat payload
+
+# Upload to OpenAI
+openai_upload = ai.openai_file_upload(access_token, "gpt-4o", file_buffer, "application/pdf", "document.pdf")
+```
+
+### 8. File Deletion (Untested)
+```python
+# Gemini files auto-delete after 48 hours, so there is no delete method.
+# Delete an OpenAI file:
+ai.openai_file_delete(access_token, "gpt-4o", openai_upload['fileReference'])
+```
+
+### 9. AI Chat with File & Tools (Untested)
+```python
+payload = {
+    "contents": [
+        {
+            "role": "user",
+            "parts": [
+                { "text": "Based on this document, what is my name? Also search the web for the current weather in London." },
+                { "fileData": { "fileUri": gemini_upload['fileReference'], "mimeType": gemini_upload['mimeType'] } }
+            ]
+        }
+    ],
+    "tools": [
+        { "googleSearch": {} } # Enable Google Search tool
+    ]
+}
+
+response = ai.chat(payload, access_token, "gemini-2.5-flash-lite")
+print(response)
+```
+
+## License
+MIT

rnet_oauth-1.0.1/pyproject.toml

@@ -0,0 +1,20 @@
+[build-system]
+requires = ["setuptools>=61", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "rnet-oauth"
+version = "1.0.1"
+description = "RNet OAuth Python client library"
+readme = "README.md"
+requires-python = ">=3.8"
+license = "MIT"
+authors = [{name = "rNet Ai"}]
+keywords = ["oauth2", "rnet", "authentication"]
+
+[project.urls]
+Homepage = "https://rnetai.org"
+Repository = "https://github.com/rNetAi/rnet-oauth-python"
+
+[tool.setuptools]
+packages = ["rnet_oauth"]

rnet_oauth-1.0.1/rnet_oauth/__init__.py

@@ -0,0 +1,4 @@
+from .client import RNetAuth, RNetAi
+
+__all__ = ['RNetAuth', 'RNetAi']
+__version__ = '1.0.0'

rnet_oauth-1.0.1/rnet_oauth/client.py

@@ -0,0 +1,286 @@
+import hashlib
+import os
+import base64
+import json
+import urllib.request
+import urllib.error
+from urllib.parse import urlencode
+from typing import Optional, Dict, Any, Generator
+
+ISSUER = "https://central-backend.rnetai.org"
+AI_PROVIDER = "https://ai-provider.rnetai.org"
+
+class RNetAuth:
+    """
+    RNet OAuth Python Library
+    A backend library to verify and exchange OAuth2 tokens and interact with rNet Ai.
+    """
+
+    __slots__ = ("client_id", "client_secret", "redirect_uri")
+
+    def __init__(
+        self,
+        client_id: str,
+        client_secret: str,
+        redirect_uri: str
+    ):
+        if not all([client_id, client_secret, redirect_uri]):
+            raise ValueError("client_id, client_secret, and redirect_uri are required")
+
+        self.client_id = client_id
+        self.client_secret = client_secret
+        self.redirect_uri = redirect_uri
+
+    @property
+    def issuer(self) -> str:
+        return ISSUER
+
+    @property
+    def ai_provider(self) -> str:
+        return AI_PROVIDER
+
+    def generate_pkce(self) -> Dict[str, str]:
+        """Generates a PKCE code_verifier and code_challenge."""
+        verifier_bytes = os.urandom(32)
+        verifier = base64.urlsafe_b64encode(verifier_bytes).decode('utf-8').replace('=', '')
+        
+        challenge_hash = hashlib.sha256(verifier.encode('utf-8')).digest()
+        challenge = base64.urlsafe_b64encode(challenge_hash).decode('utf-8').replace('=', '')
+        
+        return {"verifier": verifier, "challenge": challenge}
+
+    def get_authorization_url(self, challenge: Optional[str] = None, state: Optional[str] = None) -> str:
+        """Generates the authorization URL."""
+        params = {
+            "response_type": "code",
+            "client_id": self.client_id,
+            "redirect_uri": self.redirect_uri,
+            "scope": "openid profile email"
+        }
+
+        if challenge:
+            params["code_challenge"] = challenge
+            params["code_challenge_method"] = "S256"
+            
+        if state:
+            params["state"] = state
+
+        return f"{ISSUER}/oauth2/authorize?{urlencode(params)}"
+
+    def exchange_code_for_token(self, code: str, code_verifier: Optional[str] = None) -> Dict[str, Any]:
+        """Exchanges an authorization code for tokens."""
+        payload = {
+            "grant_type": "authorization_code",
+            "code": code,
+            "redirect_uri": self.redirect_uri
+        }
+        if code_verifier:
+            payload["code_verifier"] = code_verifier
+
+        return self._post_token(payload)
+
+    def refresh_access_token(self, refresh_token: str) -> Dict[str, Any]:
+        """Renews tokens using a refresh token."""
+        payload = {
+            "grant_type": "refresh_token",
+            "refresh_token": refresh_token
+        }
+        return self._post_token(payload)
+
+    def get_user_info(self, access_token: str) -> Dict[str, Any]:
+        """Fetches the authenticated user's profile from the OAuth UserInfo endpoint."""
+        if not access_token:
+            raise ValueError("access_token is required")
+
+        req = urllib.request.Request(
+            f"{ISSUER}/userinfo",
+            headers={
+                'Accept': 'application/json',
+                'Authorization': f'Bearer {access_token}'
+            },
+            method='GET'
+        )
+
+        try:
+            with urllib.request.urlopen(req) as response:
+                return json.loads(response.read().decode('utf-8'))
+        except urllib.error.HTTPError as e:
+            self._handle_error(e)
+
+    def _post_token(self, payload: Dict[str, str]) -> Dict[str, Any]:
+        url = f"{ISSUER}/oauth2/token"
+        data = urlencode(payload).encode('utf-8')
+        
+        auth = base64.b64encode(f"{self.client_id}:{self.client_secret}".encode('utf-8')).decode('utf-8')
+        
+        req = urllib.request.Request(
+            url,
+            data=data,
+            headers={
+                'Content-Type': 'application/x-www-form-urlencoded',
+                'Authorization': f'Basic {auth}'
+            },
+            method='POST'
+        )
+
+        try:
+            with urllib.request.urlopen(req) as response:
+                return json.loads(response.read().decode('utf-8'))
+        except urllib.error.HTTPError as e:
+            self._handle_error(e)
+
+    def _handle_error(self, e: urllib.error.HTTPError):
+        try:
+            error_data = json.loads(e.read().decode('utf-8'))
+            msg = error_data.get("error", str(e))
+        except:
+            msg = str(e)
+        raise RuntimeError(f"Request failed: {e.code} - {msg}")
+
+class RNetAi:
+    """
+    rNet Ai Python Library
+    Interaction with rNet Ai services.
+    """
+
+    __slots__ = ()
+
+    @property
+    def ai_provider(self) -> str:
+        return AI_PROVIDER
+
+    def chat(self, body: Dict[str, Any], access_token: str, model: str) -> Dict[str, Any]:
+        """Calls the rNet Ai Provider API."""
+        if not access_token: raise ValueError("access_token is required")
+        if not model: raise ValueError("model is required")
+
+        query = urlencode({"access_token": access_token, "model": model})
+        url = f"{AI_PROVIDER}/ai?{query}"
+        
+        req = urllib.request.Request(
+            url,
+            data=json.dumps(body).encode('utf-8'),
+            headers={'Content-Type': 'application/json'},
+            method='POST'
+        )
+
+        try:
+            with urllib.request.urlopen(req) as response:
+                return json.loads(response.read().decode('utf-8'))
+        except urllib.error.HTTPError as e:
+            self._handle_error(e)
+
+    def chat_stream(self, body: Dict[str, Any], access_token: str, model: str) -> Generator[str, None, None]:
+        """Calls the rNet Ai Provider API and returns a generator for the response stream."""
+        if not access_token: raise ValueError("access_token is required")
+        if not model: raise ValueError("model is required")
+
+        query = urlencode({"access_token": access_token, "model": model})
+        url = f"{AI_PROVIDER}/ai/stream?{query}"
+        
+        req = urllib.request.Request(
+            url,
+            data=json.dumps(body).encode('utf-8'),
+            headers={'Content-Type': 'application/json'},
+            method='POST'
+        )
+
+        try:
+            response = urllib.request.urlopen(req)
+            for line in response:
+                yield line.decode('utf-8')
+        except urllib.error.HTTPError as e:
+            self._handle_error(e)
+
+    def gemini_file_upload(self, access_token: str, model: str, file_data: bytes, mime_type: str, display_name: str = "") -> Dict[str, Any]:
+        """Uploads a file for use with Gemini models. (Untested)"""
+        return self._upload_file(access_token, model, file_data, mime_type, display_name)
+
+    def openai_file_upload(self, access_token: str, model: str, file_data: bytes, mime_type: str, display_name: str = "") -> Dict[str, Any]:
+        """Uploads a file for use with OpenAI models. (Untested)"""
+        return self._upload_file(access_token, model, file_data, mime_type, display_name)
+
+    def claude_file_upload(self, access_token: str, model: str, file_data: bytes, mime_type: str, display_name: str = "") -> Dict[str, Any]:
+        """Uploads a file for use with Claude models. (Untested)"""
+        return self._upload_file(access_token, model, file_data, mime_type, display_name)
+
+    def openai_file_delete(self, access_token: str, model: str, file_id: str) -> Dict[str, Any]:
+        """Deletes a file previously uploaded for OpenAI models. (Untested)"""
+        return self._delete_file(access_token, model, file_id)
+
+    def claude_file_delete(self, access_token: str, model: str, file_id: str) -> Dict[str, Any]:
+        """Deletes a file previously uploaded for Claude models. (Untested)"""
+        return self._delete_file(access_token, model, file_id)
+
+    def _upload_file(self, access_token: str, model: str, file_data: bytes, mime_type: str, display_name: str) -> Dict[str, Any]:
+        if not access_token: raise ValueError("access_token is required")
+        if not model: raise ValueError("model is required")
+        if not file_data: raise ValueError("file_data is required")
+        if not mime_type: raise ValueError("mime_type is required")
+
+        query = urlencode({"access_token": access_token, "model": model})
+        url = f"{AI_PROVIDER}/ai/upload?{query}"
+
+        import uuid
+        boundary = uuid.uuid4().hex
+        
+        body = bytearray()
+        
+        # Add file part
+        body.extend(f"--{boundary}\r\n".encode('utf-8'))
+        filename = display_name if display_name else "file"
+        body.extend(f'Content-Disposition: form-data; name="file"; filename="{filename}"\r\n'.encode('utf-8'))
+        body.extend(f'Content-Type: {mime_type}\r\n\r\n'.encode('utf-8'))
+        body.extend(file_data)
+        body.extend(b'\r\n')
+        
+        # Add mimeType part
+        body.extend(f"--{boundary}\r\n".encode('utf-8'))
+        body.extend(b'Content-Disposition: form-data; name="mimeType"\r\n\r\n')
+        body.extend(mime_type.encode('utf-8'))
+        body.extend(b'\r\n')
+        
+        # Add displayName part
+        body.extend(f"--{boundary}\r\n".encode('utf-8'))
+        body.extend(b'Content-Disposition: form-data; name="displayName"\r\n\r\n')
+        body.extend(display_name.encode('utf-8'))
+        body.extend(b'\r\n')
+        
+        body.extend(f"--{boundary}--\r\n".encode('utf-8'))
+
+        req = urllib.request.Request(
+            url,
+            data=bytes(body),
+            headers={'Content-Type': f'multipart/form-data; boundary={boundary}'},
+            method='POST'
+        )
+
+        try:
+            with urllib.request.urlopen(req) as response:
+                return json.loads(response.read().decode('utf-8'))
+        except urllib.error.HTTPError as e:
+            self._handle_error(e)
+
+    def _delete_file(self, access_token: str, model: str, file_id: str) -> Dict[str, Any]:
+        if not access_token: raise ValueError("access_token is required")
+        if not model: raise ValueError("model is required")
+        if not file_id: raise ValueError("file_id is required")
+
+        query = urlencode({"access_token": access_token, "model": model, "fileId": file_id})
+        url = f"{AI_PROVIDER}/ai/upload?{query}"
+
+        req = urllib.request.Request(url, method='DELETE')
+
+        try:
+            with urllib.request.urlopen(req) as response:
+                return json.loads(response.read().decode('utf-8'))
+        except urllib.error.HTTPError as e:
+            self._handle_error(e)
+
+    def _handle_error(self, e: urllib.error.HTTPError):
+        try:
+            error_data = json.loads(e.read().decode('utf-8'))
+            msg = error_data.get("error", str(e))
+        except:
+            msg = str(e)
+        raise RuntimeError(f"Request failed: {e.code} - {msg}")

rnet_oauth-1.0.1/rnet_oauth.egg-info/PKG-INFO

@@ -0,0 +1,143 @@
+Metadata-Version: 2.4
+Name: rnet-oauth
+Version: 1.0.1
+Summary: RNet OAuth Python client library
+Author: rNet Ai
+License-Expression: MIT
+Project-URL: Homepage, https://rnetai.org
+Project-URL: Repository, https://github.com/rNetAi/rnet-oauth-python
+Keywords: oauth2,rnet,authentication
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# RNet OAuth Python Library
+
+A Python backend library for integrating **RNet OAuth** and **AI Provider** services. This library allows users to authenticate via RNet and pay for AI model token costs directly using their RNet account.
+
+## Features
+
+- **OAuth2 PKCE Support**: Secure authorization code flow with automatic code verifier and challenge generation.
+- **Token Management**: Exchange authorization codes for tokens and refresh expired tokens.
+- **UserInfo Endpoint**: Fetch the authenticated user's RNet profile with an access token.
+- **AI Integration**: Easy methods to chat with AI models using standard or streaming responses.
+
+## Installation
+
+```bash
+pip install rnet-oauth
+```
+
+## Quick Start
+
+### 1. Initialize the Clients
+```python
+from rnet_oauth import RNetAuth, RNetAi
+
+auth = RNetAuth(
+    client_id='client-id',
+    client_secret='client-secret',
+    redirect_uri='redirect-uri'
+)
+ai = RNetAi()
+```
+
+### 2. Generate Authorization URL (OAuth2 PKCE)
+```python
+# 1. Generate PKCE
+pkce = auth.generate_pkce()
+verifier = pkce['verifier']
+challenge = pkce['challenge']
+
+# 2. Get Authorization URL
+# challenge: PKCE code challenge (optional)
+# state: An optional string to maintain state between the request and callback (recommended for security)
+auth_url = auth.get_authorization_url(challenge, state='optional-state')
+```
+
+### 3. Exchange Code for Tokens
+```python
+# 3. Exchange code for tokens
+tokens = auth.exchange_code_for_token(code, verifier)
+access_token = tokens['access_token']
+```
+
+### 4. Get User Info
+```python
+user_info = auth.get_user_info(access_token)
+print(user_info['email'])
+print(user_info['name'])
+```
+
+The UserInfo response comes from RNet's `/userinfo` endpoint and may include:
+`sub`, `email`, `email_verified`, `name`, `preferred_username`, `user_id`, `role`, and `status`.
+
+### 5. Chat with AI
+```python
+response = ai.chat({
+    "contents": [
+        {
+            "role": "user",
+            "parts": [{"text": "Hello!"}]
+        }
+    ]
+}, access_token, "gemini-2.5-flash-lite")
+```
+
+### 6. Streaming AI Response (Untested)
+```python
+for chunk in ai.chat_stream({
+    "contents": [
+        {
+            "role": "user",
+            "parts": [{"text": "Hello!"}]
+        }
+    ]
+}, access_token, "gemini-2.5-flash-lite"):
+    print(chunk)
+```
+
+### 7. File Upload (Untested)
+```python
+with open("document.pdf", "rb") as f:
+    file_buffer = f.read()
+
+# Upload to Gemini
+gemini_upload = ai.gemini_file_upload(access_token, "gemini-2.5-flash-lite", file_buffer, "application/pdf", "document.pdf")
+print(gemini_upload['fileReference']) # Use this in chat payload
+
+# Upload to OpenAI
+openai_upload = ai.openai_file_upload(access_token, "gpt-4o", file_buffer, "application/pdf", "document.pdf")
+```
+
+### 8. File Deletion (Untested)
+```python
+# Gemini files auto-delete after 48 hours, so there is no delete method.
+# Delete an OpenAI file:
+ai.openai_file_delete(access_token, "gpt-4o", openai_upload['fileReference'])
+```
+
+### 9. AI Chat with File & Tools (Untested)
+```python
+payload = {
+    "contents": [
+        {
+            "role": "user",
+            "parts": [
+                { "text": "Based on this document, what is my name? Also search the web for the current weather in London." },
+                { "fileData": { "fileUri": gemini_upload['fileReference'], "mimeType": gemini_upload['mimeType'] } }
+            ]
+        }
+    ],
+    "tools": [
+        { "googleSearch": {} } # Enable Google Search tool
+    ]
+}
+
+response = ai.chat(payload, access_token, "gemini-2.5-flash-lite")
+print(response)
+```
+
+## License
+MIT

rnet_oauth-1.0.1/rnet_oauth.egg-info/SOURCES.txt

@@ -0,0 +1,9 @@
+LICENSE
+README.md
+pyproject.toml
+rnet_oauth/__init__.py
+rnet_oauth/client.py
+rnet_oauth.egg-info/PKG-INFO
+rnet_oauth.egg-info/SOURCES.txt
+rnet_oauth.egg-info/dependency_links.txt
+rnet_oauth.egg-info/top_level.txt

rnet_oauth-1.0.1/rnet_oauth.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

rnet_oauth-1.0.1/rnet_oauth.egg-info/top_level.txt

@@ -0,0 +1 @@
+rnet_oauth

rnet_oauth-1.0.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+