+
+### Please, follow these steps to contribute:
+1. Reverse a website from this list: [sites-to-reverse](https://github.com/xtekky/gpt4free/issues/40)
+2. Add it to [./etc/unittest/](https://github.com/xtekky/gpt4free/tree/main/etc/unittest/)
+3. Refactor it and add it to [./g4f](https://github.com/xtekky/gpt4free/tree/main/g4f)
+
+### We will be grateful to see you as a contributor!
\ No newline at end of file
diff --git a/gpt4free/LEGAL_NOTICE.md b/gpt4free/LEGAL_NOTICE.md
new file mode 100644
index 0000000000000000000000000000000000000000..50a1d141037c6983fff9a99c583c2c1597787b35
--- /dev/null
+++ b/gpt4free/LEGAL_NOTICE.md
@@ -0,0 +1,55 @@
+## Legal Notice
+
+This repository is **not associated with or endorsed** by the providers of the APIs contained herein. This project is intended **for educational purposes only**. It is a personal project aimed at learning and exploration. Owners of any included sites or services may contact me to improve their security or request the removal of their content from this repository.
+
+### **Affiliation Disclaimer**
+
+This repository is not associated with or endorsed by any of the API providers mentioned herein. All trademarks, API services, and other intellectual property referenced are the property of their respective owners. No claim of ownership or affiliation is made by this project.
+
+### **Liability Limitation**
+
+Under no circumstances shall the author of this repository be liable for any direct, indirect, incidental, special, consequential, or punitive damages—including but not limited to loss of profits, data, or use—arising out of or in connection with the repository. This limitation applies regardless of whether such damages were foreseeable or whether the author was advised of the possibility of such damages.
+
+### **No Warranties**
+
+This repository is provided on an "as is" and "as available" basis without any warranties of any kind, express or implied. This includes, but is not limited to, implied warranties of merchantability, fitness for a particular purpose, and non-infringement.
+
+### **User Responsibility**
+
+Users assume all risks associated with the use of this repository. They are solely responsible for any damage or loss—including financial loss—that results from the use or misuse of the repository and its contents.
+
+### **Legal Compliance**
+
+Users are responsible for ensuring that their use of the repository and its contents complies with all applicable local, state, national, and international laws and regulations.
+
+### **Indemnification**
+
+Users agree to indemnify, defend, and hold harmless the author from any claims, liabilities, damages, losses, or expenses—including legal fees—arising out of or in any way connected with their use of this repository, violation of these terms, or infringement of any intellectual property or other rights of any person or entity.
+
+### **No Endorsement**
+
+The inclusion of third-party content does not imply endorsement or recommendation of such content by the author.
+
+### **Governing Law and Jurisdiction**
+
+Any disputes arising out of or related to the use of this repository shall be governed by the laws of the author's jurisdiction, without regard to conflict of law principles.
+
+### **Severability**
+
+If any provision of this notice is found to be unlawful, void, or unenforceable, that provision shall be deemed severable from this notice and shall not affect the validity and enforceability of the remaining provisions.
+
+### **Acknowledgment of Understanding**
+
+By using this repository, users acknowledge that they have read, understood, and agree to be bound by these terms.
+
+### **Updates and Changes**
+
+The author reserves the right to modify, update, or remove any content, information, or features in this repository at any time without prior notice. Users are responsible for regularly reviewing the content and any changes made to this repository.
+
+### **Unforeseen Consequences**
+
+The author is not responsible for any consequences, damages, or losses arising from the use or misuse of this repository or the content provided by third-party APIs. Users are solely responsible for their actions and any repercussions that may follow.
+
+### **Educational Purpose**
+
+This project and its content are provided strictly for educational purposes. Users acknowledge that they are using the APIs and models at their own risk and agree to comply with all applicable laws and regulations.
diff --git a/gpt4free/LICENSE b/gpt4free/LICENSE
new file mode 100644
index 0000000000000000000000000000000000000000..e72bfddabc15be5718a7cc061ac10e47741d8219
--- /dev/null
+++ b/gpt4free/LICENSE
@@ -0,0 +1,674 @@
+ GNU GENERAL PUBLIC LICENSE
+ Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc.
+
+
+
+ Created by @xtekky,
maintained by @hlohaus
+
+
+Support the project on + + GitHub Sponsors + + ❤️ +
++Live demo & docs: https://g4f.dev | Documentation: https://g4f.dev/docs +
+ +--- + +GPT4Free (g4f) is a community-driven project that aggregates multiple accessible providers and interfaces to make working with modern LLMs and media-generation models easier and more flexible. GPT4Free aims to offer multi-provider support, local GUI, OpenAI-compatible REST APIs, and convenient Python and JavaScript clients — all under a community-first license. + +This README is a consolidated, improved, and complete guide to installing, running, and contributing to GPT4Free. + +Table of contents +- [What’s included](#whats-included) +- [Quick links](#quick-links) +- [Requirements & compatibility](#requirements--compatibility) +- [Installation](#installation) + - [Docker (recommended)](#docker-recommended) + - [Slim Docker image](#slim-docker-image) + - [Windows (.exe)](#windows-exe) + - [Python (pip / from source / partial installs)](#python-pip--from-source--partial-installs) +- [Running the app](#running-the-app) + - [GUI (web client)](#gui-web-client) + - [FastAPI / Interference API](#fastapi--interference-api) + - [CLI](#cli) + - [Optional provider login (desktop in container)](#optional-provider-login-desktop-in-container) +- [Using the Python client](#using-the-python-client) + - [Synchronous text example](#synchronous-text-example) + - [Image generation example](#image-generation-example) + - [Async client example](#async-client-example) +- [Using GPT4Free.js (browser JS client)](#using-gpt4freejs-browser-js-client) +- [Providers & models (overview)](#providers--models-overview) +- [Local inference & media](#local-inference--media) +- [Configuration & customization](#configuration--customization) +- [Running on smartphone](#running-on-smartphone) +- [Interference API (OpenAI‑compatible)](#interference-api-openai-compatible) +- [Examples & common patterns](#examples--common-patterns) +- [Contributing](#contributing) + - [How to create a new provider](#how-to-create-a-new-provider) + - [How AI can help you write code](#how-ai-can-help-you-write-code) +- [Security, privacy & takedown policy](#security-privacy--takedown-policy) +- [Credits, contributors & attribution](#credits-contributors--attribution) +- [Powered-by highlights](#powered-by-highlights) +- [Changelog & releases](#changelog--releases) +- [Manifesto / Project principles](#manifesto--project-principles) +- [License](#license) +- [Contact & sponsorship](#contact--sponsorship) +- [Appendix: Quick commands & examples](#appendix-quick-commands--examples) + +--- + +## What’s included +- Python client library and async client. +- Optional local web GUI. +- FastAPI-based OpenAI-compatible API (Interference API). +- Official browser JS client (g4f.dev distribution). +- Docker images (full and slim). +- Multi-provider adapters (LLMs, media providers, local inference backends). +- Tooling for image/audio/video generation and media persistence. + +--- + +## Quick links +- Website & docs: https://g4f.dev | https://g4f.dev/docs +- PyPI: https://pypi.org/project/g4f +- Docker image: https://hub.docker.com/r/hlohaus789/g4f +- Releases: https://github.com/xtekky/gpt4free/releases +- Issues: https://github.com/xtekky/gpt4free/issues +- Community: Telegram (https://telegram.me/g4f_channel) · Discord News (https://discord.gg/5E39JUWUFa) · Discord Support (https://discord.gg/qXA4Wf4Fsm) + +--- + +## Requirements & compatibility +- Python 3.10+ recommended. +- Google Chrome/Chromium for providers using browser automation. +- Docker for containerized deployment. +- Works on x86_64 and arm64 (slim image supports both). +- Some provider adapters may require platform-specific tooling (Chrome/Chromium, etc.). Check provider docs for details. + +--- + +## Installation + +### Docker (recommended) +1. Install Docker: https://docs.docker.com/get-docker/ +2. Create persistent directories: + - Example (Linux/macOS): + ```bash + mkdir -p ${PWD}/har_and_cookies ${PWD}/generated_media + sudo chown -R 1200:1201 ${PWD}/har_and_cookies ${PWD}/generated_media + ``` +3. Pull image: + ```bash + docker pull hlohaus789/g4f + ``` +4. Run container: + ```bash + docker run -p 8080:8080 -p 7900:7900 \ + --shm-size="2g" \ + -v ${PWD}/har_and_cookies:/app/har_and_cookies \ + -v ${PWD}/generated_media:/app/generated_media \ + hlohaus789/g4f:latest + ``` +Notes: +- Port 8080 serves GUI/API; 7900 can expose a VNC-like desktop for provider logins (optional). +- Increase --shm-size for heavier browser automation tasks. + +### Slim Docker image (x64 & arm64) +```bash +mkdir -p ${PWD}/har_and_cookies ${PWD}/generated_media +chown -R 1000:1000 ${PWD}/har_and_cookies ${PWD}/generated_media + +docker run \ + -p 1337:8080 -p 8080:8080 \ + -v ${PWD}/har_and_cookies:/app/har_and_cookies \ + -v ${PWD}/generated_media:/app/generated_media \ + hlohaus789/g4f:latest-slim +``` +Notes: +- The slim image can update the g4f package on startup and installs additional dependencies as needed. +- In this example, the Interference API is mapped to 1337. + +### Windows Guide (.exe) +1. Download the release artifact `g4f.exe.zip` from: + https://github.com/xtekky/gpt4free/releases/latest +2. Unzip and run `g4f.exe`. +3. Open GUI at: http://localhost:8080/chat/ +4. If Windows Firewall blocks access, allow the application. + +### Python Installation (pip / from source / partial installs) + +Prerequisites: +- Python 3.10+ (https://www.python.org/downloads/) +- Chrome/Chromium for some providers. + +Install from PyPI (recommended): +```bash +pip install -U g4f[all] +``` + +Partial installs +- To install only specific functionality, use optional extras groups. See docs/requirements.md in the project docs. + +Install from source: +```bash +git clone https://github.com/xtekky/gpt4free.git +cd gpt4free +pip install -r requirements.txt +pip install -e . +``` + +Notes: +- Some features require Chrome/Chromium or other tools; follow provider-specific docs. + +--- + +## Running the app + +### GUI (web client) +- Run via Python: +```python +from g4f.gui import run_gui +run_gui() +``` +- Or via CLI: +```bash +python -m g4f.cli gui --port 8080 --debug +``` +- Open: http://localhost:8080/chat/ + +### FastAPI / Interference API +- Start FastAPI server: +```bash +python -m g4f --port 8080 --debug +``` +- If using slim docker mapping, Interference API may be available at `http://localhost:1337/v1` +- Swagger UI: `http://localhost:1337/docs` + +### CLI +- Start GUI server: +```bash +python -m g4f.cli gui --port 8080 --debug +``` + +### Optional provider login (desktop within container) +- Accessible at: + ``` + http://localhost:7900/?autoconnect=1&resize=scale&password=secret + ``` +- Useful for logging into web-based providers to obtain cookies/HAR files. + +--- + +## Using the Python client + +Install: +```bash +pip install -U g4f[all] +``` + +Synchronous text example: +```python +from g4f.client import Client + +client = Client() +response = client.chat.completions.create( + model="gpt-4o-mini", + messages=[{"role": "user", "content": "Hello, how are you?"}], + web_search=False +) +print(response.choices[0].message.content) +``` +Expected: +``` +Hello! How can I assist you today? +``` + +Image generation example: +```python +from g4f.client import Client + +client = Client() +response = client.images.generate( + model="flux", + prompt="a white siamese cat", + response_format="url" +) +print(f"Generated image URL: {response.data[0].url}") +``` + +Async client example: +```python +from g4f.async_client import AsyncClient +import asyncio + +async def main(): + client = AsyncClient() + response = await client.chat.completions.create( + model="gpt-4o-mini", + messages=[{"role": "user", "content": "Explain quantum computing briefly"}], + ) + print(response.choices[0].message.content) + +asyncio.run(main()) +``` + +Notes: +- See the full API reference for streaming, tool-calling patterns, and advanced options: https://g4f.dev/docs/client + +--- + +## Using GPT4Free.js (browser JS client) +Use the official JS client in the browser—no backend required. + +Example: +```html + +``` + +Notes: +- The JS client is distributed via the g4f.dev CDN for easy usage. Review CORS considerations and usage limits. + +--- + +## Providers & models (overview) +- GPT4Free integrates many providers including (but not limited to) OpenAI-compatible endpoints, PerplexityLabs, Gemini, MetaAI, Pollinations (media), and local inference backends. +- Model availability and behavior depend on provider capabilities. See the providers doc for current, supported provider/model lists: https://g4f.dev/docs/providers-and-models + +Provider requirements may include: +- API keys or tokens (for authenticated providers) +- Browser cookies / HAR files for providers scraped via browser automation +- Chrome/Chromium or headless browser tooling +- Local model binaries and runtime (for local inference) + +--- + +## Local inference & media +- GPT4Free supports local inference backends. See [docs/local.md](https://github.com/gpt4free/g4f.dev/blob/main/docs/local.md) for supported runtimes and hardware guidance. +- Media generation (image, audio, video) is supported through providers (e.g., Pollinations). See [docs/media.md](https://github.com/gpt4free/g4f.dev/blob/main/docs/media.md) for formats, options, and sample usage. + +--- + +## Configuration & customization +- Configure via environment variables, CLI flags, or config files. See [docs/config.md](https://github.com/gpt4free/g4f.dev/blob/main/docs/config.md). +- To reduce install size, use partial requirement groups. See [docs/requirements.md](https://github.com/gpt4free/g4f.dev/blob/main/docs/requirements.md). +- Provider selection: learn how to set defaults and override per-request at [docs/selecting_a_provider.md](https://github.com/gpt4free/g4f.dev/blob/main/docs/selecting_a_provider.md). +- Persistence: HAR files, cookies, and generated media persist in mapped directories (e.g., har_and_cookies, generated_media). + +--- + +## Running on smartphone +- The web GUI is responsive and can be accessed from a phone by visiting your host IP:8080 or via a tunnel. See [docs/guides/phone.md](https://github.com/gpt4free/g4f.dev/blob/main/docs/guides/phone.md). + +--- + +## Interference API (OpenAI‑compatible) +- The Interference API enables OpenAI-like workflows routed through GPT4Free provider selection. +- Docs: [docs/interference-api.md](https://github.com/gpt4free/g4f.dev/blob/main/docs/interference-api.md) +- Default endpoint (example slim docker): `http://localhost:1337/v1` +- Swagger UI: `http://localhost:1337/docs` + +--- + +## Examples & common patterns +- Streaming completions, stopping criteria, system messages, and tool-calling patterns are documented in: + - [docs/client.md](https://github.com/gpt4free/g4f.dev/blob/main/docs/client.md) + - [docs/async_client.md](https://github.com/gpt4free/g4f.dev/blob/main/docs/async_client.md) + - [docs/requests.md](https://github.com/gpt4free/g4f.dev/blob/main/docs/requests.md) +- Integrations (LangChain, PydanticAI): [docs/pydantic_ai.md](https://github.com/gpt4free/g4f.dev/blob/main/docs/pydantic_ai.md) +- Legacy examples: [docs/legacy.md](https://github.com/gpt4free/g4f.dev/blob/main/docs/legacy.md) + +--- + +## Contributing +Contributions are welcome — new providers, features, docs, and fixes are appreciated. + +How to contribute: +1. Fork the repository. +2. Create a branch for your change. +3. Run tests and linters. +4. Open a Pull Request with a clear description and tests/examples if applicable. + +Repository: https://github.com/xtekky/gpt4free + +### How to create a new provider +- Read the guide: [docs/guides/create_provider.md](https://github.com/gpt4free/g4f.dev/blob/main/docs/guides/create_provider.md) +- Typical steps: + - Implement a provider adapter in `g4f/Provider/` + - Add configuration and dependency notes + - Include tests and usage examples + - Respect third‑party code licenses and attribute appropriately + +### How AI can help you write code +- See: [docs/guides/help_me.md](https://github.com/gpt4free/g4f.dev/blob/main/docs/guides/help_me.md) for prompt templates and workflows to accelerate development. + +--- + +## Security, privacy & takedown policy +- Do not store or share sensitive credentials. Use per-provider recommended security practices. +- If your site appears in the project’s links and you want it removed, send proof of ownership to takedown@g4f.ai and it will be removed promptly. +- For production, secure the server with HTTPS, authentication, and firewall rules. Limit access to provider credentials and cookie/HAR storage. + +--- + +## Credits, contributors & attribution +- Core creators: [@xtekky](https://github.com/xtekky) (original), maintained by [@hlohaus](https://github.com/hlohaus). +- Full contributor graph: https://github.com/xtekky/gpt4free/graphs/contributors +- Notable code inputs and attributions: + - `har_file.py` — input from [xqdoo00o/ChatGPT-to-API](https://github.com/xqdoo00o/ChatGPT-to-API) + - `PerplexityLabs.py` — input from [nathanrchn/perplexityai](https://github.com/nathanrchn/perplexityai) + - `Gemini.py` — input from [dsdanielpark/Gemini-API](https://github.com/dsdanielpark/Gemini-API) and [HanaokaYuzu/Gemini-API](https://github.com/HanaokaYuzu/Gemini-API) + - `MetaAI.py` — inspired by [meta-ai-api by Strvm](https://github.com/Strvm/meta-ai-api) + - `proofofwork.py` — input from [missuo/FreeGPT35](https://github.com/missuo/FreeGPT35) + +Many more contributors are acknowledged in the repository. + +--- + +## Powered-by highlights +- Pollinations AI — generative media: https://github.com/pollinations/pollinations +- MoneyPrinter V2 — example project using GPT4Free: https://github.com/FujiwaraChoki/MoneyPrinterV2 +- For a full list of projects and sites using GPT4Free, see: [docs/powered-by.md](https://github.com/gpt4free/g4f.dev/blob/main/docs/powered-by.md) + +--- + +## Changelog & releases +- Releases and full changelog: https://github.com/xtekky/gpt4free/releases +- Subscribe to Discord/Telegram for announcements. + +--- + +## Manifesto / Project principles +GPT4Free is guided by community principles: +1. Open access to AI tooling and models. +2. Collaboration across providers and projects. +3. Opposition to monopolistic, closed systems that restrict creativity. +4. Community-centered development and broad access to AI technologies. +5. Promote innovation, creativity, and accessibility. + +https://g4f.dev/manifest + +--- + +## License +This program is licensed under the GNU General Public License v3.0 (GPLv3). See the full license: https://www.gnu.org/licenses/gpl-3.0.txt + +Summary: +- You may redistribute and/or modify under the terms of GPLv3. +- The program is provided WITHOUT ANY WARRANTY. + +Copyright notice +``` +xtekky/gpt4free: Copyright (C) 2025 xtekky + +This program is free software: you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation, either version 3 of the License, or +(at your option) any later version. + +This program is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. +``` + +--- + +## Contact & sponsorship +- Maintainers: https://github.com/hlohaus +- Sponsorship: https://github.com/sponsors/hlohaus +- Issues & feature requests: https://github.com/xtekky/gpt4free/issues +- Takedown requests: takedown@g4f.ai + +--- + +## Appendix: Quick commands & examples + +Install (pip): +```bash +pip install -U g4f[all] +``` + +Run GUI (Python): +```bash +python -m g4f.cli gui --port 8080 --debug +# or +python -c "from g4f.gui import run_gui; run_gui()" +``` + +Docker (full): +```bash +docker pull hlohaus789/g4f +docker run -p 8080:8080 -p 7900:7900 \ + --shm-size="2g" \ + -v ${PWD}/har_and_cookies:/app/har_and_cookies \ + -v ${PWD}/generated_media:/app/generated_media \ + hlohaus789/g4f:latest +``` + +Docker (slim): +```bash +docker run -p 1337:8080 -p 8080:8080 \ + -v ${PWD}/har_and_cookies:/app/har_and_cookies \ + -v ${PWD}/generated_media:/app/generated_media \ + hlohaus789/g4f:latest-slim +``` + +Python usage patterns: +- `client.chat.completions.create(...)` +- `client.images.generate(...)` +- Async variants via `AsyncClient` + +Docs & deeper reading +- Full docs: https://g4f.dev/docs +- Client API docs: https://g4f.dev/docs/client +- Async client docs: https://g4f.dev/docs/async_client +- Provider guides: https://g4f.dev/docs/guides +- Local inference: https://g4f.dev/docs/local + +--- + +Thank you for using and contributing to GPT4Free — together we make powerful AI tooling accessible, flexible, and community-driven. \ No newline at end of file diff --git a/gpt4free/SECURITY.md b/gpt4free/SECURITY.md new file mode 100644 index 0000000000000000000000000000000000000000..11d63c4fee954664ad690f319c445fcb7a4959cb --- /dev/null +++ b/gpt4free/SECURITY.md @@ -0,0 +1,4 @@ +## Reporting a Vulnerability + +Reporting a Vulnerability +Please report (suspected) security vulnerabilities to https://t.me/xtekky. You will receive a response within 48 hours. If the issue is confirmed, we will release a patch as soon as possible depending on complexity but historically within a few days. \ No newline at end of file diff --git a/gpt4free/docker-compose-slim.yml b/gpt4free/docker-compose-slim.yml new file mode 100644 index 0000000000000000000000000000000000000000..5976a524b3222b78083c938221dd428203eb8bc8 --- /dev/null +++ b/gpt4free/docker-compose-slim.yml @@ -0,0 +1,15 @@ +version: '3' + +services: + g4f-slim: + container_name: g4f-slim + image: hlohaus789/g4f:latest-slim + build: + context: . + dockerfile: docker/Dockerfile-slim + volumes: + - ./generated_media:/app/generated_media + - ./har_and_cookies:/app/har_and_cookies + ports: + - '8080:8080' + - '1337:8080' \ No newline at end of file diff --git a/gpt4free/docker-compose.yml b/gpt4free/docker-compose.yml new file mode 100644 index 0000000000000000000000000000000000000000..8d9dd722bec82ec130cfac66cd4c0c8323ab7917 --- /dev/null +++ b/gpt4free/docker-compose.yml @@ -0,0 +1,17 @@ +version: '3' + +services: + gpt4free: + image: hlohaus789/g4f:latest + shm_size: 2gb + build: + context: . + dockerfile: docker/Dockerfile + volumes: + - .:/app + ports: + - '8080:8080' + - '1337:8080' + - '7900:7900' + environment: + - OLLAMA_HOST=host.docker.internal diff --git a/gpt4free/docker/Dockerfile b/gpt4free/docker/Dockerfile new file mode 100644 index 0000000000000000000000000000000000000000..9f7e699069f1ceb1cdb9ae22ebfd23dae8bf2bfa --- /dev/null +++ b/gpt4free/docker/Dockerfile @@ -0,0 +1,55 @@ +FROM selenium/node-chrome + +ARG G4F_VERSION +ENV G4F_VERSION $G4F_VERSION + +ENV SE_SCREEN_WIDTH 1850 +ENV G4F_DIR /app +ENV G4F_LOGIN_URL http://localhost:7900/?autoconnect=1&resize=scale&password=secret + +USER root + +# If docker compose, install git +RUN if [ "$G4F_VERSION" = "" ] ; then \ + apt-get -qqy update && \ + apt-get -qqy install git \ + ; fi + +# Install Python3, pip, remove OpenJDK 11, clean up +RUN apt-get -qqy update \ + && apt-get -qqy upgrade \ + && apt-get -qyy autoremove \ + && apt-get -qqy install python3 python-is-python3 pip ffmpeg flac libavcodec-extra \ + && apt-get -qyy remove openjdk-11-jre-headless \ + && apt-get -qyy autoremove \ + && apt-get -qyy clean \ + && rm -rf /var/lib/apt/lists/* /var/cache/apt/* + +# Update entrypoint +COPY docker/supervisor.conf /etc/supervisor/conf.d/selenium.conf +COPY docker/supervisor-api.conf /etc/supervisor/conf.d/api.conf + +# Change background image +COPY docker/background.png /usr/share/images/fluxbox/ubuntu-light.png + +# Add user, fix permissions +RUN chown "${SEL_UID}:${SEL_GID}" $HOME/.local /opt/venv/share + +# Switch user +USER $SEL_UID + +# Set the working directory in the container. +WORKDIR $G4F_DIR + +# Copy the project's requirements file into the container. +COPY requirements.txt $G4F_DIR + +# Upgrade pip for the latest features and install the project's Python dependencies. +RUN pip install --break-system-packages --upgrade pip \ + && pip install --break-system-packages -r requirements.txt + +# Copy the entire package into the container. +ADD --chown=$SEL_UID:$SEL_GID g4f $G4F_DIR/g4f + +# Expose ports +EXPOSE 8080 7900 \ No newline at end of file diff --git a/gpt4free/docker/Dockerfile-armv7 b/gpt4free/docker/Dockerfile-armv7 new file mode 100644 index 0000000000000000000000000000000000000000..5173d1d7b19175acd1844231c7568a8c94c09cc8 --- /dev/null +++ b/gpt4free/docker/Dockerfile-armv7 @@ -0,0 +1,71 @@ +FROM python:slim-bookworm + +ARG G4F_VERSION +ARG G4F_USER=g4f +ARG G4F_USER_ID=1000 +ARG PYDANTIC_VERSION=1.8.1 + +ENV G4F_VERSION $G4F_VERSION +ENV G4F_USER $G4F_USER +ENV G4F_USER_ID $G4F_USER_ID +ENV G4F_DIR /app + +RUN apt-get update && apt-get upgrade -y \ + && apt-get install -y git curl \ + && apt-get install --quiet --yes --no-install-recommends \ + build-essential libffi-dev zlib1g-dev libjpeg-dev libssl-dev pkg-config \ +# Add user and user group + && groupadd -g $G4F_USER_ID $G4F_USER \ + && useradd -rm -G sudo -u $G4F_USER_ID -g $G4F_USER_ID $G4F_USER \ + && mkdir -p /var/log/supervisor \ + && chown "${G4F_USER_ID}:${G4F_USER_ID}" /var/log/supervisor \ + && echo "${G4F_USER}:${G4F_USER}" | chpasswd \ + && python -m pip install --upgrade pip + +USER $G4F_USER_ID +WORKDIR $G4F_DIR + +ENV HOME /home/$G4F_USER +ENV PATH "${HOME}/.local/bin:${HOME}/.cargo/bin:${PATH}" + +# Install rust toolchain +RUN curl https://sh.rustup.rs -sSf | bash -s -- -y + +# Create app dir and copy the project's requirements file into it +RUN mkdir -p $G4F_DIR +COPY requirements-min.txt $G4F_DIR +COPY requirements-slim.txt $G4F_DIR + +# Upgrade pip for the latest features and install the project's Python dependencies. +RUN pip install --no-cache-dir -r requirements-min.txt \ + && pip install --no-cache-dir --no-binary setuptools \ + Cython==0.29.22 \ + setuptools \ + # Install PyDantic + && pip install \ + -vvv \ + --no-cache-dir \ + --no-binary :all: \ + --global-option=build_ext \ + --global-option=-j8 \ + pydantic==${PYDANTIC_VERSION} +RUN cat requirements-slim.txt | xargs -n 1 timeout 5m pip install --no-cache-dir || true + +# Remove build packages +RUN pip uninstall --yes \ + Cython \ + setuptools + +USER root + +# Clean up build deps +RUN rm --recursive --force "${HOME}/.rustup" +RUN apt-get purge --auto-remove --yes \ + build-essential \ + && apt-get clean \ + && rm --recursive --force /var/lib/apt/lists/* /tmp/* /var/tmp/* + +USER $G4F_USER_ID + +# Copy the entire package into the container. +ADD --chown=$G4F_USER:$G4F_USER g4f $G4F_DIR/g4f diff --git a/gpt4free/docker/Dockerfile-slim b/gpt4free/docker/Dockerfile-slim new file mode 100644 index 0000000000000000000000000000000000000000..4219c8b0c7d0ec6bc2fdc72c45d5732e0c2b5fdb --- /dev/null +++ b/gpt4free/docker/Dockerfile-slim @@ -0,0 +1,39 @@ +FROM python:slim-bookworm + +ARG G4F_VERSION +ARG G4F_LIVE=true +ARG G4F_USER=g4f +ARG G4F_USER_ID=1000 + +ENV G4F_VERSION $G4F_VERSION +ENV G4F_LIVE $G4F_LIVE +ENV G4F_USER $G4F_USER +ENV G4F_USER_ID $G4F_USER_ID +ENV G4F_DIR /app + +RUN apt-get update && apt-get upgrade -y \ + && apt-get install -y git cron ffmpeg flac \ +# Add user and user group + && groupadd -g $G4F_USER_ID $G4F_USER \ + && useradd -rm -G sudo -u $G4F_USER_ID -g $G4F_USER_ID $G4F_USER \ + && echo "${G4F_USER}:${G4F_USER}" | chpasswd \ + && python -m pip install --upgrade pip \ + && apt-get clean \ + && rm --recursive --force /var/lib/apt/lists/* /tmp/* /var/tmp/* + +RUN mkdir -p $G4F_DIR +RUN chown "${G4F_USER_ID}:${G4F_USER_ID}" $G4F_DIR + +USER $G4F_USER_ID +WORKDIR $G4F_DIR + +ENV HOME /home/$G4F_USER +ENV PATH "${HOME}/.local/bin:${PATH}" + +RUN git clone https://github.com/xtekky/gpt4free.git $G4F_DIR \ + && pip install --no-cache-dir -r requirements-slim.txt +RUN git clone https://github.com/hlohaus/deepseek4free.git \ + && cd deepseek4free && git checkout 21Feb \ + && pip install --no-cache-dir . && cd .. && rm -rf deepseek4free + +CMD python -m etc.tool.update && docker/update.sh & docker/start.sh \ No newline at end of file diff --git a/gpt4free/docker/start.sh b/gpt4free/docker/start.sh new file mode 100644 index 0000000000000000000000000000000000000000..810c75b0e4e3223b36114fbae181c37ab5d42056 --- /dev/null +++ b/gpt4free/docker/start.sh @@ -0,0 +1,2 @@ +#!/usr/bin/env bash +python -m g4f --port 8080 --debug --reload \ No newline at end of file diff --git a/gpt4free/docker/supervisor-api.conf b/gpt4free/docker/supervisor-api.conf new file mode 100644 index 0000000000000000000000000000000000000000..fb8b6c3b425aca5c5f86e8f03e4db76e93841ae2 --- /dev/null +++ b/gpt4free/docker/supervisor-api.conf @@ -0,0 +1,12 @@ +[program:g4f-api] +priority=15 +command=python -m g4f api --port 8080 --debug +directory=/app +stopasgroup=true +autostart=true +autorestart=true + +;Logs (all Hub activity redirected to stdout so it can be seen through "docker logs" +redirect_stderr=true +stdout_logfile=/dev/stdout +stdout_logfile_maxbytes=0 \ No newline at end of file diff --git a/gpt4free/docker/supervisor.conf b/gpt4free/docker/supervisor.conf new file mode 100644 index 0000000000000000000000000000000000000000..7fd4331a94e89a8897cb328c5a1e5f5a730f66d6 --- /dev/null +++ b/gpt4free/docker/supervisor.conf @@ -0,0 +1,50 @@ +[program:xvfb] +priority=0 +command=/opt/bin/start-xvfb.sh +autostart=true +autorestart=true + +;Logs +redirect_stderr=false +stdout_logfile=/var/log/supervisor/xvfb-stdout.log +stderr_logfile=/var/log/supervisor/xvfb-stderr.log +stdout_logfile_maxbytes=50MB +stderr_logfile_maxbytes=50MB +stdout_logfile_backups=5 +stderr_logfile_backups=5 +stdout_capture_maxbytes=50MB +stderr_capture_maxbytes=50MB + +[program:vnc] +priority=5 +command=/opt/bin/start-vnc.sh +autostart=true +autorestart=true + +;Logs +redirect_stderr=false +stdout_logfile=/var/log/supervisor/vnc-stdout.log +stderr_logfile=/var/log/supervisor/vnc-stderr.log +stdout_logfile_maxbytes=50MB +stderr_logfile_maxbytes=50MB +stdout_logfile_backups=5 +stderr_logfile_backups=5 +stdout_capture_maxbytes=50MB +stderr_capture_maxbytes=50MB + +[program:novnc] +priority=10 +command=/opt/bin/start-novnc.sh +autostart=true +autorestart=true + +;Logs +redirect_stderr=false +stdout_logfile=/var/log/supervisor/novnc-stdout.log +stderr_logfile=/var/log/supervisor/novnc-stderr.log +stdout_logfile_maxbytes=50MB +stderr_logfile_maxbytes=50MB +stdout_logfile_backups=5 +stderr_logfile_backups=5 +stdout_capture_maxbytes=50MB +stderr_capture_maxbytes=50MB \ No newline at end of file diff --git a/gpt4free/docker/update.sh b/gpt4free/docker/update.sh new file mode 100644 index 0000000000000000000000000000000000000000..7653f6349aaa96ba3a926f71f8e574f4259d5cee --- /dev/null +++ b/gpt4free/docker/update.sh @@ -0,0 +1,24 @@ +#!/bin/bash +trap break INT +for (( c=0; c<=1000000; c++ )) +do +echo "UPDATE: a$c" +git pull origin main +sleep 120 +echo "UPDATE: b$c" +git pull origin main +sleep 120 +echo "UPDATE: c$c" +git pull origin main +sleep 120 +echo "UPDATE: d$c" +git pull origin main +sleep 120 +echo "UPDATE: #$c" +git pull origin main +sleep 120 +done +echo "STOPPED." +trap - INT +sleep 1 +echo "END." \ No newline at end of file diff --git a/gpt4free/docs/README.md b/gpt4free/docs/README.md new file mode 100644 index 0000000000000000000000000000000000000000..b440674a5ed65c21b21f952327fc19541fa23ed9 --- /dev/null +++ b/gpt4free/docs/README.md @@ -0,0 +1 @@ +Link to [Documentation](https://github.com/gpt4free/gpt4free.github.io) \ No newline at end of file diff --git a/gpt4free/docs/aarch64-compatibility.md b/gpt4free/docs/aarch64-compatibility.md new file mode 100644 index 0000000000000000000000000000000000000000..26d33d120950f57aab802d1e0e1c8887b82d3b67 --- /dev/null +++ b/gpt4free/docs/aarch64-compatibility.md @@ -0,0 +1,72 @@ +# aarch64 (ARM64) Compatibility + +This document describes the compatibility status and known issues for g4f on aarch64 (ARM64) systems. + +## Issue Resolution + +**Fixed in this release:** The "Illegal instruction (core dumped)" error that occurred when importing g4f on aarch64 systems has been resolved. + +### Problem +Previously, g4f would crash with "Illegal instruction (core dumped)" on ARM64 systems (such as Apple Silicon Macs, Raspberry Pi, AWS Graviton instances, etc.) due to compiled dependencies with architecture-specific optimizations. + +### Solution +The library now includes proper error handling for architecture-incompatible dependencies: +- Safe import mechanisms prevent crashes when compiled libraries are unavailable +- Graceful fallbacks to alternative implementations when possible +- Clear error messages when specific features require unavailable dependencies + +## Compatibility Status + +### ✅ Working Features +- Basic client functionality (`from g4f.client import Client`) +- CLI commands (`g4f --help`, `g4f client --help`) +- Providers that use standard HTTP libraries +- Most text generation functionality + +### ⚠️ Limited Features +Some advanced features may have reduced functionality on aarch64: +- Providers requiring `curl_cffi` will fall back to `aiohttp` +- Browser automation features may not be available +- Some performance optimizations may not be active + +### 📋 Requirements +For full functionality on aarch64, ensure you have: +```bash +# Basic requirements (should work on all architectures) +pip install -r requirements-min.txt + +# Full requirements (some packages may need compilation on aarch64) +pip install -r requirements.txt +``` + +## Testing Your Installation + +You can verify your installation works correctly: + +```python +# Test basic import +from g4f.client import Client +client = Client() +print("✓ g4f imported successfully") + +# Test CLI +import subprocess +result = subprocess.run(['g4f', '--help'], capture_output=True) +print("✓ CLI works" if result.returncode == 0 else "✗ CLI issues") +``` + +## Known Issues + +1. **Performance**: Some providers may have reduced performance due to fallback implementations +2. **Browser Features**: nodriver and webview functionality may not be available +3. **Image Processing**: Some image-related features may have compatibility issues + +## Getting Help + +If you encounter issues on aarch64: +1. First try with minimal requirements: `pip install -r requirements-min.txt` +2. Check if the issue persists with basic functionality +3. Report architecture-specific issues with your system details: + - Architecture: `uname -m` + - OS: `uname -a` + - Python version: `python --version` \ No newline at end of file diff --git a/gpt4free/docs/arm64-build-plan.md b/gpt4free/docs/arm64-build-plan.md new file mode 100644 index 0000000000000000000000000000000000000000..e1914990c260914f56d67e0a731c443f6e69194e --- /dev/null +++ b/gpt4free/docs/arm64-build-plan.md @@ -0,0 +1,64 @@ +# Future ARM64 Build Enhancement Plan + +This document outlines the plan for adding comprehensive ARM64 support to the g4f build system. + +## Current Status + +- **macOS ARM64**: ✅ Supported (native runners) +- **Linux ARM64**: ⏳ Requires ARM64 runners or cross-compilation +- **Windows ARM64**: ⏳ Requires ARM64 runners or cross-compilation + +## Implementation Plan for ARM64 Support + +### Phase 1: Linux ARM64 (Future Enhancement) +```yaml +# Add to .github/workflows/build-packages.yml +build-linux-exe: + strategy: + matrix: + include: + - architecture: x64 + runner: ubuntu-latest + runner-arch: x86_64 + - architecture: arm64 + runner: buildjet-4vcpu-ubuntu-2204-arm # ARM64 runners + runner-arch: aarch64 +``` + +### Phase 2: Windows ARM64 (Future Enhancement) +```yaml +build-windows-exe: + strategy: + matrix: + include: + - architecture: x64 + runner: windows-latest + runner-arch: x86_64 + - architecture: arm64 + runner: windows-latest-arm64 # When available + runner-arch: arm64 +``` + +### Phase 3: Cross-compilation Support +For environments without native ARM64 runners: +- Use Docker with QEMU emulation +- Configure Nuitka for cross-compilation +- Test compatibility and performance + +## Benefits of ARM64 Support + +1. **Performance**: Native ARM64 binaries run faster on ARM64 hardware +2. **Compatibility**: Better support for Apple Silicon Macs and ARM64 Linux systems +3. **Future-proofing**: ARM64 adoption is increasing across all platforms + +## Testing Requirements + +- Verify ARM64 binaries work on actual ARM64 hardware +- Test performance compared to x64 binaries on ARM64 systems +- Ensure compatibility with all g4f features + +## Notes + +- This is marked as a future enhancement because it requires ARM64 runners or cross-compilation setup +- Current implementation provides a solid foundation for easy expansion +- The build matrix is designed to accommodate additional architectures \ No newline at end of file diff --git a/gpt4free/docs/build-workflow.md b/gpt4free/docs/build-workflow.md new file mode 100644 index 0000000000000000000000000000000000000000..18681f9cf3d10c1c510e0c04c6821e84333a4573 --- /dev/null +++ b/gpt4free/docs/build-workflow.md @@ -0,0 +1,108 @@ +# Build Workflow Documentation + +This document explains the comprehensive build workflow for g4f that creates packages for multiple platforms and package managers. + +## Workflow Overview + +The `.github/workflows/build-packages.yml` workflow automatically builds multiple package formats when a version tag is pushed to the repository. + +### Supported Package Formats + +1. **PyPI Package** - Python wheel and source distribution +2. **Windows Executable** - Standalone .exe file built with Nuitka +3. **Linux Executable** - Standalone binary for Linux systems built with Nuitka +4. **macOS Executable** - Standalone binary for macOS systems built with Nuitka (x64 and ARM64) +5. **Debian Packages** - .deb files for Ubuntu/Debian (amd64, arm64, armhf) +6. **WinGet Package** - Windows Package Manager manifest +7. **Docker Images** - Multi-architecture container images + +### Triggering a Build + +To trigger a build, push a version tag to the repository: + +```bash +git tag v1.2.3 +git push origin v1.2.3 +``` + +The workflow will: +1. Detect the tag and extract the version +2. Build all package formats in parallel +3. Create a GitHub release with all artifacts +4. Publish to PyPI (for releases) +5. Generate WinGet manifest for Windows Package Manager + +### Manual Build Triggering + +You can also manually trigger builds using the workflow_dispatch event: + +1. Go to the "Actions" tab in GitHub +2. Select "Build All Packages" workflow +3. Click "Run workflow" +4. Optionally specify a version number + +### Package Locations + +After a successful build, packages are available: + +- **GitHub Releases**: All executables and packages as release assets + - Python packages (wheel and source distribution) + - Standalone executables for Windows, Linux, and macOS + - Debian packages for AMD64, ARM64, and ARMv7 architectures + - WinGet manifest files +- **PyPI**: `pip install g4f` +- **Docker Hub**: `docker pull hlohaus789/g4f:latest` +- **WinGet**: `winget install g4f` (after manifest approval) + +### Build Requirements + +The workflow handles all dependencies automatically, but for local development: + +- Python 3.10+ +- Nuitka for executables (replaces PyInstaller) +- Docker for container builds +- dpkg-deb for Debian packages + +### Customizing Builds + +Key files for customization: + +- `g4f_cli.py` - Entry point for executable builds +- `scripts/build-nuitka.sh` - Nuitka build script for all platforms +- `scripts/build-deb.sh` - Debian package build script +- `winget/manifests/` - WinGet package manifest templates +- `.github/workflows/build-packages.yml` - Main workflow configuration + +### Version Handling + +The workflow supports multiple version sources: +1. Git tags (preferred for releases) +2. Environment variable `G4F_VERSION` +3. Manual input in workflow dispatch + +Version must follow [PEP 440](https://peps.python.org/pep-0440/) format for PyPI compatibility. + +### Troubleshooting + +Common issues and solutions: + +1. **Build fails**: Check Python version compatibility and dependencies +2. **Version errors**: Ensure version follows PEP 440 format +3. **Missing artifacts**: Check if all build jobs completed successfully +4. **Docker push fails**: Verify Docker Hub credentials are set in repository secrets + +### Security Notes + +The workflow uses secure practices: +- Trusted action versions +- Environment isolation +- Secret management for credentials +- No hardcoded sensitive data + +### Contributing + +To improve the build system: +1. Test changes locally first +2. Update documentation +3. Consider backward compatibility +4. Test with multiple Python versions \ No newline at end of file diff --git a/gpt4free/docs/reasoning-standardization.md b/gpt4free/docs/reasoning-standardization.md new file mode 100644 index 0000000000000000000000000000000000000000..b99b0170c5e272a8a528ae4ef2f6dd76d3956e6d --- /dev/null +++ b/gpt4free/docs/reasoning-standardization.md @@ -0,0 +1,65 @@ +# Reasoning Field Standardization + +## Issue +DeepSeek uses `"reasoning_content"` field while OpenAI uses `"reasoning"` field in their chat completion streaming responses. This inconsistency caused confusion about what field name to use in the g4f Interference API. + +## Decision +**Standardized on OpenAI's `"reasoning"` field format for API output while maintaining input compatibility.** + +## Rationale +1. **OpenAI Compatibility**: OpenAI is the de facto standard for chat completion APIs +2. **Ecosystem Compatibility**: Most tools and libraries expect OpenAI format +3. **Consistency**: Provides a unified output format regardless of the underlying provider +4. **Backward Compatibility**: Input parsing continues to accept both formats + +## Implementation + +### Input Format Support (Unchanged) +The system continues to accept both input formats in `OpenaiTemplate.py`: +```python +reasoning_content = choice.get("delta", {}).get("reasoning_content", choice.get("delta", {}).get("reasoning")) +``` + +### Output Format Standardization (Changed) +- **Streaming Delta**: Uses `reasoning` field (OpenAI format) +- **Non-streaming Message**: Uses `reasoning` field (OpenAI format) +- **API Responses**: Should use standard OpenAI streaming format + +### Example Output Formats + +#### Streaming Response (OpenAI Compatible) +```json +{ + "id": "chatcmpl-example", + "object": "chat.completion.chunk", + "choices": [{ + "index": 0, + "delta": { + "role": "assistant", + "reasoning": "I need to think about this step by step..." + }, + "finish_reason": null + }] +} +``` + +#### Non-streaming Response +```json +{ + "choices": [{ + "message": { + "role": "assistant", + "content": "Here's my answer", + "reasoning": "My reasoning process was..." + } + }] +} +``` + +## Files Changed +- `g4f/client/stubs.py`: Updated to use `reasoning` field instead of `reasoning_content` + +## Testing +- Added comprehensive tests for format standardization +- Verified input compatibility with both OpenAI and DeepSeek formats +- Confirmed no regressions in existing functionality \ No newline at end of file diff --git a/gpt4free/etc/examples/api_completions_copilot.py b/gpt4free/etc/examples/api_completions_copilot.py new file mode 100644 index 0000000000000000000000000000000000000000..6c77f8e9ec1a5956820710717c4d95ac1d3604b8 --- /dev/null +++ b/gpt4free/etc/examples/api_completions_copilot.py @@ -0,0 +1,55 @@ +import requests +import json +import uuid + +url = "http://localhost:1337/v1/chat/completions" +conversation_id = str(uuid.uuid4()) +body = { + "model": "", + "provider": "Copilot", + "stream": True, + "messages": [ + {"role": "user", "content": "Hello, i am Heiner. How are you?"} + ], + "conversation_id": conversation_id +} +response = requests.post(url, json=body, stream=True) +response.raise_for_status() +for line in response.iter_lines(): + if line.startswith(b"data: "): + try: + json_data = json.loads(line[6:]) + if json_data.get("error"): + print(json_data) + break + content = json_data.get("choices", [{"delta": {}}])[0]["delta"].get("content", "") + if content: + print(content, end="") + except json.JSONDecodeError: + pass +print() +print() +print() +body = { + "model": "", + "provider": "Copilot", + "stream": True, + "messages": [ + {"role": "user", "content": "Tell me somethings about my name"} + ], + "conversation_id": conversation_id +} +response = requests.post(url, json=body, stream=True) +response.raise_for_status() +for line in response.iter_lines(): + if line.startswith(b"data: "): + try: + json_data = json.loads(line[6:]) + if json_data.get("error"): + print(json_data) + break + content = json_data.get("choices", [{"delta": {}}])[0]["delta"].get("content", "") + if content: + print(content, end="") + except json.JSONDecodeError: + pass diff --git a/gpt4free/etc/examples/api_generations_image.py b/gpt4free/etc/examples/api_generations_image.py new file mode 100644 index 0000000000000000000000000000000000000000..368d5acc03811b19afdd50ffb5050ad2d0d0bb26 --- /dev/null +++ b/gpt4free/etc/examples/api_generations_image.py @@ -0,0 +1,11 @@ +import requests +url = "http://localhost:1337/v1/images/generations" +body = { + "model": "flux", + "prompt": "hello world user", + "response_format": None, + #"response_format": "url", + #"response_format": "b64_json", +} +data = requests.post(url, json=body, stream=True).json() +print(data) diff --git a/gpt4free/etc/examples/audio.py b/gpt4free/etc/examples/audio.py new file mode 100644 index 0000000000000000000000000000000000000000..851e939d4b17134df29587c6394609eec99f88bb --- /dev/null +++ b/gpt4free/etc/examples/audio.py @@ -0,0 +1,28 @@ +import asyncio +from g4f.client import AsyncClient +import g4f.Provider +import g4f.models + +async def main(): + client = AsyncClient(provider=g4f.Provider.PollinationsAI) + + # Generate audio with PollinationsAI + response = await client.chat.completions.create( + model="openai-audio", + messages=[{"role": "user", "content": "Say good day to the world"}], + audio={ "voice": "alloy", "format": "mp3" }, + ) + response.choices[0].message.save("alloy.mp3") + + # Transcribe a audio file + with open("audio.wav", "rb") as audio_file: + response = await client.chat.completions.create( + messages="Transcribe this audio", + provider=g4f.Provider.Microsoft_Phi_4, + media=[[audio_file, "audio.wav"]], + modalities=["text"], + ) + print(response.choices[0].message.content) + +if __name__ == "__main__": + asyncio.run(main()) diff --git a/gpt4free/etc/examples/messages.py b/gpt4free/etc/examples/messages.py new file mode 100644 index 0000000000000000000000000000000000000000..32720c7c0d654aceb46758cb501daa0f848a3c93 --- /dev/null +++ b/gpt4free/etc/examples/messages.py @@ -0,0 +1,33 @@ +from g4f.client import Client + +class ConversationHandler: + def __init__(self, model="gpt-4"): + self.client = Client() + self.model = model + self.conversation_history = [] + + def add_user_message(self, content): + self.conversation_history.append({ + "role": "user", + "content": content + }) + + def get_response(self): + response = self.client.chat.completions.create( + model=self.model, + messages=self.conversation_history + ) + assistant_message = { + "role": response.choices[0].message.role, + "content": response.choices[0].message.content + } + self.conversation_history.append(assistant_message) + return assistant_message["content"] + +# Usage example +conversation = ConversationHandler() +conversation.add_user_message("Hello!") +print("Assistant:", conversation.get_response()) + +conversation.add_user_message("How are you?") +print("Assistant:", conversation.get_response()) diff --git a/gpt4free/etc/examples/messages_stream.py b/gpt4free/etc/examples/messages_stream.py new file mode 100644 index 0000000000000000000000000000000000000000..237797985cbd89abb31d60f99414674210196f93 --- /dev/null +++ b/gpt4free/etc/examples/messages_stream.py @@ -0,0 +1,25 @@ +import asyncio +from g4f.client import AsyncClient + +async def main(): + client = AsyncClient() + + stream = client.chat.completions.create( + model="gpt-4", + messages=[{"role": "user", "content": "Say hello there!"}], + stream=True, + ) + + accumulated_text = "" + try: + async for chunk in stream: + if chunk.choices and chunk.choices[0].delta.content: + content = chunk.choices[0].delta.content + accumulated_text += content + print(content, end="", flush=True) + except Exception as e: + print(f"\nError occurred: {e}") + finally: + print("\n\nFinal accumulated text:", accumulated_text) + +asyncio.run(main()) diff --git a/gpt4free/etc/examples/openaichat.py b/gpt4free/etc/examples/openaichat.py new file mode 100644 index 0000000000000000000000000000000000000000..291daa2c3634c56b8dafc0d3e0943d09ec94a49c --- /dev/null +++ b/gpt4free/etc/examples/openaichat.py @@ -0,0 +1,23 @@ +from g4f.client import Client +from g4f.Provider import OpenaiChat, RetryProvider + +# compatible countries: https://pastebin.com/UK0gT9cn +client = Client( + proxies = { + 'http': 'http://username:password@host:port', # MUST BE WORKING OPENAI COUNTRY PROXY ex: USA + 'https': 'http://username:password@host:port' # MUST BE WORKING OPENAI COUNTRY PROXY ex: USA + }, + provider = RetryProvider([OpenaiChat], + single_provider_retry=True, max_retries=5) +) + +messages = [ + {'role': 'user', 'content': 'Hello'} +] + +response = client.chat.completions.create(model='gpt-3.5-turbo', + messages=messages, + stream=True) + +for message in response: + print(message.choices[0].delta.content or "") \ No newline at end of file diff --git a/gpt4free/etc/examples/text_completions_demo_async.py b/gpt4free/etc/examples/text_completions_demo_async.py new file mode 100644 index 0000000000000000000000000000000000000000..098185907e7158ea3b12cbfa7b1114149c372415 --- /dev/null +++ b/gpt4free/etc/examples/text_completions_demo_async.py @@ -0,0 +1,17 @@ +import asyncio +from g4f.client import AsyncClient + +async def main(): + client = AsyncClient() + + response = await client.chat.completions.create( + model="gpt-4o", + messages=[ + {"role": "system", "content": "You are a helpful assistant."}, + {"role": "user", "content": "how does a court case get to the Supreme Court?"} + ] + ) + + print(response.choices[0].message.content) + +asyncio.run(main()) diff --git a/gpt4free/etc/examples/text_completions_demo_sync.py b/gpt4free/etc/examples/text_completions_demo_sync.py new file mode 100644 index 0000000000000000000000000000000000000000..2ed41b32e47f675148e7ab0df325aacdf225947e --- /dev/null +++ b/gpt4free/etc/examples/text_completions_demo_sync.py @@ -0,0 +1,13 @@ +from g4f.client import Client + +client = Client() + +response = client.chat.completions.create( + model="gpt-4o", + messages=[ + {"role": "system", "content": "You are a helpful assistant."}, + {"role": "user", "content": "how does a court case get to the Supreme Court?"} + ], +) + +print(response.choices[0].message.content) diff --git a/gpt4free/etc/examples/text_completions_streaming.py b/gpt4free/etc/examples/text_completions_streaming.py new file mode 100644 index 0000000000000000000000000000000000000000..fff27d77c130110cb4afd8e74d69d0b1da31116c --- /dev/null +++ b/gpt4free/etc/examples/text_completions_streaming.py @@ -0,0 +1,49 @@ +import asyncio +from g4f.client import Client, AsyncClient + +question = """ +Hey! How can I recursively list all files in a directory in Python? +""" + +# Synchronous streaming function +def sync_stream(): + client = Client() + stream = client.chat.completions.create( + model="gpt-4", + messages=[ + {"role": "user", "content": question} + ], + stream=True, + ) + + for chunk in stream: + if chunk.choices[0].delta.content: + print(chunk.choices[0].delta.content or "", end="") + +# Asynchronous streaming function +async def async_stream(): + client = AsyncClient() + stream = client.chat.completions.create( + model="gpt-4", + messages=[ + {"role": "user", "content": question} + ], + stream=True, + ) + + async for chunk in stream: + if chunk.choices and chunk.choices[0].delta.content: + print(chunk.choices[0].delta.content, end="") + +# Main function to run both streams +def main(): + print("Synchronous Stream:") + sync_stream() + print("\n\nAsynchronous Stream:") + asyncio.run(async_stream()) + +if __name__ == "__main__": + try: + main() + except Exception as e: + print(f"An error occurred: {str(e)}") diff --git a/gpt4free/etc/examples/video.py b/gpt4free/etc/examples/video.py new file mode 100644 index 0000000000000000000000000000000000000000..0d5e787b5b61803ea215cdcdbb922ef2b8e7007d --- /dev/null +++ b/gpt4free/etc/examples/video.py @@ -0,0 +1,19 @@ +import g4f.Provider +from g4f.client import Client + +client = Client( + provider=g4f.Provider.HuggingFaceMedia, + api_key="hf_***" # Your API key here +) + +video_models = client.models.get_video() + +print(video_models) + +result = client.media.generate( + model=video_models[0], + prompt="G4F AI technology is the best in the world.", + response_format="url" +) + +print(result.data[0].url) \ No newline at end of file diff --git a/gpt4free/etc/examples/vision_images.py b/gpt4free/etc/examples/vision_images.py new file mode 100644 index 0000000000000000000000000000000000000000..3a64bb16d0573c404a130d6ee4086c8ca485d7bd --- /dev/null +++ b/gpt4free/etc/examples/vision_images.py @@ -0,0 +1,33 @@ +import g4f +import requests + +from g4f.client import Client + +client = Client() + +# Processing remote image +remote_image = requests.get("https://raw.githubusercontent.com/xtekky/gpt4free/refs/heads/main/docs/images/cat.jpeg", stream=True).content +response_remote = client.chat.completions.create( + model=g4f.models.default_vision, + messages=[ + {"role": "user", "content": "What are on this image?"} + ], + image=remote_image +) +print("Response for remote image:") +print(response_remote.choices[0].message.content) + +print("\n" + "-"*50 + "\n") # Separator + +# Processing local image +local_image = open("docs/images/cat.jpeg", "rb") +response_local = client.chat.completions.create( + model=g4f.models.default_vision, + messages=[ + {"role": "user", "content": "What are on this image?"} + ], + image=local_image +) +print("Response for local image:") +print(response_local.choices[0].message.content) +local_image.close() # Close file after use diff --git a/gpt4free/etc/examples/vision_images_reka.py b/gpt4free/etc/examples/vision_images_reka.py new file mode 100644 index 0000000000000000000000000000000000000000..6b3a88abcb225af4b63ad842e623eb486ab07ebe --- /dev/null +++ b/gpt4free/etc/examples/vision_images_reka.py @@ -0,0 +1,27 @@ +# Image Chat with Reca +# !! YOU NEED COOKIES / BE LOGGED IN TO chat.reka.ai +# download an image and save it as test.png in the same folder + +from g4f.client import Client +from g4f.Provider import Reka + +client = Client( + provider = Reka # Optional if you set model name to reka-core +) + +completion = client.chat.completions.create( + model = "reka-core", + messages = [ + { + "role": "user", + "content": "What can you see in the image ?" + } + ], + stream = True, + image = open("docs/images/cat.jpeg", "rb") # open("path", "rb"), do not use .read(), etc. it must be a file object +) + +for message in completion: + print(message.choices[0].delta.content or "") + + # >>> In the image there is ... diff --git a/gpt4free/etc/testing/_providers.py b/gpt4free/etc/testing/_providers.py new file mode 100644 index 0000000000000000000000000000000000000000..0d75dd02cae2d4d75d9d8f253db40643cc69b2f1 --- /dev/null +++ b/gpt4free/etc/testing/_providers.py @@ -0,0 +1,61 @@ +import sys +from pathlib import Path +from colorama import Fore, Style + +sys.path.append(str(Path(__file__).parent.parent)) + +from g4f import Provider, ProviderType, models +from g4f.Provider import __providers__ + + +def main(): + providers = get_providers() + failed_providers = [] + + for provider in providers: + if provider.needs_auth: + continue + print("Provider:", provider.__name__) + result = test(provider) + print("Result:", result) + if provider.working and not result: + failed_providers.append(provider) + print() + + if failed_providers: + print(f"{Fore.RED + Style.BRIGHT}Failed providers:{Style.RESET_ALL}") + for _provider in failed_providers: + print(f"{Fore.RED}{_provider.__name__}") + else: + print(f"{Fore.GREEN + Style.BRIGHT}All providers are working") + + +def get_providers() -> list[ProviderType]: + return [ + provider + for provider in __providers__ + if provider.__name__ not in dir(Provider.deprecated) + and provider.url is not None + ] + +def create_response(provider: ProviderType) -> str: + response = provider.create_completion( + model=models.default.name, + messages=[{"role": "user", "content": "Hello, who are you? Answer in detail much as possible."}], + stream=False, + ) + return "".join(response) + +def test(provider: ProviderType) -> bool: + try: + response = create_response(provider) + assert type(response) is str + assert len(response) > 0 + return response + except Exception: + return False + + +if __name__ == "__main__": + main() + diff --git a/gpt4free/etc/testing/log_time.py b/gpt4free/etc/testing/log_time.py new file mode 100644 index 0000000000000000000000000000000000000000..79997a619414dce34d20cbc4d6b387944e2a4b65 --- /dev/null +++ b/gpt4free/etc/testing/log_time.py @@ -0,0 +1,21 @@ +from time import time + + +async def log_time_async(method: callable, **kwargs): + start = time() + result = await method(**kwargs) + secs = f"{round(time() - start, 2)} secs" + return " ".join([result, secs]) if result else secs + + +def log_time_yield(method: callable, **kwargs): + start = time() + result = yield from method(**kwargs) + yield f" {round(time() - start, 2)} secs" + + +def log_time(method: callable, **kwargs): + start = time() + result = method(**kwargs) + secs = f"{round(time() - start, 2)} secs" + return " ".join([result, secs]) if result else secs \ No newline at end of file diff --git a/gpt4free/etc/testing/test_all.py b/gpt4free/etc/testing/test_all.py new file mode 100644 index 0000000000000000000000000000000000000000..6850627da41027161e50ec8e93f38421a349bc8e --- /dev/null +++ b/gpt4free/etc/testing/test_all.py @@ -0,0 +1,57 @@ +import asyncio +import sys +from pathlib import Path +sys.path.append(str(Path(__file__).parent.parent.parent)) + +import g4f + + +async def test(model: g4f.Model): + try: + try: + for response in g4f.ChatCompletion.create( + model=model, + messages=[{"role": "user", "content": "write a poem about a tree"}], + temperature=0.1, + stream=True + ): + print(response, end="") + + print() + except: + for response in await g4f.ChatCompletion.create_async( + model=model, + messages=[{"role": "user", "content": "write a poem about a tree"}], + temperature=0.1, + stream=True + ): + print(response, end="") + + print() + + return True + except Exception as e: + print(model.name, "not working:", e) + print(e.__traceback__.tb_next) + return False + + +async def start_test(): + models_to_test = [ + # GPT-3.5 + g4f.models.gpt_35_turbo, + + # GPT-4 + g4f.models.gpt_4, + ] + + models_working = [] + + for model in models_to_test: + if await test(model): + models_working.append(model.name) + + print("working models:", models_working) + + +asyncio.run(start_test()) diff --git a/gpt4free/etc/testing/test_api.py b/gpt4free/etc/testing/test_api.py new file mode 100644 index 0000000000000000000000000000000000000000..57e2f117c377a9d8aa604a65dc213efe91b231dd --- /dev/null +++ b/gpt4free/etc/testing/test_api.py @@ -0,0 +1,27 @@ +import openai + +# Set your Hugging Face token as the API key if you use embeddings +# If you don't use embeddings, leave it empty +openai.api_key = "YOUR_HUGGING_FACE_TOKEN" # Replace with your actual token + +# Set the API base URL if needed, e.g., for a local development environment +openai.api_base = "http://localhost:1337/v1" + +def main(): + response = openai.ChatCompletion.create( + model="gpt-3.5-turbo", + messages=[{"role": "user", "content": "write a poem about a tree"}], + stream=True, + ) + if isinstance(response, dict): + # Not streaming + print(response.choices[0].message.content) + else: + # Streaming + for token in response: + content = token["choices"][0]["delta"].get("content") + if content is not None: + print(content, end="", flush=True) + +if __name__ == "__main__": + main() \ No newline at end of file diff --git a/gpt4free/etc/testing/test_async.py b/gpt4free/etc/testing/test_async.py new file mode 100644 index 0000000000000000000000000000000000000000..12ec732eaf4b49081b9124da9173a2db84bccd9f --- /dev/null +++ b/gpt4free/etc/testing/test_async.py @@ -0,0 +1,31 @@ +import sys +from pathlib import Path +import asyncio + +sys.path.append(str(Path(__file__).parent.parent)) +sys.path.append(str(Path(__file__).parent.parent.parent)) + +import g4f +from testing._providers import get_providers +from testing.log_time import log_time_async + +async def create_async(provider): + try: + response = await log_time_async( + provider.create_async, + model=g4f.models.default.name, + messages=[{"role": "user", "content": "Hello, are you GPT 3.5?"}] + ) + print(f"{provider.__name__}:", response) + except Exception as e: + print(f"{provider.__name__}: {e.__class__.__name__}: {e}") + +async def run_async(): + responses: list = [ + create_async(provider) + for provider in get_providers() + if provider.working + ] + await asyncio.gather(*responses) + +print("Total:", asyncio.run(log_time_async(run_async))) \ No newline at end of file diff --git a/gpt4free/etc/testing/test_chat_completion.py b/gpt4free/etc/testing/test_chat_completion.py new file mode 100644 index 0000000000000000000000000000000000000000..6b053b72384300ade28bb0c95d2976ce6715a1eb --- /dev/null +++ b/gpt4free/etc/testing/test_chat_completion.py @@ -0,0 +1,26 @@ +import sys +from pathlib import Path + +sys.path.append(str(Path(__file__).parent.parent.parent)) + +import g4f, asyncio + +print("create:", end=" ", flush=True) +for response in g4f.ChatCompletion.create( + model=g4f.models.default, + #provider=g4f.Provider.Bing, + messages=[{"role": "user", "content": "write a poem about a tree"}], + stream=True +): + print(response, end="", flush=True) +print() + +async def run_async(): + response = await g4f.ChatCompletion.create_async( + model=g4f.models.default, + #provider=g4f.Provider.Bing, + messages=[{"role": "user", "content": "hello!"}], + ) + print("create_async:", response) + +asyncio.run(run_async()) diff --git a/gpt4free/etc/testing/test_gui.py b/gpt4free/etc/testing/test_gui.py new file mode 100644 index 0000000000000000000000000000000000000000..cc3ae379d110c2aad19b30a9c8283cdd75406cc6 --- /dev/null +++ b/gpt4free/etc/testing/test_gui.py @@ -0,0 +1,6 @@ +import sys +from pathlib import Path +sys.path.append(str(Path(__file__).parent.parent.parent)) + +from g4f.gui import run_gui +run_gui() diff --git a/gpt4free/etc/testing/test_interference.py b/gpt4free/etc/testing/test_interference.py new file mode 100644 index 0000000000000000000000000000000000000000..d8e85a6ce6a6797f47dec44fd6ac2307a6003b9d --- /dev/null +++ b/gpt4free/etc/testing/test_interference.py @@ -0,0 +1,27 @@ +# type: ignore +import openai + +openai.api_key = "" +openai.api_base = "http://localhost:1337" + + +def main(): + chat_completion = openai.ChatCompletion.create( + model="gpt-3.5-turbo", + messages=[{"role": "user", "content": "write a poem about a tree"}], + stream=True, + ) + + if isinstance(chat_completion, dict): + # not stream + print(chat_completion.choices[0].message.content) + else: + # stream + for token in chat_completion: + content = token["choices"][0]["delta"].get("content") + if content != None: + print(content, end="", flush=True) + + +if __name__ == "__main__": + main() \ No newline at end of file diff --git a/gpt4free/etc/testing/test_needs_auth.py b/gpt4free/etc/testing/test_needs_auth.py new file mode 100644 index 0000000000000000000000000000000000000000..26630e23b1b5e6e172680c019c47b3eb4ddb208c --- /dev/null +++ b/gpt4free/etc/testing/test_needs_auth.py @@ -0,0 +1,96 @@ +import sys +from pathlib import Path +import asyncio + +sys.path.append(str(Path(__file__).parent.parent)) + +import g4f +from testing.log_time import log_time, log_time_async, log_time_yield + + +_providers = [ + g4f.Provider.H2o, + g4f.Provider.You, + g4f.Provider.HuggingChat, + g4f.Provider.OpenAssistant, + g4f.Provider.Bing, + g4f.Provider.Bard +] + +_instruct = "Hello, are you GPT 4?." + +_example = """ +OpenaiChat: Hello! How can I assist you today? 2.0 secs +Bard: Hello! How can I help you today? 3.44 secs +Bing: Hello, this is Bing. How can I help? 😊 4.14 secs +Async Total: 4.25 secs + +OpenaiChat: Hello! How can I assist you today? 1.85 secs +Bard: Hello! How can I help you today? 3.38 secs +Bing: Hello, this is Bing. How can I help? 😊 6.14 secs +Stream Total: 11.37 secs + +OpenaiChat: Hello! How can I help you today? 3.28 secs +Bard: Hello there! How can I help you today? 3.58 secs +Bing: Hello! How can I help you today? 3.28 secs +No Stream Total: 10.14 secs +""" + +print("Bing: ", end="") +for response in log_time_yield( + g4f.ChatCompletion.create, + model=g4f.models.default, + messages=[{"role": "user", "content": _instruct}], + provider=g4f.Provider.Bing, + #cookies=g4f.get_cookies(".huggingface.co"), + stream=True, + auth=True +): + print(response, end="", flush=True) +print() +print() + + +async def run_async(): + responses = [ + log_time_async( + provider.create_async, + model=None, + messages=[{"role": "user", "content": _instruct}], + ) + for provider in _providers + ] + responses = await asyncio.gather(*responses) + for idx, provider in enumerate(_providers): + print(f"{provider.__name__}:", responses[idx]) +print("Async Total:", asyncio.run(log_time_async(run_async))) +print() + + +def run_stream(): + for provider in _providers: + print(f"{provider.__name__}: ", end="") + for response in log_time_yield( + provider.create_completion, + model=None, + messages=[{"role": "user", "content": _instruct}], + ): + print(response, end="", flush=True) + print() +print("Stream Total:", log_time(run_stream)) +print() + + +def create_no_stream(): + for provider in _providers: + print(f"{provider.__name__}:", end=" ") + for response in log_time_yield( + provider.create_completion, + model=None, + messages=[{"role": "user", "content": _instruct}], + stream=False + ): + print(response, end="") + print() +print("No Stream Total:", log_time(create_no_stream)) +print() \ No newline at end of file diff --git a/gpt4free/etc/testing/test_providers.py b/gpt4free/etc/testing/test_providers.py new file mode 100644 index 0000000000000000000000000000000000000000..8c444d3493e9ed2870af7cabace2aa0f3127f505 --- /dev/null +++ b/gpt4free/etc/testing/test_providers.py @@ -0,0 +1,32 @@ +from g4f.Provider import __all__, ProviderUtils +from g4f import ChatCompletion +import concurrent.futures + +_ = [ + 'BaseProvider', + 'AsyncProvider', + 'AsyncGeneratorProvider', + 'RetryProvider' +] + +def test_provider(provider): + try: + provider = (ProviderUtils.convert[provider]) + if provider.working and not provider.needs_auth: + print('testing', provider.__name__) + completion = ChatCompletion.create(model='gpt-3.5-turbo', + messages=[{"role": "user", "content": "hello"}], provider=provider) + return completion, provider.__name__ + except Exception as e: + #print(f'Failed to test provider: {provider} | {e}') + return None + +with concurrent.futures.ThreadPoolExecutor() as executor: + futures = [ + executor.submit(test_provider, provider) + for provider in __all__ + if provider not in _ + ] + for future in concurrent.futures.as_completed(futures): + if result := future.result(): + print(f'{result[1]} | {result[0]}') \ No newline at end of file diff --git a/gpt4free/etc/tool/commit.py b/gpt4free/etc/tool/commit.py new file mode 100644 index 0000000000000000000000000000000000000000..17bb7a150908baf35cb8cd312e2c9c4313b715a3 --- /dev/null +++ b/gpt4free/etc/tool/commit.py @@ -0,0 +1,506 @@ +#!/usr/bin/env python3 +""" +AI Commit Message Generator using gpt4free (g4f) + +This tool uses AI to generate meaningful git commit messages based on +staged changes. It analyzes the git diff and suggests appropriate commit +messages following conventional commit format. The tool can work with +any git repository and supports multiple AI models for message generation. + +Created for use with gpt4free (g4f) development workflow. + +Usage: + python -m etc.tool.commit [options] + +Examples: + # Generate commit for current repository + python -m etc.tool.commit + + # Generate commit for specific repository + python -m etc.tool.commit --repo /path/to/repo + python -m etc.tool.commit --repo ../my-project + python -m etc.tool.commit --repo ~/projects/website + + # Generate and edit commit message before committing + python -m etc.tool.commit --repo ./docs --edit + + # Generate message only without committing + python -m etc.tool.commit --repo ~/projects/app --no-commit + + # Use specific AI model + python -m etc.tool.commit --model gpt-4 --repo ./backend + + # List available models + python -m etc.tool.commit --list-models + + # Complex workflow example + python -m etc.tool.commit --repo ../frontend --model claude-3-sonnet --edit + +Features: + - AI-powered commit message generation using gpt4free + - Support for multiple AI models (GPT-4, Claude, Gemini, etc.) + - Conventional commit format compliance + - Multi-repository support with automatic validation + - Interactive editing with system default editor + - Sensitive data filtering and protection + - Automatic retry logic with fallback models + - Git repository information display + - Staged changes analysis and diff processing + - Comprehensive error handling and validation + +Options: + --model MODEL Specify the AI model to use (default: gpt-4o) + --edit Edit the generated commit message before committing + --no-commit Generate message only without committing + --list-models List available AI models and exit + --repo PATH Specify git repository path (default: current directory) + --help Show this help message and exit + +Requirements: + - gpt4free (g4f) library + - Git installed and accessible via command line + - Active git repository with staged changes + - Internet connection for AI model access + +Workflow: + 1. Validates specified git repository + 2. Fetches staged changes using git diff + 3. Filters sensitive data from diff + 4. Generates commit message using AI + 5. Optionally allows editing the message + 6. Creates git commit with generated message + +Security Features: + - Automatic filtering of sensitive patterns (passwords, tokens, etc.) + - Local processing of git data + - No permanent storage of repository content + - Safe handling of authentication credentials + +Supported Commit Types: + - feat: New features + - fix: Bug fixes + - docs: Documentation changes + - refactor: Code refactoring + - test: Test additions/modifications + - style: Code style changes + - perf: Performance improvements + - chore: Maintenance tasks + +Author: Created for gpt4free (g4f) project +License: MIT +""" +import subprocess +import sys +import os +import argparse +import tempfile +import time +from pathlib import Path +from typing import Optional, Any, List + +from g4f.client import Client +from g4f.models import ModelUtils +from g4f.cookies import read_cookie_files + +from g4f import debug +debug.logging = True + +# Constants +DEFAULT_MODEL = "gpt-4o" +FALLBACK_MODELS = [] +MAX_DIFF_SIZE = None # Set to None to disable truncation, or a number for character limit +MAX_RETRIES = 3 +RETRY_DELAY = 2 # Seconds + +def parse_arguments(): + """Parse command line arguments""" + parser = argparse.ArgumentParser( + description="AI Commit Message Generator using gpt4free (g4f)", + formatter_class=argparse.RawDescriptionHelpFormatter, + epilog=__doc__ + ) + parser.add_argument("--model", type=str, default=DEFAULT_MODEL, + help=f"AI model to use (default: {DEFAULT_MODEL})") + parser.add_argument("--edit", action="store_true", + help="Edit the generated commit message before committing") + parser.add_argument("--no-commit", action="store_true", + help="Generate message only without committing") + parser.add_argument("--list-models", action="store_true", + help="List available AI models and exit") + parser.add_argument("--repo", type=str, default=".", + help="Git repository path (default: current directory)") + parser.add_argument("--max-retries", type=int, default=MAX_RETRIES, + help="Maximum number of retries for AI generation (default: 3)") + + return parser.parse_args() + +def validate_git_repository(repo_path: str) -> Path: + """Validate that the specified path is a git repository""" + repo_path = Path(repo_path).resolve() + + if not repo_path.exists(): + print(f"Error: Repository path does not exist: {repo_path}") + sys.exit(1) + + if not repo_path.is_dir(): + print(f"Error: Repository path is not a directory: {repo_path}") + sys.exit(1) + + # Check if it's a git repository + git_dir = repo_path / ".git" + if not git_dir.exists(): + # Check if we're in a subdirectory of a git repo + current = repo_path + while current != current.parent: + if (current / ".git").exists(): + repo_path = current + break + current = current.parent + else: + print(f"Error: Not a git repository: {repo_path}") + print("Initialize a git repository with: git init") + sys.exit(1) + + return repo_path + +def get_git_diff(repo_path: Path) -> Optional[str]: + """Get the current git diff for staged changes in specified repository""" + try: + diff_process = subprocess.run( + ["git", "diff", "--staged"], + capture_output=True, + text=True, + cwd=repo_path + ) + if diff_process.returncode != 0: + print(f"Error: git diff command failed with code {diff_process.returncode}") + print(f"Error output: {diff_process.stderr}") + return None + + return diff_process.stdout + except Exception as e: + print(f"Error running git diff in {repo_path}: {e}") + return None + +def get_repository_info(repo_path: Path) -> dict: + """Get information about the git repository""" + info = { + "path": repo_path, + "name": repo_path.name, + "branch": "unknown", + "remote": "unknown" + } + + try: + # Get current branch + branch_process = subprocess.run( + ["git", "branch", "--show-current"], + capture_output=True, + text=True, + cwd=repo_path + ) + if branch_process.returncode == 0: + info["branch"] = branch_process.stdout.strip() + except: + pass + + try: + # Get remote origin URL + remote_process = subprocess.run( + ["git", "remote", "get-url", "origin"], + capture_output=True, + text=True, + cwd=repo_path + ) + if remote_process.returncode == 0: + info["remote"] = remote_process.stdout.strip() + except: + pass + + return info + +def truncate_diff(diff_text: str, max_size: int = MAX_DIFF_SIZE) -> str: + """Truncate diff if it's too large, preserving the most important parts""" + if max_size is None or len(diff_text) <= max_size: + return diff_text + + print(f"Warning: Diff is large ({len(diff_text)} chars), truncating to {max_size} chars") + + # Split by file sections and keep as many complete files as possible + sections = diff_text.split("diff --git ") + header = sections[0] + file_sections = ["diff --git " + s for s in sections[1:]] + + result = header + for section in file_sections: + if len(result) + len(section) <= max_size: + result += section + else: + break + + return result + +def filter_sensitive_data(diff_text: str) -> str: + """Filter out potentially sensitive data from the diff""" + # List of patterns that might indicate sensitive data + sensitive_patterns = [ + ("password", "***REDACTED***"), + ("secret", "***REDACTED***"), + ("token", "***REDACTED***"), + ("api_key", "***REDACTED***"), + ("apikey", "***REDACTED***"), + ("auth", "***REDACTED***"), + ("credential", "***REDACTED***"), + ] + + # Simple pattern matching - in a real implementation, you might want more sophisticated regex + filtered_text = diff_text + for pattern, replacement in sensitive_patterns: + # Only replace if it looks like an assignment or declaration + filtered_text = filtered_text.replace(f'{pattern}="', f'{pattern}="{replacement}') + filtered_text = filtered_text.replace(f"{pattern}='", f"{pattern}='{replacement}'") + filtered_text = filtered_text.replace(f"{pattern}:", f"{pattern}: {replacement}") + filtered_text = filtered_text.replace(f"{pattern} =", f"{pattern} = {replacement}") + + return filtered_text + +def show_spinner(duration: int = None): + """Display a simple spinner to indicate progress""" + import itertools + import threading + import time + + spinner = itertools.cycle(['-', '/', '|', '\\']) + stop_spinner = threading.Event() + + def spin(): + while not stop_spinner.is_set(): + sys.stdout.write(f"\rGenerating commit message... {next(spinner)} ") + sys.stdout.flush() + time.sleep(0.1) + + spinner_thread = threading.Thread(target=spin) + spinner_thread.start() + + try: + if duration: + time.sleep(duration) + stop_spinner.set() + return stop_spinner + except: + stop_spinner.set() + raise + +def generate_commit_message(diff_text: str, model: str = DEFAULT_MODEL, max_retries: int = MAX_RETRIES) -> Optional[str]: + """Generate a commit message based on the git diff""" + if not diff_text or diff_text.strip() == "": + return "No changes staged for commit" + + read_cookie_files() # Load cookies for g4f client + + # Filter sensitive data + filtered_diff = filter_sensitive_data(diff_text) + + # Truncate if necessary + truncated_diff = truncate_diff(filtered_diff) + + client = Client() + + prompt = f""" + {truncated_diff} + ``` + + Analyze ONLY the exact changes in this git diff and create a precise commit message. + + FORMAT: + 1. First line: "[\S\s]+?)\n```", text)
+ if match:
+ text = match.group("code")
+ else:
+ text = text.split("\n---\n")[0]
+ try:
+ return json.loads(text.strip())
+ except json.JSONDecodeError:
+ raise RuntimeError(f"Invalid JSON: {text}")
+
+def read_text(text: str) -> str:
+ """
+ Extracts text from a markdown code block.
+
+ Args:
+ text (str): A string containing a markdown code block.
+
+ Returns:
+ str: The extracted text.
+ """
+ match = re.search(r"```(markdown|)\n(?P[\S\s]+?)\n```", text)
+ if match:
+ return match.group("text")
+ else:
+ raise RuntimeError(f"Invalid markdown: {text}")
+
+def get_ai_response(prompt: str, as_json: bool = True) -> Union[dict, str]:
+ """
+ Gets a response from g4f API based on the prompt.
+
+ Args:
+ prompt (str): The prompt to send to g4f.
+ as_json (bool): Whether to parse the response as JSON.
+
+ Returns:
+ Union[dict, str]: The parsed response from g4f, either as a dictionary or a string.
+ """
+ response = g4f.ChatCompletion.create(
+ G4F_MODEL,
+ [{'role': 'user', 'content': prompt}],
+ G4F_PROVIDER,
+ ignore_stream_and_auth=True
+ )
+ return read_json(response) if as_json else read_text(response)
+
+def analyze_code(pull: PullRequest, diff: str)-> list[dict]:
+ """
+ Analyzes the code changes in the pull request.
+
+ Args:
+ pull (PullRequest): The pull request object.
+ diff (str): The diff of the pull request.
+
+ Returns:
+ list[dict]: A list of comments generated by the analysis.
+ """
+ comments = []
+ changed_lines = []
+ current_file_path = None
+ offset_line = 0
+
+ for line in diff.split('\n'):
+ if line.startswith('+++ b/'):
+ current_file_path = line[6:]
+ changed_lines = []
+ elif line.startswith('@@'):
+ match = re.search(r'\+([0-9]+?),', line)
+ if match:
+ offset_line = int(match.group(1))
+ elif current_file_path:
+ if (line.startswith('\\') or line.startswith('diff')) and changed_lines:
+ prompt = create_analyze_prompt(changed_lines, pull, current_file_path)
+ response = get_ai_response(prompt)
+ for review in response.get('reviews', []):
+ review['path'] = current_file_path
+ comments.append(review)
+ current_file_path = None
+ elif line.startswith('-'):
+ changed_lines.append(line)
+ else:
+ changed_lines.append(f"{offset_line}:{line}")
+ offset_line += 1
+
+ return comments
+
+def create_analyze_prompt(changed_lines: list[str], pull: PullRequest, file_path: str):
+ """
+ Creates a prompt for the g4f model.
+
+ Args:
+ changed_lines (list[str]): The lines of code that have changed.
+ pull (PullRequest): The pull request object.
+ file_path (str): The path to the file being reviewed.
+
+ Returns:
+ str: The generated prompt.
+ """
+ code = "\n".join(changed_lines)
+ example = '{"reviews": [{"line": , "body": ""}]}'
+ return f"""Your task is to review pull requests. Instructions:
+- Provide the response in following JSON format: {example}
+- Do not give positive comments or compliments.
+- Provide comments and suggestions ONLY if there is something to improve, otherwise "reviews" should be an empty array.
+- Write the comment in GitHub Markdown format.
+- Use the given description only for the overall context and only comment the code.
+- IMPORTANT: NEVER suggest adding comments to the code.
+
+Review the following code diff in the file "{file_path}" and take the pull request title and description into account when writing the response.
+
+Pull request title: {pull.title}
+Pull request description:
+---
+{pull.body}
+---
+
+Each line is prefixed by its number. Code to review:
+```
+{code}
+```
+"""
+
+def create_review_prompt(pull: PullRequest, diff: str):
+ """
+ Creates a prompt to create a review comment.
+
+ Args:
+ pull (PullRequest): The pull request object.
+ diff (str): The diff of the pull request.
+
+ Returns:
+ str: The generated prompt for review.
+ """
+ return f"""Your task is to review a pull request. Instructions:
+- Write in name of g4f copilot. Don't use placeholder.
+- Write the review in GitHub Markdown format.
+- Enclose your response in backticks ```markdown```
+- Thank the author for contributing to the project.
+
+Pull request author: {pull.user.name}
+Pull request title: {pull.title}
+Pull request description:
+---
+{pull.body}
+---
+
+Diff:
+```diff
+{diff}
+```
+"""
+
+def main():
+ try:
+ github = Github(GITHUB_TOKEN)
+ pull = get_pr_details(github)
+ if not pull:
+ print(f"No PR number found")
+ exit()
+ diff = get_diff(pull.diff_url)
+ except Exception as e:
+ print(f"Error get details: {e.__class__.__name__}: {e}")
+ exit(1)
+ try:
+ review = get_ai_response(create_review_prompt(pull, diff), False)
+ except Exception as e:
+ print(f"Error create review: {e}")
+ exit(1)
+ if pull.get_reviews().totalCount > 0 or pull.get_issue_comments().totalCount > 0:
+ pull.create_issue_comment(body=review)
+ return
+ try:
+ comments = analyze_code(pull, diff)
+ except Exception as e:
+ print(f"Error analyze: {e}")
+ exit(1)
+ print("Comments:", comments)
+ try:
+ if comments:
+ pull.create_review(body=review, comments=comments)
+ else:
+ pull.create_issue_comment(body=review)
+ except Exception as e:
+ print(f"Error posting review: {e}")
+ exit(1)
+
+if __name__ == "__main__":
+ main()
diff --git a/gpt4free/etc/tool/create_provider.py b/gpt4free/etc/tool/create_provider.py
new file mode 100644
index 0000000000000000000000000000000000000000..fa585e0c88707cfd2846606bb9f36752cf5c5d93
--- /dev/null
+++ b/gpt4free/etc/tool/create_provider.py
@@ -0,0 +1,139 @@
+
+import sys, re
+from pathlib import Path
+from os import path
+
+sys.path.append(str(Path(__file__).parent.parent.parent))
+
+# Enable logging
+import g4f
+g4f.debug.logging = True
+
+# Read auth files
+from g4f.cookies import read_cookie_files
+read_cookie_files()
+
+def read_code(text):
+ if match := re.search(r"```(python|py|)\n(?P[\S\s]+?)\n```", text):
+ return match.group("code")
+ return text
+
+def input_command():
+ print("Enter/Paste the cURL command. Ctrl-D or Ctrl-Z ( windows ) to save it.")
+ contents = []
+ while True:
+ try:
+ line = input()
+ except EOFError:
+ break
+ contents.append(line)
+ return "\n".join(contents)
+
+name = input("Name: ")
+provider_path = f"g4f/Provider/{name}.py"
+
+example = """
+from __future__ import annotations
+
+from aiohttp import ClientSession
+
+from ..typing import AsyncResult, Messages
+from .base_provider import AsyncGeneratorProvider, ProviderModelMixin
+from .helper import format_prompt
+
+
+class {name}(AsyncGeneratorProvider, ProviderModelMixin):
+ label = ""
+ url = "https://example.com"
+ api_endpoint = "https://example.com/api/completion"
+ working = True
+ needs_auth = False
+ supports_stream = True
+ supports_system_message = True
+ supports_message_history = True
+
+ default_model = ''
+ models = ['', '']
+
+ model_aliases = {
+ "alias1": "model1",
+ }
+
+ @classmethod
+ def get_model(cls, model: str) -> str:
+ if model in cls.models:
+ return model
+ elif model in cls.model_aliases:
+ return cls.model_aliases[model]
+ else:
+ return cls.default_model
+
+ @classmethod
+ async def create_async_generator(
+ cls,
+ model: str,
+ messages: Messages,
+ proxy: str = None,
+ **kwargs
+ ) -> AsyncResult:
+ model = cls.get_model(model)
+
+ headers = {{
+ "authority": "example.com",
+ "accept": "application/json",
+ "origin": cls.url,
+ "referer": f"{{cls.url}}/chat",
+ }}
+ async with ClientSession(headers=headers) as session:
+ prompt = format_prompt(messages)
+ data = {{
+ "prompt": prompt,
+ "model": model,
+ }}
+ async with session.post(f"{{cls.url}}/api/chat", json=data, proxy=proxy) as response:
+ response.raise_for_status()
+ async for chunk in response.content:
+ if chunk:
+ yield chunk.decode()
+"""
+
+if not path.isfile(provider_path):
+ command = input_command()
+
+ prompt = f"""
+Create a provider from a cURL command. The command is:
+```bash
+{command}
+```
+A example for a provider:
+```python
+{example}
+```
+The name for the provider class:
+{name}
+Replace "hello" with `format_prompt(messages)`.
+And replace "gpt-3.5-turbo" with `model`.
+"""
+
+ print("Create code...")
+ response = []
+ for chunk in g4f.ChatCompletion.create(
+ model=g4f.models.default,
+ messages=prompt,
+ stream=True,
+ ):
+ print(chunk, end="", flush=True)
+ if not isinstance(chunk, Exception):
+ response.append(str(chunk))
+ print()
+ response = "".join(response)
+
+ if code := read_code(response):
+ with open(provider_path, "w") as file:
+ file.write(code)
+ print("Saved at:", provider_path)
+ with open("g4f/Provider/__init__.py", "a") as file:
+ file.write(f"\nfrom .{name} import {name}")
+else:
+ with open(provider_path, "r") as file:
+ code = file.read()
diff --git a/gpt4free/etc/tool/improve_code.py b/gpt4free/etc/tool/improve_code.py
new file mode 100644
index 0000000000000000000000000000000000000000..8578b478577c653545abf54355cd2275ab5d2204
--- /dev/null
+++ b/gpt4free/etc/tool/improve_code.py
@@ -0,0 +1,45 @@
+
+import sys, re
+from pathlib import Path
+from os import path
+
+sys.path.append(str(Path(__file__).parent.parent.parent))
+
+import g4f
+
+def read_code(text):
+ if match := re.search(r"```(python|py|)\n(?P[\S\s]+?)\n```", text):
+ return match.group("code")
+
+path = input("Path: ")
+
+with open(path, "r") as file:
+ code = file.read()
+
+prompt = f"""
+Improve the code in this file:
+```py
+{code}
+```
+Don't remove anything.
+Add typehints if possible.
+Don't add any typehints to kwargs.
+Don't remove license comments.
+"""
+
+print("Create code...")
+response = []
+for chunk in g4f.ChatCompletion.create(
+ model=g4f.models.default,
+ messages=[{"role": "user", "content": prompt}],
+ timeout=300,
+ stream=True
+):
+ response.append(chunk)
+ print(chunk, end="", flush=True)
+print()
+response = "".join(response)
+
+if code := read_code(response):
+ with open(path, "w") as file:
+ file.write(code)
diff --git a/gpt4free/etc/tool/md2html.py b/gpt4free/etc/tool/md2html.py
new file mode 100644
index 0000000000000000000000000000000000000000..988b4282393ad34552b86d4fa6b286204f4d3dc7
--- /dev/null
+++ b/gpt4free/etc/tool/md2html.py
@@ -0,0 +1,436 @@
+#!/usr/bin/env python3
+"""
+Markdown to HTML Converter using GitHub API
+
+This tool converts Markdown files to HTML using GitHub's Markdown API,
+producing high-quality HTML with GitHub Flavored Markdown support.
+It supports single files, directories, and batch processing with
+comprehensive error handling and retry logic.
+
+Created for use with gpt4free (g4f) documentation system.
+
+Usage:
+ python -m etc.tool.і [file.md] [options]
+
+Examples:
+ # Convert single file
+ python -m etc.tool.md2html README.md
+
+ # Convert all files in directory
+ python -m etc.tool.md2html -d docs/
+
+ # Convert with custom output
+ python -m etc.tool.md2html file.md -o output.html
+
+ # Use custom template
+ python -m etc.tool.md2html -t custom.html file.md
+
+Features:
+ - GitHub Flavored Markdown conversion
+ - Automatic retry logic for API failures
+ - Rate limit handling
+ - Template-based HTML generation
+ - Recursive directory processing
+ - Custom output paths
+ - Comprehensive error handling
+
+Requirements:
+ - requests library
+ - GITHUB_TOKEN environment variable (optional, but recommended)
+ - template.html file in script directory
+
+Author: Created for gpt4free (g4f) project
+License: MIT
+"""
+
+import os
+import re
+import sys
+import requests
+import time
+import argparse
+from pathlib import Path
+from typing import Optional, List
+
+def get_github_token() -> Optional[str]:
+ """Get GitHub token with validation."""
+ token = os.getenv("GITHUB_TOKEN")
+ if not token:
+ print("Warning: GITHUB_TOKEN not found. API requests may be rate-limited.")
+ return None
+ return token
+
+def extract_title(content: str) -> str:
+ """Extract title from markdown content with fallback."""
+ if not content.strip():
+ return "Untitled"
+
+ lines = content.strip().splitlines()
+ for line in lines:
+ line = line.strip()
+ if line.startswith('#'):
+ return line.lstrip('#').strip()
+
+ return "Untitled"
+
+def process_markdown_links(content: str) -> str:
+ """Process markdown links for proper HTML conversion."""
+ content = content.replace("(README.md)", "(/docs/)")
+ content = content.replace("(../README.md)", "(/docs/)")
+ content = content.replace(".md)", ".html)")
+ return content
+
+def convert_markdown_to_html(content: str, token: Optional[str] = None) -> str:
+ """Convert markdown to HTML using GitHub API with retry logic."""
+ processed_content = process_markdown_links(content)
+
+ headers = {
+ "Accept": "application/vnd.github+json",
+ "User-Agent": "Markdown-Converter/1.0"
+ }
+
+ if token:
+ headers["Authorization"] = f"Bearer {token}"
+
+ payload = {
+ "text": processed_content,
+ "mode": "gfm",
+ "context": "gpt4free/gpt4free"
+ }
+
+ max_retries = 3
+ for attempt in range(max_retries):
+ try:
+ response = requests.post(
+ "https://api.github.com/markdown",
+ json=payload,
+ headers=headers,
+ timeout=30
+ )
+
+ if response.status_code == 200:
+ return response.text
+ elif response.status_code == 403:
+ print(f"Rate limit exceeded. Attempt {attempt + 1}/{max_retries}")
+ if attempt < max_retries - 1:
+ time.sleep(60)
+ continue
+ elif response.status_code == 401:
+ print("Authentication failed. Check your GITHUB_TOKEN.")
+ sys.exit(1)
+ else:
+ print(f"API request failed with status {response.status_code}: {response.text}")
+ if attempt < max_retries - 1:
+ time.sleep(5)
+ continue
+
+ except requests.exceptions.RequestException as e:
+ print(f"Network error on attempt {attempt + 1}: {e}")
+ if attempt < max_retries - 1:
+ time.sleep(5)
+ continue
+
+ print("Failed to convert markdown after all retries")
+ sys.exit(1)
+
+def load_template(template_path: Path) -> str:
+ """Load HTML template with error handling."""
+ if not template_path.exists():
+ print(f"Error: Template file not found at {template_path}")
+ sys.exit(1)
+
+ try:
+ with open(template_path, 'r', encoding='utf-8') as f:
+ return f.read()
+ except Exception as e:
+ print(f"Error reading template file: {e}")
+ sys.exit(1)
+
+def process_file(file_path: Path, template: str, output_dir: Optional[Path] = None, token: Optional[str] = None) -> bool:
+ """Process a single markdown file."""
+ try:
+ # Read markdown file
+ with open(file_path, 'r', encoding='utf-8') as f:
+ content = f.read()
+
+ if not content.strip():
+ print(f"Warning: Empty file {file_path}")
+ return False
+
+ # Extract title
+ title = extract_title(content)
+ print(f"Processing: {file_path.name} -> Title: {title}")
+
+ # Convert to HTML
+ html = convert_markdown_to_html(content, token)
+
+ # Generate output filename
+ if file_path.name == "README.md":
+ output_filename = "index.html"
+ else:
+ output_filename = file_path.stem + ".html"
+
+ # Determine output path
+ if output_dir:
+ output_path = output_dir / output_filename
+ output_dir.mkdir(parents=True, exist_ok=True)
+ else:
+ output_path = file_path.parent / output_filename
+
+ # Generate final HTML
+ final_html = template.replace("{{ article }}", html).replace("{{ title }}", title)
+
+ # Write output file
+ with open(output_path, 'w', encoding='utf-8') as f:
+ f.write(final_html)
+
+ print(f"✓ Created: {output_path}")
+ return True
+
+ except Exception as e:
+ print(f"✗ Error processing {file_path}: {e}")
+ return False
+
+def find_markdown_files(path: Path, recursive: bool = True) -> List[Path]:
+ """Find markdown files in given path."""
+ markdown_files = []
+
+ if path.is_file():
+ if path.suffix.lower() == '.md':
+ markdown_files.append(path)
+ else:
+ print(f"Warning: {path} is not a markdown file")
+ elif path.is_dir():
+ if recursive:
+ markdown_files.extend(path.rglob("*.md"))
+ else:
+ markdown_files.extend(path.glob("*.md"))
+ else:
+ print(f"Error: {path} does not exist")
+ sys.exit(1)
+
+ return sorted(markdown_files)
+
+def create_parser():
+ """Create command line argument parser."""
+ parser = argparse.ArgumentParser(
+ description='Convert Markdown files to HTML using GitHub API',
+ formatter_class=argparse.RawDescriptionHelpFormatter,
+ epilog='''
+Examples:
+ # Convert single file
+ python md2html.py file.md
+ python md2html.py docs/README.md
+
+ # Convert single file with custom output
+ python md2html.py file.md -o output.html
+ python md2html.py file.md --output-dir ./html/
+
+ # Convert all markdown files in current directory
+ python md2html.py
+
+ # Convert all markdown files in specific directory (recursive)
+ python md2html.py -d docs/
+ python md2html.py --directory ./documentation/
+
+ # Convert files in directory (non-recursive)
+ python md2html.py -d docs/ --no-recursive
+
+ # Use custom template
+ python md2html.py -t custom_template.html file.md
+
+ # Convert multiple specific files
+ python md2html.py file1.md file2.md docs/file3.md
+
+Environment Variables:
+ GITHUB_TOKEN GitHub personal access token for API authentication
+ (optional but recommended to avoid rate limits)
+
+Template Variables:
+ {{ title }} Replaced with extracted document title
+ {{ article }} Replaced with converted HTML content
+
+Created for gpt4free (g4f) documentation system.
+'''
+ )
+
+ parser.add_argument(
+ 'files',
+ nargs='*',
+ help='Markdown files to convert (if none specified, converts current directory)'
+ )
+
+ parser.add_argument(
+ '-d', '--directory',
+ type=Path,
+ help='Convert all .md files in directory'
+ )
+
+ parser.add_argument(
+ '-o', '--output',
+ type=Path,
+ help='Output file path (only for single file conversion)'
+ )
+
+ parser.add_argument(
+ '--output-dir',
+ type=Path,
+ help='Output directory for converted files'
+ )
+
+ parser.add_argument(
+ '-t', '--template',
+ type=Path,
+ default='template.html',
+ help='HTML template file (default: template.html)'
+ )
+
+ parser.add_argument(
+ '--no-recursive',
+ action='store_true',
+ help='Do not search subdirectories when using --directory'
+ )
+
+ parser.add_argument(
+ '-v', '--verbose',
+ action='store_true',
+ help='Show verbose output'
+ )
+
+ return parser
+
+def main():
+ """Main conversion function."""
+ parser = create_parser()
+ args = parser.parse_args()
+
+ # Get GitHub token
+ token = get_github_token()
+
+ # Determine template path
+ if args.template.is_absolute():
+ template_path = args.template
+ else:
+ template_path = Path(__file__).parent / args.template
+
+ # Load template
+ template = load_template(template_path)
+
+ # Determine what to convert
+ markdown_files = []
+
+ if args.files:
+ # Convert specific files
+ for file_str in args.files:
+ file_path = Path(file_str)
+ if file_path.exists():
+ if file_path.is_file() and file_path.suffix.lower() == '.md':
+ markdown_files.append(file_path)
+ else:
+ print(f"Warning: {file_path} is not a markdown file")
+ else:
+ print(f"Error: {file_path} does not exist")
+ sys.exit(1)
+ elif args.directory:
+ # Convert directory
+ recursive = not args.no_recursive
+ markdown_files = find_markdown_files(args.directory, recursive)
+ else:
+ # Convert current directory
+ current_dir = Path.cwd()
+ markdown_files = find_markdown_files(current_dir, recursive=True)
+
+ if not markdown_files:
+ print("No markdown files found to convert.")
+ return
+
+ # Validate arguments
+ if args.output and len(markdown_files) > 1:
+ print("Error: --output can only be used with single file conversion")
+ sys.exit(1)
+
+ if args.verbose:
+ print(f"Found {len(markdown_files)} markdown files to process:")
+ for f in markdown_files:
+ print(f" - {f}")
+ print()
+ else:
+ print(f"Found {len(markdown_files)} markdown files to process")
+
+ # Process files
+ successful = 0
+ failed = 0
+
+ for file_path in markdown_files:
+ # Determine output location
+ output_dir = None
+ if args.output and len(markdown_files) == 1:
+ # Single file with specific output
+ output_path = args.output
+ if process_single_file_with_output(file_path, template, output_path, token):
+ successful += 1
+ else:
+ failed += 1
+ else:
+ # Regular processing
+ if args.output_dir:
+ output_dir = args.output_dir
+
+ if process_file(file_path, template, output_dir, token):
+ successful += 1
+ else:
+ failed += 1
+
+ # Small delay to avoid hitting rate limits
+ time.sleep(0.5)
+
+ # Summary
+ print(f"\nConversion complete:")
+ print(f"✓ Successful: {successful}")
+ print(f"✗ Failed: {failed}")
+
+ if failed > 0:
+ sys.exit(1)
+
+def process_single_file_with_output(file_path: Path, template: str, output_path: Path, token: Optional[str] = None) -> bool:
+ """Process single file with specific output path."""
+ try:
+ # Read markdown file
+ with open(file_path, 'r', encoding='utf-8') as f:
+ content = f.read()
+
+ if not content.strip():
+ print(f"Warning: Empty file {file_path}")
+ return False
+
+ # Extract title
+ title = extract_title(content)
+ print(f"Processing: {file_path.name} -> Title: {title}")
+
+ # Convert to HTML
+ html = convert_markdown_to_html(content, token)
+
+ # Create output directory if needed
+ output_path.parent.mkdir(parents=True, exist_ok=True)
+
+ # If output file exists, read and replace title and content
+ if output_path.is_file():
+ output = output_path.read_text()
+ output = re.sub(r"([\S\s]+?) ", f"{title} ", output)
+ output = re.sub(r'itemprop="text">[\S\s]+?', f'itemprop="text">{html}', output)
+ else:
+ # If output file does not exist, create it with template
+ output = template.replace("{{ article }}", html).replace("{{ title }}", title)
+ # Write output file
+ with open(output_path, 'w', encoding='utf-8') as f:
+ f.write(output)
+
+ print(f"✓ Created: {output_path}")
+ return True
+
+ except Exception as e:
+ print(f"✗ Error processing {file_path}: {e}")
+ return False
+
+if __name__ == "__main__":
+ main()
diff --git a/gpt4free/etc/tool/openapi.py b/gpt4free/etc/tool/openapi.py
new file mode 100644
index 0000000000000000000000000000000000000000..83359e4e7ebf7a6d0b8d0cdcde20848b48bf5f88
--- /dev/null
+++ b/gpt4free/etc/tool/openapi.py
@@ -0,0 +1,11 @@
+import json
+
+from g4f.api import create_app
+
+app = create_app()
+
+with open("openapi.json", "w") as f:
+ data = json.dumps(app.openapi())
+ f.write(data)
+
+print(f"openapi.json - {round(len(data)/1024, 2)} kbytes")
\ No newline at end of file
diff --git a/gpt4free/etc/tool/readme_table.py b/gpt4free/etc/tool/readme_table.py
new file mode 100644
index 0000000000000000000000000000000000000000..0543f26c9474902592aa655b1807b04de0c84504
--- /dev/null
+++ b/gpt4free/etc/tool/readme_table.py
@@ -0,0 +1,179 @@
+import re
+from urllib.parse import urlparse
+import asyncio
+
+from g4f import models, ChatCompletion
+from g4f.providers.types import BaseRetryProvider, ProviderType
+from g4f.providers.base_provider import ProviderModelMixin
+from g4f.Provider import __providers__
+from g4f.models import _all_models
+from g4f import debug
+
+debug.logging = True
+
+async def test_async(provider: ProviderType):
+ if not provider.working:
+ return False
+ messages = [{"role": "user", "content": "Hello Assistant!"}]
+ try:
+ response = await asyncio.wait_for(ChatCompletion.create_async(
+ model=models.default,
+ messages=messages,
+ provider=provider
+ ), 30)
+ return bool(response)
+ except Exception as e:
+ if debug.logging:
+ print(f"{provider.__name__}: {e.__class__.__name__}: {e}")
+ return False
+
+def test_async_list(providers: list[ProviderType]):
+ responses: list = [
+ asyncio.run(test_async(_provider))
+ for _provider in providers
+ ]
+ return responses
+
+def print_providers():
+ providers = [provider for provider in __providers__ if provider.working]
+ responses = test_async_list(providers)
+ lines = []
+ for type in ("Free", "Auth"):
+ lines += [
+ "",
+ f"## {type}",
+ "",
+ ]
+ for idx, _provider in enumerate(providers):
+ do_continue = False
+ if type == "Auth" and _provider.needs_auth:
+ do_continue = True
+ elif type == "Free" and not _provider.needs_auth:
+ do_continue = True
+ if not do_continue:
+ continue
+
+ lines.append(
+ f"### {getattr(_provider, 'label', _provider.__name__)}",
+ )
+ provider_name = f"`g4f.Provider.{_provider.__name__}`"
+ lines.append(f"| Provider | {provider_name} |")
+ lines.append("| -------- | ---- |")
+
+ if _provider.url:
+ netloc = urlparse(_provider.url).netloc.replace("www.", "")
+ website = f"[{netloc}]({_provider.url})"
+ else:
+ website = "❌"
+
+ message_history = "✔️" if _provider.supports_message_history else "❌"
+ system = "✔️" if _provider.supports_system_message else "❌"
+ stream = "✔️" if _provider.supports_stream else "❌"
+ if _provider.working:
+ status = ''
+ if responses[idx]:
+ status = ''
+ else:
+ status = ''
+ else:
+ status = ''
+ auth = "✔️" if _provider.needs_auth else "❌"
+
+ lines.append(f"| **Website** | {website} | \n| **Status** | {status} |")
+
+ if issubclass(_provider, ProviderModelMixin):
+ try:
+ all_models = _provider.get_models()
+ models = [model for model in _all_models if model in all_models or model in _provider.model_aliases]
+ image_models = _provider.image_models
+ if image_models:
+ for alias, name in _provider.model_aliases.items():
+ if alias in _all_models and name in image_models:
+ image_models.append(alias)
+ image_models = [model for model in image_models if model in _all_models]
+ if image_models:
+ models = [model for model in models if model not in image_models]
+ if models:
+ lines.append(f"| **Models** | {', '.join(models)} ({len(all_models)})|")
+ if image_models:
+ lines.append(f"| **Image Models (Image Generation)** | {', '.join(image_models)} |")
+ if hasattr(_provider, "vision_models"):
+ lines.append(f"| **Vision (Image Upload)** | ✔️ |")
+ except:
+ pass
+
+ lines.append(f"| **Authentication** | {auth} | \n| **Streaming** | {stream} |")
+ lines.append(f"| **System message** | {system} | \n| **Message history** | {message_history} |")
+ return lines
+
+def print_models():
+ base_provider_names = {
+ "google": "Google",
+ "openai": "OpenAI",
+ "huggingface": "Huggingface",
+ "anthropic": "Anthropic",
+ "inflection": "Inflection",
+ "meta": "Meta",
+ }
+ provider_urls = {
+ "google": "https://gemini.google.com/",
+ "openai": "https://openai.com/",
+ "huggingface": "https://huggingface.co/",
+ "anthropic": "https://www.anthropic.com/",
+ "inflection": "https://inflection.ai/",
+ "meta": "https://llama.meta.com/",
+ }
+
+ lines = [
+ "| Model | Base Provider | Provider | Website |",
+ "| ----- | ------------- | -------- | ------- |",
+ ]
+ for name, model in models.ModelUtils.convert.items():
+ if name.startswith("gpt-3.5") or name.startswith("gpt-4"):
+ if name not in ("gpt-3.5-turbo", "gpt-4", "gpt-4-turbo"):
+ continue
+ name = re.split(r":|/", model.name)[-1]
+ if model.base_provider not in base_provider_names:
+ continue
+ base_provider = base_provider_names[model.base_provider]
+ if not isinstance(model.best_provider, BaseRetryProvider):
+ provider_name = f"g4f.Provider.{model.best_provider.__name__}"
+ else:
+ provider_name = f"{len(model.best_provider.providers)}+ Providers"
+ provider_url = provider_urls[model.base_provider]
+ netloc = urlparse(provider_url).netloc.replace("www.", "")
+ website = f"[{netloc}]({provider_url})"
+
+ lines.append(f"| {name} | {base_provider} | {provider_name} | {website} |")
+
+ return lines
+
+def print_image_models():
+ lines = [
+ "| Label | Provider | Image Model | Vision Model | Website |",
+ "| ----- | -------- | ----------- | ------------ | ------- |",
+ ]
+ for provider in [provider for provider in __providers__ if provider.working and getattr(provider, "image_models", None) or getattr(provider, "vision_models", None)]:
+ provider_url = provider.url if provider.url else "❌"
+ netloc = urlparse(provider_url).netloc.replace("www.", "")
+ website = f"[{netloc}]({provider_url})"
+ label = getattr(provider, "label", provider.__name__)
+ if provider.image_models:
+ image_models = ", ".join([model for model in provider.image_models if model in _all_models])
+ else:
+ image_models = "❌"
+ if hasattr(provider, "vision_models"):
+ vision_models = "✔️"
+ else:
+ vision_models = "❌"
+ lines.append(f'| {label} | `g4f.Provider.{provider.__name__}` | {image_models}| {vision_models} | {website} |')
+
+ return lines
+
+if __name__ == "__main__":
+ with open("docs/providers.md", "w") as f:
+ f.write("\n".join(print_providers()))
+ f.write(f"\n{'-' * 50} \n")
+ #f.write("\n".join(print_models()))
+ #f.write(f"\n{'-' * 50} \n")
+ f.write("\n".join(print_image_models()))
\ No newline at end of file
diff --git a/gpt4free/etc/tool/template.html b/gpt4free/etc/tool/template.html
new file mode 100644
index 0000000000000000000000000000000000000000..daac877e20887a1259e649099b1ba0500a4eb5ae
--- /dev/null
+++ b/gpt4free/etc/tool/template.html
@@ -0,0 +1,60 @@
+
+
+
+
+
+ {{ title }}
+
+
+
+
+
+
+
+
+
+
+
+
+
+ {{ article }}
+
+
\ No newline at end of file
diff --git a/gpt4free/etc/tool/translate_readme.py b/gpt4free/etc/tool/translate_readme.py
new file mode 100644
index 0000000000000000000000000000000000000000..e0a9b1f1c95ade97a7e1702531ecaa420e3d6ba8
--- /dev/null
+++ b/gpt4free/etc/tool/translate_readme.py
@@ -0,0 +1,88 @@
+
+import sys
+from pathlib import Path
+import asyncio
+
+sys.path.append(str(Path(__file__).parent.parent.parent))
+
+import g4f
+g4f.debug.logging = True
+from g4f.debug import access_token
+provider = g4f.Provider.OpenaiChat
+
+iso = "GE"
+language = "german"
+translate_prompt = f"""
+Translate this markdown document to {language}.
+Don't translate or change inline code examples.
+```md
+"""
+keep_note = "Keep this: [!Note] as [!Note].\n"
+blocklist = [
+ '## ©️ Copyright',
+ '## 🚀 Providers and Models',
+ '## 🔗 Related GPT4Free Projects'
+]
+allowlist = [
+ "### Other",
+ "### Models"
+]
+
+def read_text(text):
+ start = end = 0
+ new = text.strip().split('\n')
+ for i, line in enumerate(new):
+ if line.startswith('```'):
+ if not start:
+ start = i + 1
+ end = i
+ return '\n'.join(new[start:end]).strip()
+
+async def translate(text):
+ prompt = translate_prompt + text.strip() + '\n```'
+ if "[!Note]" in text:
+ prompt = keep_note + prompt
+ result = read_text(await provider.create_async(
+ model="",
+ messages=[{"role": "user", "content": prompt}],
+ access_token=access_token
+ ))
+ if text.endswith("```") and not result.endswith("```"):
+ result += "\n```"
+ return result
+
+async def translate_part(part, i):
+ blocklisted = False
+ for headline in blocklist:
+ if headline in part:
+ blocklisted = True
+ if blocklisted:
+ lines = part.split('\n')
+ lines[0] = await translate(lines[0])
+ part = '\n'.join(lines)
+ for trans in allowlist:
+ if trans in part:
+ part = part.replace(trans, await translate(trans))
+ else:
+ part = await translate(part)
+ print(f"[{i}] translated")
+ return part
+
+async def translate_readme(readme) -> str:
+ parts = readme.split('\n## ')
+ print(f"{len(parts)} parts...")
+ parts = await asyncio.gather(
+ *[translate_part("## " + part, i) for i, part in enumerate(parts)]
+ )
+ return "\n\n".join(parts)
+
+with open("README.md", "r") as fp:
+ readme = fp.read()
+
+print("Translate readme...")
+readme = asyncio.run(translate_readme(readme))
+
+file = f"README-{iso}.md"
+with open(file, "w") as fp:
+ fp.write(readme)
+print(f'"{file}" saved')
\ No newline at end of file
diff --git a/gpt4free/etc/tool/update.py b/gpt4free/etc/tool/update.py
new file mode 100644
index 0000000000000000000000000000000000000000..c2bc0851a8f92e0fa821d06710c23ee63ef22bb7
--- /dev/null
+++ b/gpt4free/etc/tool/update.py
@@ -0,0 +1,19 @@
+import os
+from g4f import version
+from subprocess import call, STDOUT
+
+if __name__ == "__main__":
+ if not os.getenv("G4F_LIVE"):
+ print("Live mode is not enabled. Exiting update script.")
+ exit(0)
+ command = ["git", "fetch"]
+ call(command, stderr=STDOUT)
+ command = ["git", "reset", "--hard"]
+ call(command, stderr=STDOUT)
+ command = ["git" ,"pull", "origin", "main"]
+ call(command, stderr=STDOUT)
+ current_version = version.get_git_version()
+ with open("g4f/debug.py", "a") as f:
+ f.write(f"\nversion: str = '{current_version}'\n")
+ #command = ["pip", "install", "-U", "-r" , "requirements-slim.txt"]
+ #call(command, stderr=STDOUT)
\ No newline at end of file
diff --git a/gpt4free/etc/tool/vercel.py b/gpt4free/etc/tool/vercel.py
new file mode 100644
index 0000000000000000000000000000000000000000..c5ce964c428ade2716bb5443c4d6025e71a6c379
--- /dev/null
+++ b/gpt4free/etc/tool/vercel.py
@@ -0,0 +1,103 @@
+import json
+import re
+from typing import Any
+
+import quickjs
+from curl_cffi import requests
+
+session = requests.Session(impersonate="chrome107")
+
+
+def get_model_info() -> dict[str, Any]:
+ url = "https://sdk.vercel.ai"
+ response = session.get(url)
+ html = response.text
+ paths_regex = r"static\/chunks.+?\.js"
+ separator_regex = r'"\]\)<\/script>