multiai 0.2__py3-none-any.whl

multiai/__init__.py

@@ -0,0 +1,3 @@
+"""init.py."""
+from .multiai import Prompt, Provider
+from .printlong import print_long

multiai/data/system.ini

@@ -0,0 +1,28 @@
+[system]
+version = 0.2
+description = A Python library for text-based AI interactions
+url = https://sekika.github.io/multiai/
+
+[model]
+ai_provider = openai
+openai = gpt-4o-mini
+anthropic = claude-3-haiku-20240307
+google = gemini-1.5-flash
+perplexity = llama-3.1-sonar-small-128k-chat
+mistral = mistral-large-latest
+
+[default]
+temperature = 0.7
+max_requests = 5
+
+[command]
+blank_lines = 0
+always_copy = no
+always_log = no
+log_file = chat-ai-DATE.md
+
+[prompt]
+color = blue
+english = If the following sentence is English, revise the text to improve its readability and clarity in English. If not, translate into English. No need to explain. Just output the result English text.
+factual = Do not hallucinate. Do not make up factual information.
+url = Summarize following text very briefly.

multiai/entry.py

@@ -0,0 +1,145 @@
+"""
+Entry point of multiai
+"""
+import argparse
+import configparser
+import os
+import readline
+import subprocess
+import sys
+import webbrowser
+from datetime import datetime
+from multiai import Prompt, Provider
+
+__all__ = [
+    "entry",
+]
+
+
+def entry():
+    """
+    Entry point of multiai
+
+    to be invoked with ai command
+    """
+    client = Prompt()
+    # Load user setting from config file in the order of
+    # data/system.ini, ~/.multiai, .multiai
+    inifile = configparser.ConfigParser()
+    here = os.path.abspath(os.path.dirname(__file__))
+    inifile.read(os.path.join(here, 'data/system.ini'))
+    inifile.read(os.path.expanduser('~/.multiai'))
+    inifile.read('.multiai')
+    # Start reading [command] section of the config file
+    # blank_lines: blank lines required to finish input
+    client.blank_lines = inifile.getint('command', 'blank_lines')
+    # always_copy: always use -c option
+    always_copy = inifile.getboolean('command', 'always_copy')
+    # always_log: always use -l option
+    always_log = inifile.getboolean('command', 'always_copy')
+    # log_file: file name of the log file.
+    log_file = inifile.get('command', 'log_file')
+    log_file = os.path.expanduser(log_file)
+    log_file = log_file.replace('DATE', datetime.today().strftime('%Y%m%d'))
+    client.log_file = log_file
+    # user_agent: user agent when retrieving web data
+    client.user_agent = inifile.get('command', 'user_agent', fallback=None)
+    # [promot] section
+    prompt_english = inifile.get('prompt', 'english')
+    prompt_factual = inifile.get('prompt', 'factual')
+    prompt_url = inifile.get('prompt', 'url')
+    # Load commandline argument
+    parser = argparse.ArgumentParser(
+        description=f'multiai {client.version} - {client.description}')
+    parser.add_argument('prompt', nargs='*',
+                        help='prompt for AI')
+    parser.add_argument('-d', '--document',
+                        action='store_true', help='open document page and exit')
+    for provider in Provider:
+        name = provider.name.lower()
+        help = 'use ' + name
+        if client.ai_provider == provider:
+            help += ' (Default)'
+        parser.add_argument(
+            '-' + name.replace('m', '')[0],
+            '--' + name,
+            action='store_true',
+            help=help)
+    parser.add_argument('-m', '--model',
+                        help='set model')
+    parser.add_argument('-t', '--temperature',
+                        help=f'set temperature. 0 is deterministic. Default is {client.temperature}.')
+    parser.add_argument('-e', '--english',
+                        action='store_true', help='correct if English, translate into English otherwise')
+    parser.add_argument('-f', '--factual',
+                        action='store_true', help='factual information')
+    parser.add_argument('-u', '--url',
+                        help='retrieve text from the URL')
+    if not always_copy:
+        parser.add_argument('-c', '--copy',
+                            action='store_true', help='copy the latest answer')
+    if not always_log:
+        parser.add_argument('-l', '--log',
+                            action='store_true', help='save log file as chatgpt.md')
+    args = parser.parse_args()
+    # Get prompt
+    prompt = ' '.join(args.prompt)
+    # -d option
+    if args.document:
+        webbrowser.open(client.url)
+        sys.exit()
+    # Set ai_provider, ai_providers and model
+    client.ai_providers = []
+    for provider in Provider:
+        if getattr(args, provider.name.lower()):
+            client.ai_provider = provider
+            client.ai_providers.append(provider)
+    if len(client.ai_providers) == 0:
+        client.ai_providers = [client.ai_provider]
+    if len(client.ai_providers) == 1:
+        default_model = 'model_' + client.ai_provider.name.lower()
+        if args.model:
+            setattr(client, default_model, args.model)
+        client.model = getattr(client, default_model, None)
+    # -t option
+    if args.temperature:
+        try:
+            client.temperature = float(args.temperature)
+        except ValueError:
+            print("Invalid 'temperature': should be a number.")
+            sys.exit(1)
+        if client.temperature < 0:
+            print("Invalid 'temperature': should be >=0.")
+            sys.exit(1)
+    # -c option
+    if always_copy:
+        args.copy = True
+    client.copy = args.copy
+    # -l option
+    if always_log:
+        args.log = True
+    client.log = args.log
+    if args.log:
+        if not os.path.exists(log_file):
+            with open(log_file, 'w') as file:
+                file.write("# AI chat log\n\n")
+    # -e and -f option
+    pre_prompt = ''
+    if args.english:
+        pre_prompt = prompt_english + '\n\n'
+    if args.factual:
+        pre_prompt = prompt_factual + '\n'
+    # -u option
+    if args.url:
+        text = client.retrieve_from_url(args.url)
+        if prompt == '':
+            prompt = prompt_url
+        print(f'{client.color(client.role)}> {prompt}\n\nText of {args.url}')
+        prompt_summary = f'{prompt_url}\n\nText of {args.url}'
+        prompt += '\n' + text
+        client.ask_print(prompt, prompt_summary=prompt_summary)
+    # Finished loading arguments and run
+    if prompt == '' or args.url:
+        client.interactive(pre_prompt=pre_prompt)
+    else:
+        client.ask_print(pre_prompt + prompt)

multiai/multiai.py

@@ -0,0 +1,540 @@
+"""
+multiai - A Python library for text-based AI interactions
+"""
+import anthropic
+import configparser
+import enum
+import google.generativeai as genai
+import json
+import openai
+import os
+import mistralai
+import PyPDF2
+import pyperclip
+import requests
+import sys
+import trafilatura
+from io import BytesIO
+from multiai.printlong import print_long
+
+__all__ = [
+    "Prompt",
+    "Provider",
+    "ColorCode",
+]
+
+
+class Prompt():
+    """
+    The Prompt main application.
+
+    Usage:
+        client = Prompt()
+        answer = client.ask(prompt)
+    """
+
+    def __init__(self):
+        # Values independent of system or user setting file
+        self.role = 'user'
+        # Anthropic requires max_tokens, so default value is given.
+        # It can be overwritten by max_tokens.
+        self.max_tokens_anthropic = 4096
+        # Load system default values from data/system.ini
+        inifile = configparser.ConfigParser()
+        here = os.path.abspath(os.path.dirname(__file__))
+        inifile.read(os.path.join(here, 'data/system.ini'))
+        self.version = inifile.get('system', 'version')
+        self.description = inifile.get('system', 'description')
+        self.url = inifile.get('system', 'url')
+        # Load user setting from config file in the order of
+        # ~/.multiai, .multai
+        # It overwrites the system default values
+        conf_file = os.path.expanduser('~/.multiai')
+        inifile.read(conf_file)
+        inifile.read('.multiai')
+        self.set_provider(inifile.get('model', 'ai_provider'))
+        for provider in Provider:
+            name = provider.name.lower()
+            model = inifile.get('model', name, fallback=None)
+            if model is None:
+                print(f'multiai system error: {name} not found in [model].')
+                sys.exit(1)
+            setattr(self, 'model_' + name, model)
+        self.temperature = inifile.getfloat('default', 'temperature')
+        self.max_requests = inifile.getint('default', 'max_requests')
+        prompt_color = inifile.get('prompt', 'color')
+        try:
+            self.prompt_color = ColorCode[prompt_color.upper()].value
+        except Exception:
+            print(f'Error in the settings file: color = {prompt_color}')
+            available_colors = [name.lower()
+                                for name in ColorCode.__members__.keys()]
+            print(f'Available colors: {", ".join(available_colors)}')
+            sys.exit(1)
+        # No system default value is given from here.
+        # Default values are given by fallback values.
+        self.max_tokens = inifile.getint(
+            'default', 'max_tokens', fallback=None)
+        for provider in Provider:
+            env = os.getenv(provider.name + '_API_KEY')
+            name = provider.name.lower()
+            key = name + '_api_key'
+            if env is None:
+                ini = inifile.get('api_key', name, fallback=None)
+                setattr(self, key, ini)
+            else:
+                setattr(self, key, env)
+        self.clear()
+
+    def set_provider(self, provider):
+        """
+        Set AI provider
+
+        :param provider: str
+            AI provider (case insensitive)
+        """
+        try:
+            self.ai_provider = Provider[provider.upper()]
+        except Exception:
+            print(f'AI provider "{provider}" is not available.')
+            sys.exit(1)
+
+    def set_model(self, provider, model):
+        """
+        Set model
+
+        :param prvider: str
+            AI provider (case insensitive)
+        :param model: str
+            AI model
+        """
+        self.set_provider(provider)
+        self.model = model
+        setattr(self, 'model_' + provider.lower(), model)
+
+    def clear(self):
+        """
+        Clear chat history.
+        """
+        self.openai_messages = []
+        self.anthropic_messages = []
+        self.google_chat = None
+        self.perplexity_messages = []
+        self.mistral_messages = []
+
+    def ask(self, prompt, request=1, verbose=False):
+        """
+        Ask a question to AI.
+
+        :param prompt: str
+            prompt to ask AI
+        :param request: int
+            numbers of repetitive request
+        :param verbose: boolean
+            show repeat process
+        :return: str
+            Answer from AI
+        """
+        self.message = [
+            {
+                "role": self.role,
+                "content": prompt,
+            }
+        ]
+        self.prompt = prompt
+        if request == 1:
+            self.prompt_continue = False
+        else:
+            self.prompt_continue = True
+        # For example, call ask_openai() for openai
+        func_name = 'ask_' + self.ai_provider.name.lower()
+        try:
+            func = getattr(self, func_name)
+        except AttributeError:
+            print(
+                f'multiai system error: {func_name}() function is not defined.')
+            sys.exit(1)
+        func()
+        # Error
+        if self.error:
+            return self.error_message
+        # Finish successfully
+        if self.finish_reason in ['stop', 'end_turn']:
+            return self.response
+        # Unexpected finish reason
+        if self.finish_reason not in ['length', 'max_tokens']:
+            self.response += '\n\nFinish reason: {self.finish_reason}'
+            return self.response
+        # Response not finished. Continue the request.
+        request += 1
+        if request > self.max_requests:
+            self.response += '\n\nFinished because of max_tokens and max_requests.'
+            return self.response
+        if verbose:
+            print(
+                f'{self.color("Repeating...")} max_requests = {self.max_requests}, requests = {request}\r',
+                end='')
+        response = self.response
+        answer = self.ask('continue', request=request, verbose=verbose)
+        if self.error:
+            return answer
+        return response + answer
+
+    def ask_print(self, prompt, prompt_summary=None):
+        """
+        Ask a question to AI and print, copy, log
+
+        :param prompt: str
+            prompt to ask AI
+        :param prompt_summary: str
+            prompt shortened for logging
+        """
+        print(f'{self.color("Please wait ......")}\r', end='')
+        if len(self.ai_providers) == 1:
+            answer = self.ask(prompt, verbose=True)
+            print(' ' * 50 + '\r', end='')
+            if self.error:
+                print(f'{self.color("Error message")}> {answer}')
+                sys.exit(1)
+            print(f'{self.color(self.model)}>')
+            if self.log:
+                if prompt_summary is not None:
+                    prompt = prompt_summary
+                with open(self.log_file, mode='a') as f:
+                    f.write(
+                        f'### {self.role}:\n{prompt}\n### {self.model}:\n{answer}\n')
+        else:
+            answer = ''
+            if prompt_summary is None:
+                prompt_log = prompt
+            else:
+                prompt_log = prompt_summary
+            for provider in (self.ai_providers):
+                self.ai_provider = provider
+                single_answer = self.ask(prompt, verbose=True)
+                model = getattr(self, 'model_' + provider.name.lower(), None)
+                if self.error:
+                    print(
+                        f'{self.color("Error message from " + provider.name.lower())}> {single_answer}')
+                    sys.exit(1)
+                answer += f'### {model}:\n{single_answer}\n\n'
+            answer = answer.strip()
+            if self.log:
+                with open(self.log_file, mode='a') as f:
+                    f.write(
+                        f'### {self.role}:\n{prompt_log}\n{answer}\n')
+        print(' ' * 50 + '\r', end='')
+        print_long(answer)
+        if self.copy:
+            pyperclip.copy(answer)
+
+    def interactive(self, pre_prompt=''):
+        """
+        Interactive mode
+
+        :param pre_prompt: str
+            pre-prompt to append before prompt
+        """
+        prompt = ''
+        blank = 0
+        b = self.blank_lines
+        if b > 0:
+            print(
+                f'\nInput {b} blank line{"s" if b > 1 else ""} to finish input.')
+        while True:
+            try:
+                if prompt == '':
+                    line = input(f'{self.color(self.role)}> ')
+                else:
+                    line = input()
+            except EOFError:
+                sys.exit()
+            except KeyboardInterrupt:
+                sys.exit()
+            if line == '':
+                if prompt == '':
+                    print('Blank text entered. Enter "q" to quit.')
+                    continue
+                blank += 1
+                if blank < self.blank_lines:
+                    prompt += line + '\n'
+                else:
+                    self.ask_print(pre_prompt + prompt.strip())
+                    prompt = ''
+                    blank = 0
+            elif prompt == '' and line in ['q', 'x', 'quit', 'exit']:
+                sys.exit()
+            else:
+                if self.blank_lines == 0:
+                    self.ask_print(pre_prompt + line)
+                    prompt = ''
+                else:
+                    prompt += line + '\n'
+                    blank = 0
+
+    def color(self, text):
+        """
+        Return colored text with color defined at self.prompt_color
+
+        :param text: str
+            Text
+        :return: str
+            Colored text
+        """
+        if sys.stdout.isatty():
+            return f'\033[{self.prompt_color}m{text}\033[0m'
+        else:
+            return text
+
+    def retrieve_from_url(self, url, verbose=True):
+        """
+        Retrieve text from URL.
+
+        When URL ends with ".pdf", PDF file is converted to text.
+
+        :param url: str
+            URL to retrieve data from
+        :param verbose: boolean
+            whether to print message
+        :return: str
+            Retrieved text
+        """
+        if verbose:
+            print('Retrieving ...\r', end='')
+        headers = {
+            'User-Agent': self.user_agent if hasattr(self, 'user_agent') else None}
+        try:
+            response = requests.get(url, headers=headers)
+        except Exception as e:
+            if verbose:
+                print(e)
+            sys.exit(1)
+        if response.status_code != 200:
+            if verbose:
+                print(f'{response.status_code} - {response.reason}')
+            sys.exit(1)
+        if verbose:
+            print('Converting to text.\r', end='')
+        if url.lower().endswith('.pdf'):
+            with BytesIO(response.content) as pdf_file:
+                reader = PyPDF2.PdfReader(pdf_file)
+                text = ""
+                for page in range(len(reader.pages)):
+                    text += reader.pages[page].extract_text()
+        else:
+            text = trafilatura.extract(response.text)
+            if text is None:
+                if verbose:
+                    print(f'{url} could not be retrieved.')
+                sys.exit(1)
+        return text
+
+    # Implementations for each providers
+    def ask_openai(self):
+        """
+        Ask a question to OpenAI.
+        """
+        if self.openai_api_key is None:
+            self.error = True
+            self.error_message = 'API key for OpenAI is not set.'
+            return
+        openai.api_key = self.openai_api_key
+        if not self.prompt_continue:
+            self.openai_messages += self.message
+        try:
+            self.completion = openai.chat.completions.create(
+                messages=self.openai_messages,
+                model=self.model_openai,
+                temperature=self.temperature,
+                max_tokens=self.max_tokens
+            )
+            self.error = False
+            self.response = self.completion.choices[0].message.content.strip(
+            )
+            self.finish_reason = self.completion.choices[0].finish_reason
+            self.openai_messages += [{"role": "assistant",
+                                      "content": self.response}]
+        except openai.APIError as e:
+            self.error = True
+            try:
+                self.error_code = e.status_code
+                self.error_dict = e.body
+                self.error_type = f"Error {self.error_code}: {self.error_dict['code']}"
+                self.error_message = f"{self.error_type}\n{self.error_dict['message']}"
+            except Exception:
+                self.error_message = e
+
+    def ask_anthropic(self):
+        """
+        Ask a question to Anthropic.
+        """
+        if self.anthropic_api_key is None:
+            self.error = True
+            self.error_message = 'API key for Anthropic is not set.'
+            return
+        client = anthropic.Anthropic(api_key=self.anthropic_api_key)
+        self.anthropic_messages += self.message
+        try:
+            self.completion = client.messages.create(
+                messages=self.anthropic_messages,
+                model=self.model_anthropic,
+                temperature=self.temperature,
+                max_tokens=self.max_tokens if self.max_tokens else self.max_tokens_anthropic
+            )
+            self.error = False
+            self.response = self.completion.content[0].text.strip()
+            self.finish_reason = self.completion.stop_reason
+            self.anthropic_messages += [{"role": "assistant",
+                                         "content": self.response}]
+        except Exception as e:
+            self.error = True
+            try:
+                self.error_code = e.status_code
+                self.error_dict = e.body['error']
+                self.error_type = f"{self.error_code}: {self.error_dict['type']}"
+                self.error_message = f"{self.error_type}\n{self.error_dict['message']}"
+            except Exception:
+                self.error_message = e
+
+    def ask_google(self):
+        """
+        Ask a question to Google.
+        """
+        # Supress logging warnings of libraries
+        os.environ["GRPC_VERBOSITY"] = "ERROR"
+        os.environ["GLOG_minloglevel"] = "2"
+        if self.google_api_key is None:
+            self.error = True
+            self.error_message = 'API key for Google is not set.'
+            return
+        genai.configure(api_key=self.google_api_key)
+        model = genai.GenerativeModel(self.model_google)
+        if self.google_chat is None:
+            self.google_chat = model.start_chat(history=[])
+        config = genai.types.GenerationConfig(
+            temperature=self.temperature,
+            max_output_tokens=self.max_tokens)
+        try:
+            self.completion = self.google_chat.send_message(
+                self.prompt, generation_config=config)
+            self.error = False
+            self.response = self.completion.text.replace('•', '* ').strip()
+            self.finish_reason = self.completion.candidates[0].finish_reason.name.lower(
+            )
+        except Exception as e:
+            self.error = True
+            try:
+                self.error_message = e.message
+            except Exception:
+                self.error_message = e
+
+    def ask_perplexity(self):
+        """
+        Ask a question to perplexity.
+        """
+        if self.perplexity_api_key is None:
+            self.error = True
+            self.error_message = 'API key for Perplexity is not set.'
+            return
+        base_url = 'https://api.perplexity.ai'
+        client = openai.OpenAI(
+            api_key=self.perplexity_api_key,
+            base_url=base_url)
+        self.perplexity_messages += self.message
+        try:
+            self.completion = client.chat.completions.create(
+                messages=self.perplexity_messages,
+                model=self.model_perplexity,
+                temperature=self.temperature,
+                max_tokens=self.max_tokens
+            )
+            self.error = False
+            self.response = self.completion.choices[0].message.content.strip(
+            )
+            self.finish_reason = self.completion.choices[0].finish_reason
+            self.perplexity_messages += [{"role": "assistant",
+                                          "content": self.response}]
+        except openai.APIError as e:
+            self.error = True
+            try:
+                # print(f'e = {e.__dict__.keys()}')
+                # for key in e.__dict__.keys():
+                #     print(f'e.{key} = {getattr(e, key)}')
+                message = trafilatura.extract(e.message)
+                self.error_message = message.splitlines()[0]
+            except Exception:
+                self.error_message = e
+
+    def ask_mistral(self):
+        """
+        Ask a question to mistral.
+        """
+        if self.mistral_api_key is None:
+            self.error = True
+            self.error_message = 'API key for Mistral is not set.'
+            return
+        client = mistralai.Mistral(api_key=self.mistral_api_key)
+        self.mistral_messages += self.message
+        try:
+            self.completion = client.chat.complete(
+                messages=self.mistral_messages,
+                model=self.model_mistral,
+                temperature=self.temperature,
+                max_tokens=self.max_tokens
+            )
+            self.error = False
+            self.response = self.completion.choices[0].message.content.strip(
+            )
+            self.finish_reason = self.completion.choices[0].finish_reason
+            self.mistral_messages += [{"role": "assistant",
+                                       "content": self.response}]
+        except mistralai.SDKError as e:
+            self.error = True
+            try:
+                self.error_code = e.status_code
+                self.error_dict = json.loads(e.body)
+                self.error_message = f"Error {self.error_code}: {self.error_dict['message']}"
+            except Exception:
+                self.error_message = e
+
+
+class Provider(enum.Enum):
+    """
+    Provider is an Enum representing AI provider available at multiai.
+
+    To add a provider definition,
+    (1) Add the provider here. Note that the first letter should not
+        overwrap other command-line options
+    (2) Define ask_provider() function in Prompt class
+    (3) Update clear() function in Prompt class
+    (4) Define default model at system.ini
+    """
+    ANTHROPIC = enum.auto()
+    GOOGLE = enum.auto()
+    OPENAI = enum.auto()
+    PERPLEXITY = enum.auto()
+    MISTRAL = enum.auto()
+
+
+class ColorCode(enum.Enum):
+    """
+    ColorCode is an Enum representing ANSI color codes.
+
+    Each member of this Enum corresponds to a specific color used in terminal output.
+    """
+    BLACK = 30
+    RED = 31
+    GREEN = 32
+    YELLOW = 33
+    BLUE = 34
+    MAGENTA = 35
+    CYAN = 36
+    WHITE = 37
+    BACK_BLACK = 40
+    BACK_RED = 41
+    BACK_GREEN = 42
+    BACK_YELLOW = 43
+    BACK_BLUE = 44
+    BACK_MAGENTA = 45
+    BACK_CYAN = 46
+    BACK_WHITE = 47

multiai/printlong.py

@@ -0,0 +1,83 @@
+"""
+print_long - print long text with pypager
+"""
+import shutil
+import unicodedata
+import pypager
+
+
+def print_long(text):
+    """
+    Print long text with pypager.
+
+    When text fits in 1 page in a terminal, it uses print,
+    otherwise it uses pypager.
+
+    :param text: str
+        text to display
+    """
+    default_terminal_size = (80, 20)
+    terminal_size = shutil.get_terminal_size(default_terminal_size)
+    lines_per_page = terminal_size.lines - 1
+    terminal_width = terminal_size.columns
+    wrapped_lines = []
+    for line in text.split('\n'):
+        wrapped_lines.extend(wrap_text(line, terminal_width))
+    total_lines = len(wrapped_lines)
+    wrapped_text = '\n'.join(wrapped_lines)
+    if total_lines <= lines_per_page:
+        print(text)
+    else:
+        p = pypager.pager.Pager()
+        p.add_source(pypager.source.StringSource(wrapped_text))
+        p.run()
+
+
+def calculate_display_width(text):
+    """
+    Calculate display width of a line.
+
+    :param text: str
+        text to count
+    """
+    width = 0
+    for char in text:
+        if unicodedata.east_asian_width(char) in 'WF':
+            width += 2
+        else:
+            width += 1
+    return width
+
+
+def wrap_text(text, width):
+    """
+    Wrap text of a line.
+
+    :param text: str
+        text to wrap
+    :param width: int
+        display width
+    """
+    lines = []
+    current_line = ""
+    current_width = 0
+    for line in text.split('\n'):
+        if not line:
+            lines.append("")
+            continue
+        for char in line:
+            char_width = 2 if unicodedata.east_asian_width(char) in 'WF' else 1
+            if current_width + char_width > width:
+                lines.append(current_line)
+                current_line = char
+                current_width = char_width
+            else:
+                current_line += char
+                current_width += char_width
+        if current_line:
+            lines.append(current_line)
+            current_line = ""
+            current_width = 0
+    if current_line:
+        lines.append(current_line)
+    return lines

multiai-0.2.dist-info/LICENSE

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

multiai-0.2.dist-info/METADATA

@@ -0,0 +1,137 @@
+Metadata-Version: 2.1
+Name: multiai
+Version: 0.2
+Summary: A Python library for text-based AI interactions
+Home-page: https://sekika.github.io/multiai/
+Author: Katsutoshi Seki
+License: MIT
+Keywords: AI
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: Environment :: Console
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Operating System :: MacOS :: MacOS X
+Classifier: Operating System :: Microsoft :: Windows :: Windows 10
+Classifier: Operating System :: Microsoft :: Windows :: Windows 11
+Classifier: Operating System :: POSIX
+Classifier: Operating System :: POSIX :: BSD
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Natural Language :: English
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: openai
+Requires-Dist: anthropic
+Requires-Dist: google-generativeai
+Requires-Dist: requests
+Requires-Dist: mistralai
+Requires-Dist: pypager
+Requires-Dist: pyperclip
+Requires-Dist: PyPDF2
+Requires-Dist: trafilatura
+
+# multiai
+
+`multiai` is a Python library and command-line tool designed to interact with text-based generative AI models from the following providers:
+
+| AI Provider  | Web Service                        | Models Available                                               |
+|--------------|------------------------------------|----------------------------------------------------------------|
+| **OpenAI**   | [ChatGPT](https://chat.openai.com/) | [GPT Models](https://platform.openai.com/docs/models) |
+| **Anthropic**| [Claude](https://claude.ai/) | [Claude Models](https://docs.anthropic.com/en/docs/about-claude/models) |
+| **Google**   | [Gemini](https://gemini.google.com/)| [Gemini Models](https://ai.google.dev/gemini-api/docs/models/gemini) |
+| **Perplexity** | [Perplexity](https://www.perplexity.ai/) | [Perplexity Models](https://docs.perplexity.ai/docs/model-cards) |
+| **Mistral**  | [Mistral](https://chat.mistral.ai/chat) | [Mistral Models](https://docs.mistral.ai/getting-started/models/) |
+
+## Key Features
+
+- **Interactive Chat:** Communicate with AI directly from your terminal.
+- **Multi-Line Input:** Supports multi-line prompts for complex queries.
+- **Pager for Long Responses:** View lengthy responses conveniently using a pager.
+- **Continuation Handling:** Automatically handle and request continuations if responses are cut off.
+- **Automatic Chat Logging:** Automatically save your chat history for future reference.
+
+## Usage
+
+Install `multiai`, then configure your API keys for your chosen AI providers as environment variables or in a user-setting file. Once that's done, you can start interacting with the AI.
+
+- To send a simple query:
+
+  ```bash
+  ai hi
+  ```
+
+  You should see a response like:
+
+  ```bash
+  gpt-4o-mini>
+  Hello! How can I assist you today?
+  ```
+
+- For an interactive session, enter interactive mode:
+
+  ```bash
+  ai
+  ```
+
+  In this mode, you can continue the conversation:
+
+  ```bash
+  user> hi
+  gpt-4o-mini>
+  Hello! How can I assist you today?
+  user> how are you
+  gpt-4o-mini>
+  I'm just a program, so I don't have feelings, but I'm here and ready to help you! How about you? How are you doing?
+  user>
+  ```
+
+To see a list of all command-line options, use:
+
+```bash
+ai -h
+```
+
+For more detailed documentation, you can open the [manual](https://sekika.github.io/multiai/) in a web browser with:
+
+```bash
+ai -d
+```
+
+## Using `multiai` as a Python Library
+
+`multiai` can also be used as a Python library. Here’s a simple example:
+
+```python
+import multiai
+
+# Initialize the client
+client = multiai.Prompt()
+client.set_model('openai', 'gpt-4o')  # Set model
+client.temperature = 0.5  # Set temperature
+
+# Send a prompt and get a response
+answer = client.ask('hi')
+print(answer)
+
+# Continue the conversation with context
+answer = client.ask('how are you')
+print(answer)
+
+# Clear the conversation context
+client.clear()
+```
+
+The manual includes the following sample codes:
+
+- A script that translates a text file into English.
+- A local chat app that allows you to easily select from various AI models provided by different providers and engage in conversations with them.

multiai-0.2.dist-info/RECORD

@@ -0,0 +1,11 @@
+multiai/__init__.py,sha256=4-GlQ8EG6H-bo-MAtqRuEagzRVsbcTbYcypRg4QFb-o,87
+multiai/entry.py,sha256=-HadVUo9TFs80moS1Z_-lwNbswuZAnbELF5xXjloHNg,5348
+multiai/multiai.py,sha256=mOj5E1bHIuuE8B3aSE-4Nv410BovVTkuf25eBhOr274,18894
+multiai/printlong.py,sha256=262_HUxTguI5oBjd7vbMdTqGQfub0ZX9KmNF_wwmPno,2085
+multiai/data/system.ini,sha256=9kTZaOLY7SUdcGzeSlzE0BQfi-YqrMnoEr2V7YRoalA,785
+multiai-0.2.dist-info/LICENSE,sha256=9KL7GR2OrW7sgnHc8IM48AAcQ6gTEstY3UQRpe3OC5A,1085
+multiai-0.2.dist-info/METADATA,sha256=rJ5toCg-naptoJDAwx4C8ybKrcmSpfubMcuXA7SnPHI,4705
+multiai-0.2.dist-info/WHEEL,sha256=HiCZjzuy6Dw0hdX5R3LCFPDmFS4BWl8H-8W39XfmgX4,91
+multiai-0.2.dist-info/entry_points.txt,sha256=gt2WpdEIKJEcBWGWyC0-bXGK0L7767qqSfu7NUEmr3Y,43
+multiai-0.2.dist-info/top_level.txt,sha256=nIS7JbFZhSLFa-wpj8vjQ52SvxPEm9bAEYJxgV1gj68,8
+multiai-0.2.dist-info/RECORD,,

multiai-0.2.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (72.2.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

multiai-0.2.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+ai = multiai.entry:entry

multiai-0.2.dist-info/top_level.txt

@@ -0,0 +1 @@
+multiai