Package: gptty
gpttyChatGPT wrapper in your TTYAboutgptty is a ChatGPT shell interface that allows you to (1) interact with ChatGPT in a manner similar to the web application, but without needing to rely on the web application's stability; (2) preserve context across chat sessions and structure your conversations however you want; (3) save local copies of your conversations for easy reference.Use CasesPerhaps you are a system admininstrator configuring a web server for your employer. You're accessing the system from a physical interface, with internet connection but no desktop environment or graphical user interface. While configuring the web server, you receive an inexplicable error that you redirect to a file, but don't want to have to jump through hoops to copy it to another system with a browser so you can look up the error. Instead, you install gptty and redirect the error to the chat client with commands likegptty query --tag error --question "$(cat app.error | tr '\n' ' ')"(which will get rid of line breaks for you) orcat app.error | xargs -d '\n' -I {} gptty query --tag error --question "{}"(which presumes that your error spans only a single line).Alternatively, you are a software developer or data scientist who wants to pipe data through ChatGPT, but wants to employ a highly abstract API to make these requests instead of familiarizing yourself intimately with the OpenAI API and its various language-specific wrappers. When you want to update your code base to use a different model, you want to be able to just modify a singleconfig fileand  expect the query response format to remain consistent across various models.Or maybe you are an enthusiast who wants to keep local copies of their conversations, or wants to exert more direct control over the categorization methods you employ for these conversations.Model SupportOpenAI makes a number of models available through their API. [1] Currently, gptty supportsCompletions(davinci, curie) andChatCompletions(gpt-3.5-turbo, gpt-4). All you need to do is specify the model name in yourconfig(default is text-davinci-003), and the application will handle the rest.InstallationYou can installgpttyon pip:pip install gpttyYou can also install from git:cd ~/Code # replace this with whatever directory you want to use
git clone https://github.com/signebedi/gptty.git
cd gptty/

# now install the requirements
python3 -m venv venv
source venv/bin/activate
pip install -e .Now, you can verify it is working by runninggptty --help. If you experience an error, tryconfiguringthe app.Configurationgpttyreads configuration settings from a file namedgptty.ini, which the app expects to be located in the same directory that you are runninggpttyfrom unless you pass a customconfig_file. The file uses the INI file format, which consists of sections, each with its own key-value pairs.KeyTypeDefault ValueDescriptionapi_keyString""Your API key for OpenAI's GPT serviceorg_idString""Your organization ID for OpenAI's GPT serviceyour_nameString"question"The name of the input promptgpt_nameString"response"The name of the generated responseoutput_fileString"output.txt"The name of the file where the output will be savedmodelString"text-davinci-003"The name of the GPT model to usetemperatureFloat0.0The temperature to use for samplingmax_tokensInteger250The maximum number of tokens to generate for the responsemax_context_lengthInteger150The maximum length of the input contextcontext_keywords_onlyBoolTrueTokenize keywords to reduce API usagepreserve_new_linesBoolFalseKeep original formatting of responseverify_internet_endpointString"google.com"Address to validate internet connectionYou can modify the settings in the configuration file to suit your needs. If a key is not present in the configuration file, the default value will be used. The [main] section is used to specify the program's settings.[main]api_key=my_api_keyThis repository provides asample configurationfileassets/gptty.ini.examplethat you can use as a starting point.UsageChatThe chat feature provides an interactive chat interface to communicate with ChatGPT. You can ask questions and receive responses in real-time.To start the chat interface, rungptty chat. You can also specify a custom configuration file path by running:gptty chat --config_path /path/to/your/gptty.iniInside the chat interface, you can type your questions or commands directly. To view the list of available commands, type:help, which will show the following options.MetacommandDescription:helpDisplay a list of available commands and their descriptions.:quitExit ChatGPT.:logsDisplay the current configuration settings.:context[a:b]Display the context history, optionally specifying a range a and b.Under developmentTo use a command, simply type it into the command prompt and press Enter. For example, use the following command to display the current configuration settings in the terminal:> :configs

api_key: SOME_KEY_HERE
org_id: org-SOME_CHARS_HERE
your_name: question
gpt_name: response
output_file: output.txt
model: text-davinci-003
temperature: 0.0
max_tokens: 250
max_context_length: 5000You can type a question into the prompt anytime, and it will generate a response for you. If you'd like to share context across queries, see thecontextsection below.QueryThe query feature allows you to submit a single or multiple questions to ChatGPT and receive the answers directly in the command line.To use the query feature, run something like:gptty query --question "What is the capital of France?" --question "What is the largest mammal?"You can also provide an optional tag to categorize your query:gptty query --question "What is the capital of France?" --tag "geography"You can specify a custom configuration file path if needed:gptty query --config_path /path/to/your/gptty.ini --question "What is the capital of France?"Remember that gptty uses a configuration file (by default gptty.ini) to store settings like API keys, model configurations, and output file paths. Make sure you have a valid configuration file before running gptty commands.VerbosityBy adding the--verbosetag at the end of your chat and query commands, the application will provide additional debug data, including token-counts for each request. This can be useful when you need to track API usage rates.Additional ContextBy adding the--additional_context [some_string_here]option to your query commands, the application will add any string you pass as further, outside context for your question.JSONBy adding the--jsontag at the end of your query commands, the application will skip writing human readable text to stdout, and instead write the questions and responses as json objects like[{"question":QUESTION_1, "response":RESPONSE_1},{"question":QUESTION_1, "response":RESPONSE_1},...].QuietBy adding the--quiettag at the end of your query commands, the application will skip writing anything to stdout, but will still write responses to theoutput_filedesignated in the application config file.ContextTagging text for context when using thechatandquerysubcommands in this app can help improve the accuracy of the generated responses. Here's how the app handles context with thechatsubcommand:Identify the context of your question or statement.Assign a tag to that context. The tag can be a word or short phrase that describes the context likebananasorshakespeare.Include the tag in your input message by prefixing it with[tag]. For example, if the context of your question is "cooking," you can tag it as[cooking].
Make sure to use the same tag consistently for all related queries.The application will save your tagged question and response in the output file specified in the code output file.When asking subsequent questions on the same topic, provide the tag in your input message in order to retrieve the relevant context for the generated response.Here is an example of what this might look like, using questions tagged as[shakespeare]. Notice how, in the second question, the name 'William Shakespeare' is not mentioned at all.When you are using thequerysubcommand, follow the same steps described above but, instead of prepending the text of your questions with your desired tag, use the--tagoption to include the tag when submitting your query. For example, if the context of your question is "cooking," you can use:gptty --question "some question" --tag cookingThe application will save your tagged question and response in the output file specified in the config file.ScriptingYou can automate the process of sending multiple questions to thegptty querycommand using a bash script. This can be particularly useful if you have a list of questions stored in a file, and you want to process them all at once. For example, let's say you have a filequestions.txtwith each question on a new line, like below.What are the key differences between machine learning, deep learning, and artificial intelligence?
How do I choose the best programming language for a specific project or task?
Can you recommend some best practices for code optimization and performance improvement?
What are the essential principles of good software design and architecture?
How do I get started with natural language processing and text analysis in Python?
What are some popular Python libraries or frameworks for building web applications?
Can you suggest some resources to learn about data visualization and its implementation in Python?
What are some important concepts in cybersecurity, and how can I apply them to my projects?
How do I ensure that my machine learning models are fair, ethical, and unbiased?
Can you recommend strategies for staying up-to-date with the latest trends and advancements in technology and programming?You can send each question from thequestions.txtfile to thegptty querycommand using the following bash one-liner:xargs-d'\n'-I{}gpttyquery--question"{}"<questions.txtUniversalCompletionThe UniversalCompletion class provides a unified interface for interacting with OpenAI's language models, (mostly) abstracting away the specifics of whether the application is using the Completion or ChatCompletion mode. The main idea is to facilitate the creation, configuration, and management of the language models. Here is some example usage.>>>fromgpttyimportUniversalCompletion>>>g=UniversalCompletion(api_key="sk-SOME_CHARS_HERE",org_id="org-SOME_CHARS_HERE")>>>g.connect()>>>g.set_model('gpt-3.5-turbo')>>>g.validate_model_type(g.model)'v1/chat/completions'>>>g.fetch_response(prompt=[{"role":"user","content":"What is an abstraction?"}])<OpenAIObjectchat.completionid=chatcmpl-7JxBPjmne2lsd9s2uqy3GasdlXQCZat0x7fc2ls949e21>JSON:{"choices":[{"finish_reason":"stop","index":0,"message":{"content":"An abstraction is a simplified representation of a complex system or concept. It involves focusing on the most important aspects of the system or concept and ignoring the details that are not relevant to the current context. Abstractions are used in many fields, including computer science, mathematics, and philosophy, to help people understand complex ideas and systems. They can be represented in various forms, such as diagrams, models, or algorithms.","role":"assistant"}}],"created":1684990000,"id":"chatcmpl-7JxBPjmne2lsd9s2uqy3GasdlXQCZ","model":"gpt-3.5-turbo-0301","object":"chat.completion","usage":{"completion_tokens":82,"prompt_tokens":13,"total_tokens":95}}