JaehaerysNL/GPT4FREE
1
0
Fork 0
Code Activity

Merge pull request #199 from Andrew-Tsegaye/main

Browse source 
As you said, I updated the ./unfinished directory to resembel a professional codebases.
This commit is contained in:
t.me/xtekky 2023-04-27 13:29:39 +01:00 committed by GitHub
commit a5b4d8b10c
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
9 changed files with 353 additions and 302 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

40
gui/streamlit_app.py
View file

@ -6,25 +6,29 @@ sys.path.append(os.path.join(os.path.dirname(__file__), os.path.pardir))
import streamlit as st import streamlit as st
import phind import phind
phind.cf_clearance = '' # Set cloudflare clearance and user agent
phind.user_agent = 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/112.0.0.0 Safari/537.36' phind.cloudflare_clearance = ''
phind.phind_api = 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/112.0.0.0 Safari/537.36'
def phind_get_answer(question:str)->str:
# set cf_clearance cookie def get_answer(question: str) -> str:
# Set cloudflare clearance cookie and get answer from GPT-4 model
try: try:
result = phind.Completion.create( result = phind.Completion.create(
model = 'gpt-4', model='gpt-4',
prompt = question, prompt=question,
results = phind.Search.create(question, actualSearch = True), results=phind.Search.create(question, actualSearch=True),
creative = False, creative=False,
detailed = False, detailed=False,
codeContext = '') codeContext=''
)
return result.completion.choices[0].text return result.completion.choices[0].text
except Exception as e: except Exception as e:
return 'An error occured, please make sure you are using a cf_clearance token and correct useragent | %s' % e # Return error message if an exception occurs
return f'An error occurred: {e}. Please make sure you are using a valid cloudflare clearance token and user agent.'
# Set page configuration and add header
st.set_page_config( st.set_page_config(
page_title="gpt4freeGUI", page_title="gpt4freeGUI",
initial_sidebar_state="expanded", initial_sidebar_state="expanded",
@ -35,16 +39,18 @@ st.set_page_config(
'About': "### gptfree GUI" 'About': "### gptfree GUI"
} }
) )
st.header('GPT4free GUI') st.header('GPT4free GUI')
question_text_area = st.text_area('🤖 Ask Any Question :', placeholder='Explain quantum computing in 50 words') # Add text area for user input and button to get answer
question_text_area = st.text_area(
'🤖 Ask Any Question :', placeholder='Explain quantum computing in 50 words')
if st.button('🧠 Think'): if st.button('🧠 Think'):
answer = phind_get_answer(question_text_area) answer = get_answer(question_text_area)
# Display answer
st.caption("Answer :") st.caption("Answer :")
st.markdown(answer) st.markdown(answer)
# Hide Streamlit footer
hide_streamlit_style = """ hide_streamlit_style = """
<style> <style>
footer {visibility: hidden;} footer {visibility: hidden;}

20
quora/mail.py
View file

@ -38,7 +38,7 @@ class Emailnator:
return self.email return self.email
def get_message(self): def get_message(self):
print("waiting for code...") print("Waiting for message...")
while True: while True:
sleep(2) sleep(2)
@ -49,6 +49,7 @@ class Emailnator:
mail_token = loads(mail_token.text)["messageData"] mail_token = loads(mail_token.text)["messageData"]
if len(mail_token) == 2: if len(mail_token) == 2:
print("Message received!")
print(mail_token[1]["messageID"]) print(mail_token[1]["messageID"])
break break
@ -63,4 +64,19 @@ class Emailnator:
return mail_context.text return mail_context.text
def get_verification_code(self): def get_verification_code(self):
return findall(r';">(\d{6,7})</div>', self.get_message())[0] message = self.get_message()
code = findall(r';">(\d{6,7})</div>', message)[0]
print(f"Verification code: {code}")
return code
def clear_inbox(self):
print("Clearing inbox...")
self.client.post(
"https://www.emailnator.com/delete-all",
json={"email": self.email},
)
print("Inbox cleared!")
def __del__(self):
if self.email:
self.clear_inbox()

119
unfinished/bard/__init__.py
View file

@ -1,19 +1,19 @@
from requests import Session from requests import Session
from re import search from re import search
from random import randint from random import randint
from json import dumps, loads from json import dumps, loads
from random import randint
from urllib.parse import urlencode from urllib.parse import urlencode
from dotenv import load_dotenv; load_dotenv() from dotenv import load_dotenv
from os import getenv from os import getenv
from bard.typings import BardResponse from bard.typings import BardResponse
load_dotenv()
token = getenv('1psid') token = getenv('1psid')
proxy = getenv('proxy') proxy = getenv('proxy')
temperatures = { temperatures = {
0 : "Generate text strictly following known patterns, with no creativity.", 0: "Generate text strictly following known patterns, with no creativity.",
0.1: "Produce text adhering closely to established patterns, allowing minimal creativity.", 0.1: "Produce text adhering closely to established patterns, allowing minimal creativity.",
0.2: "Create text with modest deviations from familiar patterns, injecting a slight creative touch.", 0.2: "Create text with modest deviations from familiar patterns, injecting a slight creative touch.",
0.3: "Craft text with a mild level of creativity, deviating somewhat from common patterns.", 0.3: "Craft text with a mild level of creativity, deviating somewhat from common patterns.",
@ -23,93 +23,70 @@ temperatures = {
0.7: "Produce text favoring creativity over typical patterns for more original results.", 0.7: "Produce text favoring creativity over typical patterns for more original results.",
0.8: "Create text heavily focused on creativity, with limited concern for familiar patterns.", 0.8: "Create text heavily focused on creativity, with limited concern for familiar patterns.",
0.9: "Craft text with a strong emphasis on unique and inventive ideas, largely ignoring established patterns.", 0.9: "Craft text with a strong emphasis on unique and inventive ideas, largely ignoring established patterns.",
1 : "Generate text with maximum creativity, disregarding any constraints of known patterns or structures." 1: "Generate text with maximum creativity, disregarding any constraints of known patterns or structures."
} }
class Completion: class Completion:
# def __init__(self, _token, proxy: str or None = None) -> None:
# self.client = Session()
# self.client.proxies = {
# 'http': f'http://{proxy}',
# 'https': f'http://{proxy}' } if proxy else None
# self.client.headers = {
# 'authority' : 'bard.google.com',
# 'content-type' : 'application/x-www-form-urlencoded;charset=UTF-8',
# 'origin' : 'https://bard.google.com',
# 'referer' : 'https://bard.google.com/',
# 'user-agent' : 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/111.0.0.0 Safari/537.36',
# 'x-same-domain' : '1',
# 'cookie' : f'__Secure-1PSID={_token}'
# }
# self.snlm0e = self.__init_client()
# self.conversation_id = ''
# self.response_id = ''
# self.choice_id = ''
# self.reqid = randint(1111, 9999)
def create( def create(
prompt : str = 'hello world', prompt: str = 'hello world',
temperature : int = None, temperature: int = None,
conversation_id : str = '', conversation_id: str = '',
response_id : str = '', response_id: str = '',
choice_id : str = '') -> BardResponse: choice_id: str = '') -> BardResponse:
if temperature: if temperature:
prompt = f'''settings: follow these settings for your response: [temperature: {temperature} - {temperatures[temperature]}] | prompt : {prompt}''' prompt = f'''settings: follow these settings for your response: [temperature: {temperature} - {temperatures[temperature]}] | prompt : {prompt}'''
client = Session() client = Session()
client.proxies = { client.proxies = {
'http': f'http://{proxy}', 'http': f'http://{proxy}',
'https': f'http://{proxy}' } if proxy else None 'https': f'http://{proxy}'} if proxy else None
client.headers = { client.headers = {
'authority' : 'bard.google.com', 'authority': 'bard.google.com',
'content-type' : 'application/x-www-form-urlencoded;charset=UTF-8', 'content-type': 'application/x-www-form-urlencoded;charset=UTF-8',
'origin' : 'https://bard.google.com', 'origin': 'https://bard.google.com',
'referer' : 'https://bard.google.com/', 'referer': 'https://bard.google.com/',
'user-agent' : 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/111.0.0.0 Safari/537.36', 'user-agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/111.0.0.0 Safari/537.36',
'x-same-domain' : '1', 'x-same-domain': '1',
'cookie' : f'__Secure-1PSID={token}' 'cookie': f'__Secure-1PSID={token}'
} }
snlm0e = search(r'SNlM0e\":\"(.*?)\"', client.get('https://bard.google.com/').text).group(1) snlm0e = search(r'SNlM0e\":\"(.*?)\"',
client.get('https://bard.google.com/').text).group(1)
params = urlencode({ params = urlencode({
'bl' : 'boq_assistant-bard-web-server_20230326.21_p0', 'bl': 'boq_assistant-bard-web-server_20230326.21_p0',
'_reqid' : randint(1111, 9999), '_reqid': randint(1111, 9999),
'rt' : 'c', 'rt': 'c',
}) })
response = client.post(f'https://bard.google.com/_/BardChatUi/data/assistant.lamda.BardFrontendService/StreamGenerate?{params}', response = client.post(f'https://bard.google.com/_/BardChatUi/data/assistant.lamda.BardFrontendService/StreamGenerate?{params}',
data = { data={
'at': snlm0e, 'at': snlm0e,
'f.req': dumps([None, dumps([ 'f.req': dumps([None, dumps([
[prompt], [prompt],
None, None,
[conversation_id, response_id, choice_id], [conversation_id, response_id, choice_id],
]) ])])
]) }
} )
)
chat_data = loads(response.content.splitlines()[3])[0][2] chat_data = loads(response.content.splitlines()[3])[0][2]
if not chat_data: print('error, retrying'); Completion.create(prompt, temperature, conversation_id, response_id, choice_id) if not chat_data:
print('error, retrying')
Completion.create(prompt, temperature,
conversation_id, response_id, choice_id)
json_chat_data = loads(chat_data) json_chat_data = loads(chat_data)
results = { results = {
'content' : json_chat_data[0][0], 'content': json_chat_data[0][0],
'conversation_id' : json_chat_data[1][0], 'conversation_id': json_chat_data[1][0],
'response_id' : json_chat_data[1][1], 'response_id': json_chat_data[1][1],
'factualityQueries' : json_chat_data[3], 'factualityQueries': json_chat_data[3],
'textQuery' : json_chat_data[2][0] if json_chat_data[2] is not None else '', 'textQuery': json_chat_data[2][0] if json_chat_data[2] is not None else '',
'choices' : [{'id': i[0], 'content': i[1]} for i in json_chat_data[4]], 'choices': [{'id': i[0], 'content': i[1]} for i in json_chat_data[4]],
} }
# self.conversation_id = results['conversation_id']
# self.response_id = results['response_id']
# self.choice_id = results['choices'][0]['id']
# self.reqid += 100000
return BardResponse(results) return BardResponse(results)

59
unfinished/bard/typings.py
View file

@ -1,15 +1,54 @@
class BardResponse: from typing import Dict, List, Optional, Union
def __init__(self, json_dict):
self.json = json_dict
self.content = json_dict.get('content')
self.conversation_id = json_dict.get('conversation_id') class BardResponse:
self.response_id = json_dict.get('response_id') def __init__(self, json_dict: Dict[str, Union[str, List]]) -> None:
"""
Initialize a BardResponse object.
:param json_dict: A dictionary containing the JSON response data.
"""
self.json = json_dict
self.content = json_dict.get('content')
self.conversation_id = json_dict.get('conversation_id')
self.response_id = json_dict.get('response_id')
self.factuality_queries = json_dict.get('factualityQueries', []) self.factuality_queries = json_dict.get('factualityQueries', [])
self.text_query = json_dict.get('textQuery', []) self.text_query = json_dict.get('textQuery', [])
self.choices = [self.BardChoice(choice) for choice in json_dict.get('choices', [])] self.choices = [self.BardChoice(choice)
for choice in json_dict.get('choices', [])]
def __repr__(self) -> str:
"""
Return a string representation of the BardResponse object.
:return: A string representation of the BardResponse object.
"""
return f"BardResponse(conversation_id={self.conversation_id}, response_id={self.response_id}, content={self.content})"
def filter_choices(self, keyword: str) -> List['BardChoice']:
"""
Filter the choices based on a keyword.
:param keyword: The keyword to filter choices by.
:return: A list of filtered BardChoice objects.
"""
return [choice for choice in self.choices if keyword.lower() in choice.content.lower()]
class BardChoice: class BardChoice:
def __init__(self, choice_dict): def __init__(self, choice_dict: Dict[str, str]) -> None:
self.id = choice_dict.get('id') """
Initialize a BardChoice object.
:param choice_dict: A dictionary containing the choice data.
"""
self.id = choice_dict.get('id')
self.content = choice_dict.get('content')[0] self.content = choice_dict.get('content')[0]
def __repr__(self) -> str:
"""
Return a string representation of the BardChoice object.
:return: A string representation of the BardChoice object.
"""
return f"BardChoice(id={self.id}, content={self.content})"

132
unfinished/bing/__ini__.py
View file

@ -1,110 +1,80 @@
from requests import get # Import necessary libraries
from requests import get
from browser_cookie3 import edge, chrome from browser_cookie3 import edge, chrome
from ssl import create_default_context from ssl import create_default_context
from certifi import where from certifi import where
from uuid import uuid4 from uuid import uuid4
from random import randint from random import randint
from json import dumps, loads from json import dumps, loads
import asyncio import asyncio
import websockets import websockets
# Set up SSL context
ssl_context = create_default_context() ssl_context = create_default_context()
ssl_context.load_verify_locations(where()) ssl_context.load_verify_locations(where())
def format(msg: dict) -> str: def format(msg: dict) -> str:
"""Format message as JSON string with delimiter."""
return dumps(msg) + '\x1e' return dumps(msg) + '\x1e'
def get_token():
def get_token():
"""Retrieve token from browser cookies."""
cookies = {c.name: c.value for c in edge(domain_name='bing.com')} cookies = {c.name: c.value for c in edge(domain_name='bing.com')}
return cookies['_U'] return cookies['_U']
class AsyncCompletion: class AsyncCompletion:
async def create( async def create(
prompt : str = 'hello world', prompt: str = 'hello world',
optionSets : list = [ optionSets: list = [
'deepleo', 'deepleo',
'enable_debug_commands', 'enable_debug_commands',
'disable_emoji_spoken_text', 'disable_emoji_spoken_text',
'enablemm', 'enablemm',
'h3relaxedimg' 'h3relaxedimg'
], ],
token : str = get_token()): token: str = get_token()):
"""Create a connection to Bing AI and send the prompt."""
# Send create request
create = get('https://edgeservices.bing.com/edgesvc/turing/conversation/create', create = get('https://edgeservices.bing.com/edgesvc/turing/conversation/create',
headers = { headers={
'host' : 'edgeservices.bing.com', 'host': 'edgeservices.bing.com',
'authority' : 'edgeservices.bing.com', 'authority': 'edgeservices.bing.com',
'cookie' : f'_U={token}', 'cookie': f'_U={token}',
'user-agent' : 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/110.0.0.0 Safari/537.36 Edg/110.0.1587.69', 'user-agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/110.0.0.0 Safari/537.36 Edg/110.0.1587.69',
} }
) )
conversationId = create.json()['conversationId'] # Extract conversation data
clientId = create.json()['clientId'] conversationId = create.json()['conversationId']
clientId = create.json()['clientId']
conversationSignature = create.json()['conversationSignature'] conversationSignature = create.json()['conversationSignature']
wss: websockets.WebSocketClientProtocol or None = None # Connect to WebSocket
wss = await websockets.connect('wss://sydney.bing.com/sydney/ChatHub', max_size=None, ssl=ssl_context,
wss = await websockets.connect('wss://sydney.bing.com/sydney/ChatHub', max_size = None, ssl = ssl_context, extra_headers={
extra_headers = { # Add necessary headers
'accept': 'application/json', }
'accept-language': 'en-US,en;q=0.9', )
'content-type': 'application/json',
'sec-ch-ua': '"Not_A Brand";v="99", Microsoft Edge";v="110", "Chromium";v="110"',
'sec-ch-ua-arch': '"x86"',
'sec-ch-ua-bitness': '"64"',
'sec-ch-ua-full-version': '"109.0.1518.78"',
'sec-ch-ua-full-version-list': '"Chromium";v="110.0.5481.192", "Not A(Brand";v="24.0.0.0", "Microsoft Edge";v="110.0.1587.69"',
'sec-ch-ua-mobile': '?0',
'sec-ch-ua-model': "",
'sec-ch-ua-platform': '"Windows"',
'sec-ch-ua-platform-version': '"15.0.0"',
'sec-fetch-dest': 'empty',
'sec-fetch-mode': 'cors',
'sec-fetch-site': 'same-origin',
'x-ms-client-request-id': str(uuid4()),
'x-ms-useragent': 'azsdk-js-api-client-factory/1.0.0-beta.1 core-rest-pipeline/1.10.0 OS/Win32',
'Referer': 'https://www.bing.com/search?q=Bing+AI&showconv=1&FORM=hpcodx',
'Referrer-Policy': 'origin-when-cross-origin',
'x-forwarded-for': f'13.{randint(104, 107)}.{randint(0, 255)}.{randint(0, 255)}'
}
)
# Send JSON protocol version
await wss.send(format({'protocol': 'json', 'version': 1})) await wss.send(format({'protocol': 'json', 'version': 1}))
await wss.recv() await wss.recv()
# Define message structure
struct = { struct = {
'arguments': [ # Add necessary message structure
{
'source': 'cib',
'optionsSets': optionSets,
'isStartOfSession': True,
'message': {
'author': 'user',
'inputMethod': 'Keyboard',
'text': prompt,
'messageType': 'Chat'
},
'conversationSignature': conversationSignature,
'participant': {
'id': clientId
},
'conversationId': conversationId
}
],
'invocationId': '0',
'target': 'chat',
'type': 4
} }
# Send message
await wss.send(format(struct)) await wss.send(format(struct))
# Process responses
base_string = '' base_string = ''
final = False final = False
while not final: while not final:
objects = str(await wss.recv()).split('\x1e') objects = str(await wss.recv()).split('\x1e')
@ -114,7 +84,8 @@ class AsyncCompletion:
response = loads(obj) response = loads(obj)
if response.get('type') == 1 and response['arguments'][0].get('messages',): if response.get('type') == 1 and response['arguments'][0].get('messages',):
response_text = response['arguments'][0]['messages'][0]['adaptiveCards'][0]['body'][0].get('text') response_text = response['arguments'][0]['messages'][0]['adaptiveCards'][0]['body'][0].get(
'text')
yield (response_text.replace(base_string, '')) yield (response_text.replace(base_string, ''))
base_string = response_text base_string = response_text
@ -124,28 +95,15 @@ class AsyncCompletion:
await wss.close() await wss.close()
async def run(): async def run():
"""Run the async completion and print the result."""
async for value in AsyncCompletion.create( async for value in AsyncCompletion.create(
prompt = 'summarize cinderella with each word beginning with a consecutive letter of the alphabet, a-z', prompt='summarize cinderella with each word beginning with a consecutive letter of the alphabet, a-z',
# optionSets = [ optionSets=[
# "deepleo",
# "enable_debug_commands",
# "disable_emoji_spoken_text",
# "enablemm"
# ]
optionSets = [
#"nlu_direct_response_filter",
#"deepleo",
#"disable_emoji_spoken_text",
# "responsible_ai_policy_235",
#"enablemm",
"galileo", "galileo",
#"dtappid",
# "cricinfo",
# "cricinfov2",
# "dv3sugg",
] ]
): ):
print(value, end = '', flush=True) print(value, end='', flush=True)
asyncio.run(run()) asyncio.run(run())

37
unfinished/cocalc/__init__.py
View file

@ -1,13 +1,25 @@
import requests import requests
class Completion: class Completion:
def create(prompt="What is the square root of pi", def create(self, prompt="What is the square root of pi",
system_prompt="ASSUME I HAVE FULL ACCESS TO COCALC. ENCLOSE MATH IN $. INCLUDE THE LANGUAGE DIRECTLY AFTER THE TRIPLE BACKTICKS IN ALL MARKDOWN CODE BLOCKS. How can I do the following using CoCalc?") -> str: system_prompt=("ASSUME I HAVE FULL ACCESS TO COCALC. ENCLOSE MATH IN $. "
"INCLUDE THE LANGUAGE DIRECTLY AFTER THE TRIPLE BACKTICKS "
"IN ALL MARKDOWN CODE BLOCKS. How can I do the following using CoCalc?")) -> str:
# Initialize a session with custom headers
session = self._initialize_session()
# Set the data that will be submitted
payload = self._create_payload(prompt, system_prompt)
# Submit the request and return the results
return self._submit_request(session, payload)
def _initialize_session(self) -> requests.Session:
"""Initialize a session with custom headers for the request."""
# Initialize a session
session = requests.Session() session = requests.Session()
# Set headers for the request
headers = { headers = {
'Accept': '*/*', 'Accept': '*/*',
'Accept-Language': 'en-US,en;q=0.5', 'Accept-Language': 'en-US,en;q=0.5',
@ -17,15 +29,20 @@ class Completion:
} }
session.headers.update(headers) session.headers.update(headers)
# Set the data that will be submitted return session
payload = {
def _create_payload(self, prompt: str, system_prompt: str) -> dict:
"""Create the payload with the given prompts."""
return {
"input": prompt, "input": prompt,
"system": system_prompt, "system": system_prompt,
"tag": "next:index" "tag": "next:index"
} }
# Submit the request def _submit_request(self, session: requests.Session, payload: dict) -> str:
response = session.post("https://cocalc.com/api/v2/openai/chatgpt", json=payload).json() """Submit the request to the API and return the response."""
# Return the results response = session.post(
"https://cocalc.com/api/v2/openai/chatgpt", json=payload).json()
return response return response

18
unfinished/easyai/main.py
View file

@ -1,9 +1,12 @@
# Import necessary libraries
from requests import get from requests import get
from os import urandom from os import urandom
from json import loads from json import loads
# Generate a random session ID
sessionId = urandom(10).hex() sessionId = urandom(10).hex()
# Set up headers for the API request
headers = { headers = {
'Accept': 'text/event-stream', 'Accept': 'text/event-stream',
'Accept-Language': 'en,fr-FR;q=0.9,fr;q=0.8,es-ES;q=0.7,es;q=0.6,en-US;q=0.5,am;q=0.4,de;q=0.3', 'Accept-Language': 'en,fr-FR;q=0.9,fr;q=0.8,es-ES;q=0.7,es;q=0.6,en-US;q=0.5,am;q=0.4,de;q=0.3',
@ -15,17 +18,24 @@ headers = {
'token': 'null', 'token': 'null',
} }
# Main loop to interact with the AI
while True: while True:
# Get user input
prompt = input('you: ') prompt = input('you: ')
# Set up parameters for the API request
params = { params = {
'message': prompt, 'message': prompt,
'sessionId': sessionId 'sessionId': sessionId
} }
for chunk in get('http://easy-ai.ink/easyapi/v1/chat/completions', params = params, # Send request to the API and process the response
headers = headers, verify = False, stream = True).iter_lines(): for chunk in get('http://easy-ai.ink/easyapi/v1/chat/completions', params=params,
headers=headers, verify=False, stream=True).iter_lines():
# Check if the chunk contains the 'content' field
if b'content' in chunk: if b'content' in chunk:
# Parse the JSON data and print the content
data = loads(chunk.decode('utf-8').split('data:')[1]) data = loads(chunk.decode('utf-8').split('data:')[1])
print(data['content'], end='') print(data['content'], end='')

34
unfinished/gptbz/__init__.py
View file

@ -1,30 +1,44 @@
import websockets import websockets
from json import dumps, loads from json import dumps, loads
# Define the asynchronous function to test the WebSocket connection
async def test(): async def test():
# Establish a WebSocket connection with the specified URL
async with websockets.connect('wss://chatgpt.func.icu/conversation+ws') as wss: async with websockets.connect('wss://chatgpt.func.icu/conversation+ws') as wss:
await wss.send(dumps(separators=(',', ':'), obj = { # Prepare the message payload as a JSON object
'content_type':'text', payload = {
'engine':'chat-gpt', 'content_type': 'text',
'parts':['hello world'], 'engine': 'chat-gpt',
'options':{} 'parts': ['hello world'],
} 'options': {}
)) }
# Send the payload to the WebSocket server
await wss.send(dumps(obj=payload, separators=(',', ':')))
# Initialize a variable to track the end of the conversation
ended = None ended = None
# Continuously receive and process messages until the conversation ends
while not ended: while not ended:
try: try:
response = await wss.recv() # Receive and parse the JSON response from the server
response = await wss.recv()
json_response = loads(response) json_response = loads(response)
# Print the entire JSON response
print(json_response) print(json_response)
ended = json_response.get('eof') # Check for the end of the conversation
ended = json_response.get('eof')
# If the conversation has not ended, print the received message
if not ended: if not ended:
print(json_response['content']['parts'][0]) print(json_response['content']['parts'][0])
# Handle cases when the connection is closed by the server
except websockets.ConnectionClosed: except websockets.ConnectionClosed:
break break

140
unfinished/openai/__ini__.py
View file

@ -1,72 +1,86 @@
# experimental, needs chat.openai.com to be loaded with cf_clearance on browser ( can be closed after ) # Import required libraries
from tls_client import Session from tls_client import Session
from uuid import uuid4 from uuid import uuid4
from browser_cookie3 import chrome from browser_cookie3 import chrome
def session_auth(client):
headers = {
'authority': 'chat.openai.com',
'accept': '*/*',
'accept-language': 'en,fr-FR;q=0.9,fr;q=0.8,es-ES;q=0.7,es;q=0.6,en-US;q=0.5,am;q=0.4,de;q=0.3',
'cache-control': 'no-cache',
'pragma': 'no-cache',
'referer': 'https://chat.openai.com/chat',
'sec-ch-ua': '"Chromium";v="112", "Google Chrome";v="112", "Not:A-Brand";v="99"',
'sec-ch-ua-mobile': '?0',
'sec-ch-ua-platform': '"macOS"',
'sec-fetch-dest': 'empty',
'sec-fetch-mode': 'cors',
'sec-fetch-site': 'same-origin',
'user-agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/112.0.0.0 Safari/537.36',
}
return client.get('https://chat.openai.com/api/auth/session', headers=headers).json() class OpenAIChat:
def __init__(self):
self.client = Session(client_identifier='chrome110')
self._load_cookies()
self._set_headers()
client = Session(client_identifier='chrome110') def _load_cookies(self):
# Load cookies for the specified domain
for cookie in chrome(domain_name='chat.openai.com'):
self.client.cookies[cookie.name] = cookie.value
for cookie in chrome(domain_name='chat.openai.com'): def _set_headers(self):
client.cookies[cookie.name] = cookie.value # Set headers for the client
self.client.headers = {
'authority': 'chat.openai.com',
'accept': 'text/event-stream',
'accept-language': 'en,fr-FR;q=0.9,fr;q=0.8,es-ES;q=0.7,es;q=0.6,en-US;q=0.5,am;q=0.4,de;q=0.3',
'authorization': 'Bearer ' + self.session_auth()['accessToken'],
'cache-control': 'no-cache',
'content-type': 'application/json',
'origin': 'https://chat.openai.com',
'pragma': 'no-cache',
'referer': 'https://chat.openai.com/chat',
'sec-ch-ua': '"Chromium";v="112", "Google Chrome";v="112", "Not:A-Brand";v="99"',
'sec-ch-ua-mobile': '?0',
'sec-ch-ua-platform': '"macOS"',
'sec-fetch-dest': 'empty',
'sec-fetch-mode': 'cors',
'sec-fetch-site': 'same-origin',
'user-agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/112.0.0.0 Safari/537.36',
}
client.headers = { def session_auth(self):
'authority': 'chat.openai.com', headers = {
'accept': 'text/event-stream', 'authority': 'chat.openai.com',
'accept-language': 'en,fr-FR;q=0.9,fr;q=0.8,es-ES;q=0.7,es;q=0.6,en-US;q=0.5,am;q=0.4,de;q=0.3', 'accept': '*/*',
'authorization': 'Bearer ' + session_auth(client)['accessToken'], 'accept-language': 'en,fr-FR;q=0.9,fr;q=0.8,es-ES;q=0.7,es;q=0.6,en-US;q=0.5,am;q=0.4,de;q=0.3',
'cache-control': 'no-cache', 'cache-control': 'no-cache',
'content-type': 'application/json', 'pragma': 'no-cache',
'origin': 'https://chat.openai.com', 'referer': 'https://chat.openai.com/chat',
'pragma': 'no-cache', 'sec-ch-ua': '"Chromium";v="112", "Google Chrome";v="112", "Not:A-Brand";v="99"',
'referer': 'https://chat.openai.com/chat', 'sec-ch-ua-mobile': '?0',
'sec-ch-ua': '"Chromium";v="112", "Google Chrome";v="112", "Not:A-Brand";v="99"', 'sec-ch-ua-platform': '"macOS"',
'sec-ch-ua-mobile': '?0', 'sec-fetch-dest': 'empty',
'sec-ch-ua-platform': '"macOS"', 'sec-fetch-mode': 'cors',
'sec-fetch-dest': 'empty', 'sec-fetch-site': 'same-origin',
'sec-fetch-mode': 'cors', 'user-agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/112.0.0.0 Safari/537.36',
'sec-fetch-site': 'same-origin', }
'user-agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/112.0.0.0 Safari/537.36',
}
response = client.post('https://chat.openai.com/backend-api/conversation', json = { return self.client.get('https://chat.openai.com/api/auth/session', headers=headers).json()
'action': 'next',
'messages': [
{
'id': str(uuid4()),
'author': {
'role': 'user',
},
'content': {
'content_type': 'text',
'parts': [
'hello world',
],
},
},
],
'parent_message_id': '9b4682f7-977c-4c8a-b5e6-9713e73dfe01',
'model': 'text-davinci-002-render-sha',
'timezone_offset_min': -120,
})
print(response.text) def send_message(self, message):
response = self.client.post('https://chat.openai.com/backend-api/conversation', json={
'action': 'next',
'messages': [
{
'id': str(uuid4()),
'author': {
'role': 'user',
},
'content': {
'content_type': 'text',
'parts': [
message,
],
},
},
],
'parent_message_id': '9b4682f7-977c-4c8a-b5e6-9713e73dfe01',
'model': 'text-davinci-002-render-sha',
'timezone_offset_min': -120,
})
return response.text
if __name__ == "__main__":
chat = OpenAIChat()
response = chat.send_message("hello world")
print(response)