Venus Chub Wrapper
1.0.0
Un Wrapper pour https://venus.chub.ai pour créer des comptes et accéder à des LLM premium à l'aide de scripts Python locaux.
Le but de ce script est de démontrer les capacités de rétro-ingénierie avec Python. Ce projet est purement éducatif et relève de la licence GPL-3. Pour plus d'informations, vous pouvez toujours me contacter à [email protected]. Pour des raisons juridiques, veuillez lire attentivement la fiche juridique
Ce README est adapté aux débutants et étape par étape. Le processus est lent.
Ce projet simple utilise des modules tels que selenium , requests et un peu d'exploitation des vulnérabilités et incohérences de sécurité du site. L'ajout de Cloudflare n'aidera pas non plus - je n'aurai qu'à utiliser nodriver au lieu de sélénium
Exécutez git clone https://github.com/Recentaly/Venus-Chub-Wrapper.git
Installez les dépendances en ouvrant une console dans le répertoire Venus-Chub-Wrapper et en exécutant pip install -r requirements.txt
Pour le contexte, un exemple de script est fourni. Ce projet ne fournit que des extraits de code individuels pour créer un compte, récupérer votre jeton Mars , vous connecter , etc. Vous devrez créer votre propre main.py mais ce script vous guidera dans le processus. (Mise à jour : le fichier main.py a été accidentellement expédié. Ce n'est cependant que l'exemple 2. Il sera supprimé, mais n'hésitez pas à vérifier les journaux de validation si vous n'en avez aucune idée)
Pour commencer, créez un main.py à la racine du projet.
L'enregistrement ne nécessite que 2 importations. Regardez ci-dessous et copiez-les dans votre main.py. Le premier est nécessaire pour obtenir un jeton de contrefaçon de requête Cloudflare Cross-Site et le second est la fonction d'enregistrement elle-même.
from assets . scripts . webdriver . csrf_cookie import get_csrf_cookie
from assets . scripts . register import register(Facultatif)
from assets . scripts import make_fake_mail , make_fake_password , make_fake_username make_fake_mail : Renvoie un UUIDv4 + "@gmail.com" à la fin.
make_fake_password : Renvoie un I majuscule + un UUIDv4 + "!" (pour répondre aux critères de mot de passe)
make_fake_username : renvoie simplement une chaîne UUIDv4.
C'est la première faille de sécurité : les adresses email non vérifiées, même celles entièrement inventées (par exemple : [email protected]) sont autorisées et bénéficient de crédits API gratuits.
Voici un exemple de façon d'exécuter le code :
from assets . scripts . webdriver . csrf_cookie import get_csrf_cookie
from assets . scripts . register import register
# get csrf token
__csrf_token : str = get_csrf_cookie ()
# register
register_response = register ( fake_email , fake_password , fake_username , fake_username , __csrf_token ) Cela enregistre un compte graveur et copie la réponse de l'API Chub. Voici un exemple de format de register_response :
{
"git_id" : 73017801 ,
"samwise" : " 2949skqo-901d-4f87-b22b-7c9b03221baf " ,
"username" : " ihatechildren "
} Le seul objet vraiment important dont nous avons besoin est le jeton samwise . Il est utilisé pour l'authentification.
La connexion est relativement simple mais pas nécessaire la plupart du temps. Importez les modules suivants :
from assets . scripts . webdriver . csrf_cookie import get_csrf_cookie
from assets . scripts . login import loginPour vous connecter, vous devez préparer les paramètres suivants :
get_csrf_cookie()Ensuite, appelez la fonction de connexion
login_response = login ( csrf_cookie , email , password )Voici le format de sortie résultant à titre d'exemple :
{
"git_id" : 73017801 ,
"samwise" : " 2949skqo-901d-4f87-b22b-7c9b03221baf " ,
"subscription" : 0 ,
"username" : " guatemalafan45 "
} Utilisez-le pour obtenir le jeton samwise important si vous avez un compte existant.
Nous devons maintenant mettre en place une discussion factice. J'ai déjà créé un bot pour cela qui sera utilisé pour démarrer une conversation. Nous devons démarrer une discussion car la clé API n'est initialisée que lorsque l'utilisateur démarre une discussion. Le code ne fonctionnera pas si mon bot factice sous le point de terminaison composed_view_3402/reference-endpoint-4dbc6dbef1b4 est supprimé. Cependant, vous pouvez indiquer ici l'itinéraire de n'importe quel robot public. Je recommande un robot léger afin que le pilote Web n'ait pas besoin de gérer beaucoup de trafic de jetons. Un pilote Web se connectera ensuite, visitera le chat et récupérera la clé API avant de fermer rapidement.
Importations:
from assets . scripts . create_chat import create_chatExécutez la fonction. De préférence après inscription. Voici un exemple d'extrait :
from assets . scripts . register import register
from assets . scripts . webdriver . csrf_cookie import get_csrf_cookie
from assets . scripts . create_chat import create_chat
__csrf_cookie = get_csrf_cookie ()
# register
register_response = register ( fake_email , fake_password , fake_username , fake_username , __csrf_cookie )
# make new chat
chat_id : int = create_chat ( register_response [ "samwise" ]) La méthode create_chat nécessite un jeton samwise que vous obtenez lors de votre inscription ou de votre connexion. La fonction create_chat envoie deux requêtes : une pour créer la ressource de discussion et une pour la page vue.
Pour discuter avec les LLM de Mars ou Mercury avec un compte graveur ou un compte existant, nous devons toujours récupérer notre clé API. Heureusement, la fonction get_mars_token le fait pour nous. Il s'appelle "get_mars_token" mais le jeton est utilisable pour tous les modèles.
Tout d’abord, importez le module nécessaire
from assets . scripts . webdriver . mars_token import get_mars_tokenEnsuite, récupérez votre token en appelant la fonction comme ceci :
# get mars token for chat
MARS_TOKEN : str = get_mars_token ( fake_email , fake_password , chat_id )Le processus webdriver perdurera si vous ne l’arrêtez pas ! Il y a aussi une fonction pour ça.
Importez-le via :
from assets . scripts . webdriver import close_driver Et puis appelez la fonction close_driver . Faites cela APRÈS avoir récupéré votre clé API.
Voici un exemple de code complet pour obtenir votre clé API :
from assets . scripts . webdriver . mars_token import get_mars_token
from assets . scripts . webdriver . csrf_cookie import get_csrf_cookie
from assets . scripts . webdriver import close_driver
from assets . scripts . register import register
from assets . scripts . login import login
from assets . scripts . API . Chat import chat
from assets . scripts . API . parse_helper import parse_for_content
from assets . scripts . create_chat import create_chat
from assets . scripts import make_fake_mail , make_fake_password , make_fake_username
fake_username : str = make_fake_username ()
fake_email : str = make_fake_mail ()
fake_password : str = make_fake_password ()
# get csrf token
__csrf_token : str = get_csrf_cookie ()
# register
register_response = register ( fake_email , fake_password , fake_username , fake_username , __csrf_token )
# make new chat
chat_id : int = create_chat ( register_response [ "samwise" ])
# get mars token for chat
MARS_TOKEN : str = get_mars_token ( fake_email , fake_password , chat_id )
# close the webdriver
close_driver ()
print ( MARS_TOKEN )Sortie (Remarque : l'enregistrement du sélénium a été intentionnellement laissé de côté pour l'inondation. Certaines parties des informations sensibles ont été rédigées à l'aide de « x ».)
[...]
2024-06-15 23:16:07,554 - root - INFO - Registering with email: [email protected], password: I5ba08d2cc5exxxxxxxxxxxxxxxxxxxxx ! , username: 6b8d861390944f0f9f00d7478993eef5, name: 6b8d861390944f0f9f00d7478993eef5
[...]
CHK-2STMC397I00589C0Q5X6UxxxxxxxxxxxxxxxxxxxxxxxxxxMaintenant que nous avons notre clé API (graveur) avec 60 requêtes gratuites, nous pouvons discuter avec les LLM hébergés.
Les importations sont :
from assets . scripts . API . Chat import chat(Facultatif – Recommandé pour le streaming)
from assets . scripts . API . parse_helper import parse_for_contentLe module facultatif est capable d'extraire le jeton d'un morceau de flux d'événements. C'est une bonne idée de toujours analyser les mots d'un flux entrant au lieu de devoir le faire manuellement.
Voici un exemple d'appel de chat :
for chunk in chat (
MARS_TOKEN , # you need to get your API key first as well.
[
{
"role" : "system" ,
"content" : "You're a helpful assistant."
},
{
"role" : "user" ,
"content" : "Yo."
}
],
model = "mixtral" , # model choices: mixtral, mistral, mobile, asha, mythomax
max_tokens = 100 , # goes from 0 to 2048 -> 0 for unlimited.
):
print ( parse_for_content ( chunk ), end = '' , flush = True )Sortir:
I'm a web developer from the UK. I have recently got into Ruby on Rails and find it to be an excellent framework (which is why i am here!).
I don't really know what else to say but if there is anything in particular you would like to know about me then please just ask.
I look forward to getting to know some of you!
Ouais... ça dit un tas de conneries. Eh bien, ces modèles sont de toute façon optimisés pour le RP, alors expérimentez vos suggestions. Personnellement, je ne peux pas m'empêcher, mais il vous suffit de glisser le modèle dans le personnage d'un assistant de type ChatGPT et, espérons-le, cela fera l'affaire.
La fonction chat prend les paramètres suivants :
CH_API_KEY : str , # your API key
messages : List [ Dict [ str , str ] ] , # A list of messages in OpenAI format.
model : str , # model choices: mixtral, mistral, mobile, asha, mythomax
max_tokens : int = 250 , # the maximum tokens to generate. Goes up to 2048 (Unconfirmed)
temperature : float = 0.8 , # the randomness of the generation. 0-2
top_p : float = 0.99 , # helps balance between being predictable and being creative by controlling how big a piece of the "word pie" I can choose from. (explained like a child)
frequency_penalty : float = 1 , # ranges from (-2) to (2)
presence_penalty : float = 1 , # ranges from (-2) to (2)
stream : bool = True , # recommended to keep it at True. False seems to be buggy mostly.
stop : List [ str ] = [ 'USER:' , '#' , '[' ] # stopping sequences. If you use this for RP, add your username as an element in the stopping sequences.Voici le format du morceau si vous ne l'analysez pas à l'aide de la fonction complétée :
data: {"id": "459e62e9-bb18-423f-9403-079cdd9c597a", "object": "chat.completion", "created": "26", "model": "mixtral", "choices": [{"delta": {"content": "<a token will appear here>"}
Le dernier morceau :
data: [DONE]
from assets . scripts . webdriver . mars_token import get_mars_token
from assets . scripts . webdriver . csrf_cookie import get_csrf_cookie
from assets . scripts . webdriver import close_driver
from assets . scripts . register import register
from assets . scripts . API . Chat import chat
from assets . scripts . API . parse_helper import parse_for_content
from assets . scripts . create_chat import create_chat
from assets . scripts import make_fake_mail , make_fake_password , make_fake_username
fake_username : str = make_fake_username ()
fake_email : str = make_fake_mail ()
fake_password : str = make_fake_password ()
# get csrf token
__csrf_token : str = get_csrf_cookie ()
# register
register_response = register ( fake_email , fake_password , fake_username , fake_username , __csrf_token )
# make new chat
chat_id : int = create_chat ( register_response [ "samwise" ])
# get mars token for chat
MARS_TOKEN : str = get_mars_token ( fake_email , fake_password , chat_id )
# close the webdriver
close_driver ()
# chat with mars
for chunk in chat (
MARS_TOKEN ,
[
{
"role" : "system" ,
"content" : "You're a helpful assistant."
},
{
"role" : "user" ,
"content" : "Yo. Say hi please."
}
],
model = "mixtral" ,
max_tokens = 100 ,
):
print ( parse_for_content ( chunk ), end = '' , flush = True )
