philo-chat 0.1.0__tar.gz

philo_chat-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Erfan Moosavi
+
+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.

philo_chat-0.1.0/PKG-INFO

@@ -0,0 +1,77 @@
+Metadata-Version: 2.4
+Name: philo-chat
+Version: 0.1.0
+Summary: Chat with your favorite philosophers - Nietzsche, Socrates, and more!
+Author-email: Erfan Moosavi <erfanmoosavi84@gmail.com>
+License: MIT
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: fastapi[standard]==0.129.0
+Requires-Dist: openai>=1.0.0
+Requires-Dist: pydantic>=2.0.0
+Requires-Dist: python-dotenv>=1.0.1
+Requires-Dist: pyyaml>=6.0
+Dynamic: license-file
+
+# PhiloChat
+
+![PyPI](https://img.shields.io/pypi/v/philo-chat)
+![License](https://img.shields.io/pypi/l/philo-chat)
+
+Chat with your favorite philosophers - Nietzsche, Socrates, and more-in real-time!
+
+## 📌 Overview
+
+Philo-Chat is an interactive command-line application that allows users to have AI-powered conversations with famous philosophers. Each philosopher responds in their distinctive style, language, and perspective. Users can create multiple chats, select philosophers, and maintain conversation histories.
+
+---
+
+## 🌟 Features
+
+* **User Authentication:** Signup and login functionality to secure chats.
+* **Multiple Chats:** Create multiple chat sessions with different philosophers.
+* **AI-Powered Philosopher Responses:** Each philosopher responds intelligently using an AI completion engine.
+* **Chat Management:** Delete or exit chats at any time.
+* **Interactive CLI:** Easy-to-use command-line interface with clear prompts and messages.
+* **Chat History:** Maintains conversation history per chat.
+
+---
+
+## 🚀 Quick Start
+
+```bash
+# 1. Install
+pip install -U philo-chat
+
+# 2. Create .env file with your API credentials
+echo "BASE_URL=your_url" > .env
+echo "OPENAI_API_KEY=your_key" > .env
+echo "MODEL_NAME=your_model" > .env
+
+# 3. Run!
+philo-chat
+```
+
+---
+
+## ⚙️ Commands
+
+* `signup` - Create a new user account.
+* `login` - Log in with an existing account.
+* `logout` - Log out from the current account.
+* `delete_account` - Delete your account.
+* `new_chat` - Start a new chat with a philosopher.
+* `select_chat` - Enter an existing chat session.
+* `exit_chat` - Exit the current chat session.
+* `delete_chat` - Delete a specific chat session.
+* `list_chats` - Show all your existing chats and their philosophers.
+* `list_philosophers` - Show all available philosophers to chat with.
+* `help` - Show available commands.
+* `exit` - Exit the application.
+
+---
+
+## 📄 License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.

philo_chat-0.1.0/README.md

@@ -0,0 +1,61 @@
+# PhiloChat
+
+![PyPI](https://img.shields.io/pypi/v/philo-chat)
+![License](https://img.shields.io/pypi/l/philo-chat)
+
+Chat with your favorite philosophers - Nietzsche, Socrates, and more-in real-time!
+
+## 📌 Overview
+
+Philo-Chat is an interactive command-line application that allows users to have AI-powered conversations with famous philosophers. Each philosopher responds in their distinctive style, language, and perspective. Users can create multiple chats, select philosophers, and maintain conversation histories.
+
+---
+
+## 🌟 Features
+
+* **User Authentication:** Signup and login functionality to secure chats.
+* **Multiple Chats:** Create multiple chat sessions with different philosophers.
+* **AI-Powered Philosopher Responses:** Each philosopher responds intelligently using an AI completion engine.
+* **Chat Management:** Delete or exit chats at any time.
+* **Interactive CLI:** Easy-to-use command-line interface with clear prompts and messages.
+* **Chat History:** Maintains conversation history per chat.
+
+---
+
+## 🚀 Quick Start
+
+```bash
+# 1. Install
+pip install -U philo-chat
+
+# 2. Create .env file with your API credentials
+echo "BASE_URL=your_url" > .env
+echo "OPENAI_API_KEY=your_key" > .env
+echo "MODEL_NAME=your_model" > .env
+
+# 3. Run!
+philo-chat
+```
+
+---
+
+## ⚙️ Commands
+
+* `signup` - Create a new user account.
+* `login` - Log in with an existing account.
+* `logout` - Log out from the current account.
+* `delete_account` - Delete your account.
+* `new_chat` - Start a new chat with a philosopher.
+* `select_chat` - Enter an existing chat session.
+* `exit_chat` - Exit the current chat session.
+* `delete_chat` - Delete a specific chat session.
+* `list_chats` - Show all your existing chats and their philosophers.
+* `list_philosophers` - Show all available philosophers to chat with.
+* `help` - Show available commands.
+* `exit` - Exit the application.
+
+---
+
+## 📄 License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.

philo_chat-0.1.0/philo_chat.egg-info/PKG-INFO

@@ -0,0 +1,77 @@
+Metadata-Version: 2.4
+Name: philo-chat
+Version: 0.1.0
+Summary: Chat with your favorite philosophers - Nietzsche, Socrates, and more!
+Author-email: Erfan Moosavi <erfanmoosavi84@gmail.com>
+License: MIT
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: fastapi[standard]==0.129.0
+Requires-Dist: openai>=1.0.0
+Requires-Dist: pydantic>=2.0.0
+Requires-Dist: python-dotenv>=1.0.1
+Requires-Dist: pyyaml>=6.0
+Dynamic: license-file
+
+# PhiloChat
+
+![PyPI](https://img.shields.io/pypi/v/philo-chat)
+![License](https://img.shields.io/pypi/l/philo-chat)
+
+Chat with your favorite philosophers - Nietzsche, Socrates, and more-in real-time!
+
+## 📌 Overview
+
+Philo-Chat is an interactive command-line application that allows users to have AI-powered conversations with famous philosophers. Each philosopher responds in their distinctive style, language, and perspective. Users can create multiple chats, select philosophers, and maintain conversation histories.
+
+---
+
+## 🌟 Features
+
+* **User Authentication:** Signup and login functionality to secure chats.
+* **Multiple Chats:** Create multiple chat sessions with different philosophers.
+* **AI-Powered Philosopher Responses:** Each philosopher responds intelligently using an AI completion engine.
+* **Chat Management:** Delete or exit chats at any time.
+* **Interactive CLI:** Easy-to-use command-line interface with clear prompts and messages.
+* **Chat History:** Maintains conversation history per chat.
+
+---
+
+## 🚀 Quick Start
+
+```bash
+# 1. Install
+pip install -U philo-chat
+
+# 2. Create .env file with your API credentials
+echo "BASE_URL=your_url" > .env
+echo "OPENAI_API_KEY=your_key" > .env
+echo "MODEL_NAME=your_model" > .env
+
+# 3. Run!
+philo-chat
+```
+
+---
+
+## ⚙️ Commands
+
+* `signup` - Create a new user account.
+* `login` - Log in with an existing account.
+* `logout` - Log out from the current account.
+* `delete_account` - Delete your account.
+* `new_chat` - Start a new chat with a philosopher.
+* `select_chat` - Enter an existing chat session.
+* `exit_chat` - Exit the current chat session.
+* `delete_chat` - Delete a specific chat session.
+* `list_chats` - Show all your existing chats and their philosophers.
+* `list_philosophers` - Show all available philosophers to chat with.
+* `help` - Show available commands.
+* `exit` - Exit the application.
+
+---
+
+## 📄 License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.

philo_chat-0.1.0/philo_chat.egg-info/SOURCES.txt

@@ -0,0 +1,26 @@
+LICENSE
+README.md
+pyproject.toml
+philo_chat.egg-info/PKG-INFO
+philo_chat.egg-info/SOURCES.txt
+philo_chat.egg-info/dependency_links.txt
+philo_chat.egg-info/entry_points.txt
+philo_chat.egg-info/requires.txt
+philo_chat.egg-info/top_level.txt
+src/__init__.py
+src/philo_chat.py
+src/py.typed
+src/cli/cli.py
+src/cli/console_io_handler.py
+src/core/__init__.py
+src/core/exceptions.py
+src/core/entities/__init__.py
+src/core/entities/chat.py
+src/core/entities/chat_completer.py
+src/core/entities/message.py
+src/core/entities/philosopher.py
+src/core/entities/user.py
+src/core/utils/__init__.py
+src/core/utils/prompt_loading.py
+src/data/philosophers.json
+src/data/prompt_template.yaml

philo_chat-0.1.0/philo_chat.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

philo_chat-0.1.0/philo_chat.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+philo-chat = src.cli.cli:main

philo_chat-0.1.0/philo_chat.egg-info/requires.txt

@@ -0,0 +1,5 @@
+fastapi[standard]==0.129.0
+openai>=1.0.0
+pydantic>=2.0.0
+python-dotenv>=1.0.1
+pyyaml>=6.0

philo_chat-0.1.0/philo_chat.egg-info/top_level.txt

@@ -0,0 +1 @@
+src

philo_chat-0.1.0/pyproject.toml

@@ -0,0 +1,32 @@
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "philo-chat"
+version = "0.1.0"
+authors = [{ name = "Erfan Moosavi", email = "erfanmoosavi84@gmail.com" }]
+description = "Chat with your favorite philosophers - Nietzsche, Socrates, and more!"
+readme = "README.md"
+license = {text = "MIT"}
+requires-python = ">=3.10"
+dependencies = [
+  "fastapi[standard]==0.129.0",
+  "openai>=1.0.0",
+  "pydantic>=2.0.0",
+  "python-dotenv>=1.0.1",
+  "pyyaml>=6.0",
+]
+
+[project.scripts]
+philo-chat = "src.cli.cli:main"
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["src*"]
+
+[tool.setuptools]
+include-package-data = true
+
+[tool.setuptools.package-data]
+"src" = ["data/*.json", "data/*.yaml", "py.typed"]

philo_chat-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

philo_chat-0.1.0/src/__init__.py

@@ -0,0 +1,3 @@
+from .philo_chat import PhiloChat
+
+__all__ = ["PhiloChat"]

philo_chat-0.1.0/src/cli/cli.py

@@ -0,0 +1,222 @@
+import os
+import sys
+from enum import Enum
+
+from dotenv import load_dotenv
+
+from .console_io_handler import ConsoleIOHandler
+from ..philo_chat import PhiloChat
+
+
+class Commands(Enum):
+    SIGNUP = "signup"
+    LOGIN = "login"
+    LOGOUT = "logout"
+    DELETE_ACCOUNT = "delete_account"
+    NEW_CHAT = "new_chat"
+    SELECT_CHAT = "select_chat"
+    LIST_CHATS = "list_chats"
+    EXIT_CHAT = "exit_chat"
+    DELETE_CHAT = "delete_chat"
+    LIST_PHILOSOPHERS = "list_philosophers"
+    HELP = "help"
+    EXIT = "exit"
+
+
+class PhiloChatCLI:
+    SUCCESS = "Success"
+
+    def __init__(self, base_url: str, api_key: str, model_name: str) -> None:
+        self.system = PhiloChat(base_url, api_key, model_name)
+        self.io = ConsoleIOHandler()
+        self.help_menu = "Available commands:\n" + "\n".join(
+            [f"\t-{command.value}" for command in Commands]
+        )
+
+    def run(self) -> None:
+        self.io.display_message(
+            "Welcome to Philosopher Chat!\nCommands? Type 'help' and see what's possible"
+        )
+
+        while True:
+            command = self.io.get_input("Please enter the command: ")
+            result = self._handle_command(command)
+
+            if result == "EXIT":
+                break
+            elif result == "HELP":
+                self.io.display_message(self.help_menu)
+            elif result:
+                self.io.display_message(result)
+
+    def _format_message(self, msg) -> str:
+        return f"[{msg.time}] {msg.author} ->\n{msg.content}"
+
+    def _handle_command(self, command: str) -> str:
+        if command == Commands.SIGNUP.value:
+            return self._handle_signup()
+        elif command == Commands.LOGIN.value:
+            return self._handle_login()
+        elif command == Commands.LOGOUT.value:
+            return self._handle_logout()
+        elif command == Commands.DELETE_ACCOUNT.value:
+            return self._handle_delete_account()
+        elif command == Commands.NEW_CHAT.value:
+            return self._handle_new_chat()
+        elif command == Commands.SELECT_CHAT.value:
+            return self._handle_select_chat()
+        elif command == Commands.LIST_CHATS.value:
+            return self._handle_list_chats()
+        elif command == Commands.DELETE_CHAT.value:
+            return self._handle_delete_chat()
+        elif command == Commands.LIST_PHILOSOPHERS.value:
+            return self._handle_list_philosophers()
+        elif command == Commands.HELP.value:
+            return "HELP"
+        elif command == Commands.EXIT.value:
+            return "EXIT"
+        else:
+            return "Please enter a valid command."
+
+    def _handle_signup(self) -> str:
+        try:
+            username = self.io.get_input("Enter your username: ")
+            password = self.io.get_input("Enter your password: ")
+            name = self.io.get_input("Enter your name: ")
+            age = self.io.get_input("Enter your age: ")
+            self.system.signup(username, password, name, age)
+            return self.SUCCESS
+
+        except Exception as e:
+            self.io.display_message(str(e))
+
+    def _handle_login(self) -> str:
+        try:
+            username = self.io.get_input("Enter your username: ")
+            password = self.io.get_input("Enter your password: ")
+            self.system.login(username, password)
+            return self.SUCCESS
+
+        except Exception as e:
+            self.io.display_message(str(e))
+
+    def _handle_logout(self) -> str:
+        try:
+            self.system.logout()
+            return self.SUCCESS
+
+        except Exception as e:
+            self.io.display_message(str(e))
+
+    def _handle_delete_account(self) -> str:
+        try:
+            self.system.delete_account()
+            return self.SUCCESS
+
+        except Exception as e:
+            self.io.display_message(str(e))
+
+    def _handle_new_chat(self) -> str:
+        try:
+            chat_name = self.io.get_input("Enter the chat name: ")
+            philosophers_list = self.system.list_philosophers()
+
+            self.io.display_philosophers_list(philosophers_list)
+
+            philosopher_id = (
+                int(self.io.get_input("Choose a philosopher by number: ")) - 1
+            )
+            if philosopher_id < 0 or philosopher_id >= len(philosophers_list):
+                return "Invalid choice."
+
+            # Convert list index to actual philosopher ID
+            actual_philosopher_id = list(self.system.philosophers.keys())[
+                philosopher_id
+            ]
+            self.system.new_chat(chat_name, actual_philosopher_id)
+            return self.SUCCESS
+
+        except Exception as e:
+            self.io.display_message(str(e))
+
+    def _handle_select_chat(self) -> str:
+        name = self.io.get_input("Enter the chat name: ")
+        return self._handle_chat_session(name)
+
+    def _handle_chat_session(self, name: str) -> str:
+        try:
+            all_messages = self.system.select_chat(name)
+
+            # Display chat history
+            for msg in all_messages:
+                self.io.display_chat_message(self._format_message(msg))
+
+            # Chat loop
+            while (
+                self.system.logged_in_user and self.system.logged_in_user.selected_chat
+            ):
+                input_text = self.io.get_input(
+                    "Enter your message (type 'exit_chat' to leave): "
+                )
+                if input_text == Commands.EXIT_CHAT.value:
+                    self.system.exit_chat()
+                    break
+
+                ai_msg, user_msg = self.system.complete_chat(input_text)
+
+                self.io.display_chat_message(self._format_message(user_msg))
+                self.io.display_chat_message(self._format_message(ai_msg))
+
+            return "Exited chat."
+
+        except Exception as e:
+            self.io.display_message(str(e))
+
+    def _handle_list_chats(self) -> str:
+        try:
+            chats = self.system.list_chats()
+            self.io.display_chats_list(chats)
+
+        except Exception as e:
+            self.io.display_message(str(e))
+
+    def _handle_delete_chat(self) -> str:
+        try:
+            name = self.io.get_input("Enter the chat name: ")
+            self.system.delete_chat(name)
+            return self.SUCCESS
+
+        except Exception as e:
+            self.io.display_message(str(e))
+
+    def _handle_list_philosophers(self) -> str:
+        try:
+            philosophers_list = self.system.list_philosophers()
+            self.io.display_philosophers_list(philosophers_list)
+
+        except Exception as e:
+            self.io.display_message(str(e))
+
+
+def main():
+    """Entry point for the philo-chat console script."""
+
+    load_dotenv()
+    base_url = os.getenv("BASE_URL")
+    api_key = os.getenv("OPENAI_API_KEY")
+    model_name = os.getenv("MODEL_NAME")
+
+    if not all([base_url, api_key, model_name]):
+        print("Missing environment variables. Create a .env file with:")
+        print("BASE_URL=your_url")
+        print("OPENAI_API_KEY=your_key")
+        print("MODEL_NAME=your_model")
+        sys.exit(1)
+
+    # Run the app
+    pcli = PhiloChatCLI(base_url, api_key, model_name)
+    pcli.run()
+
+
+if __name__ == "__main__":
+    main()

philo_chat-0.1.0/src/cli/console_io_handler.py

@@ -0,0 +1,18 @@
+class ConsoleIOHandler:
+    def display_message(self, message: str) -> None:
+        print(message)
+
+    def get_input(self, prompt: str) -> str:
+        return input(prompt)
+
+    def display_chat_message(self, message: str) -> None:
+        print("-" * 50)
+        print(message)
+
+    def display_philosophers_list(self, philosophers: list) -> None:
+        for i, philosopher in enumerate(philosophers, start=1):
+            print(f"{i}. {philosopher.name}")
+
+    def display_chats_list(self, chats: list) -> None:
+        for chat in chats:
+            print(f"{chat.name}\tPhilosopher-> {chat.philosopher.name}")

philo_chat-0.1.0/src/core/entities/chat.py

@@ -0,0 +1,42 @@
+from .message import Message
+from .philosopher import Philosopher
+from ..exceptions import BadRequestError
+from ..utils.prompt_loading import load_prompt
+
+
+class Chat:
+    def __init__(self, name: str, philosopher: Philosopher) -> None:
+        self.name = name
+        self.philosopher = philosopher
+        self.messages: list[Message] = []
+
+    def complete_chat(
+        self, input_text: str, username: str, name: str, age: str, chat_completer
+    ) -> tuple[Message, Message]:
+        cleaned_input = input_text.strip()
+
+        if not cleaned_input:
+            raise BadRequestError("Message cannot be empty")
+
+        if self._is_first_message():
+            prompt = load_prompt(cleaned_input, self.philosopher.name, name, age)
+            prompt_msg = Message("user", username, prompt)
+            self._add_message(prompt_msg)
+
+        user_msg = Message("user", username, cleaned_input)
+        self._add_message(user_msg)
+
+        response = chat_completer.complete_chat(self.messages)
+        ai_msg = Message("assistant", self.philosopher.name, response)
+        self._add_message(ai_msg)
+
+        return ai_msg, user_msg
+
+    def get_history(self) -> list[Message]:
+        return self.messages[1:]
+
+    def _add_message(self, new_msg: Message) -> None:
+        self.messages.append(new_msg)
+
+    def _is_first_message(self) -> bool:
+        return bool(not self.messages)

philo_chat-0.1.0/src/core/entities/chat_completer.py

@@ -0,0 +1,25 @@
+from openai import OpenAI
+
+from ..exceptions import LLMError
+from .message import Message
+
+
+class ChatCompleter:
+    def __init__(self, base_url: str, api_key: str, model_name: str) -> None:
+        self.client = OpenAI(base_url=base_url, api_key=api_key)
+        self.model_name = model_name
+
+    def complete_chat(self, messages: list[Message]) -> str:
+        try:
+            completion_messages = [self._msg_to_dict(msg) for msg in messages]
+
+            completion = self.client.chat.completions.create(
+                model=self.model_name, messages=completion_messages
+            )
+            return completion.choices[0].message.content.strip()
+
+        except Exception as e:
+            raise LLMError(f"Completion failed: {e}")
+
+    def _msg_to_dict(self, msg: Message) -> dict[str, str]:
+        return {"role": msg.role, "content": msg.content}

philo_chat-0.1.0/src/core/entities/message.py

@@ -0,0 +1,9 @@
+from datetime import datetime
+
+
+class Message:
+    def __init__(self, role: str, author: str, content: str) -> None:
+        self.author = author
+        self.role = role
+        self.content = content
+        self.time = datetime.now().strftime("%H:%M")

philo_chat-0.1.0/src/core/entities/philosopher.py

@@ -0,0 +1,4 @@
+class Philosopher:
+    def __init__(self, id: int, name: str) -> None:
+        self.id = id
+        self.name = name

philo_chat-0.1.0/src/core/entities/user.py

@@ -0,0 +1,63 @@
+from ..exceptions import BadRequestError, NotFoundError
+from .chat import Chat
+from .message import Message
+from .philosopher import Philosopher
+
+
+class User:
+    def __init__(self, username: str, password: str, name: str, age: int) -> None:
+        self.username = username
+        self.password = password
+        self.name = name
+        self.age = age
+        self.chats: dict[str, Chat] = {}
+        self.selected_chat: Chat | None = None
+
+    def new_chat(self, name: str, philosopher: Philosopher) -> None:
+        if self._find_chat(name):
+            raise BadRequestError("Chat already exists")
+
+        new_chat = Chat(name, philosopher)
+        self.chats[name] = new_chat
+
+    def select_chat(self, name: str) -> list[Message]:
+        chat = self._find_chat(name)
+
+        if not chat:
+            raise NotFoundError("Chat not found")
+
+        self.selected_chat = chat
+        return self.selected_chat.get_history()
+
+    def list_chats(self) -> list[Chat]:
+        if not self.chats:
+            raise NotFoundError("No chats found")
+
+        return list(self.chats.values())
+
+    def exit_chat(self) -> None:
+        if not self.selected_chat:
+            raise BadRequestError("No chats selected")
+
+        self.selected_chat = None
+
+    def delete_chat(self, name: str) -> None:
+        chat = self._find_chat(name)
+
+        if not chat:
+            raise NotFoundError("Chat not found")
+
+        if self.selected_chat == chat:
+            self.selected_chat = None
+        del self.chats[name]
+
+    def complete_chat(self, input_text: str, chat_completer) -> tuple[Message, Message]:
+        if not self.selected_chat:
+            raise BadRequestError("No chats selected")
+
+        return self.selected_chat.complete_chat(
+            input_text, self.username, self.name, self.age, chat_completer
+        )
+
+    def _find_chat(self, name: str) -> Chat | None:
+        return self.chats.get(name)

philo_chat-0.1.0/src/core/exceptions.py

@@ -0,0 +1,18 @@
+class PhiloChatError(Exception):
+    pass
+
+
+class BadRequestError(PhiloChatError):
+    pass
+
+
+class NotFoundError(PhiloChatError):
+    pass
+
+
+class PermissionDeniedError(PhiloChatError):
+    pass
+
+
+class LLMError(PhiloChatError):
+    pass

philo_chat-0.1.0/src/core/utils/prompt_loading.py

@@ -0,0 +1,25 @@
+from functools import lru_cache
+from pathlib import Path
+
+import yaml
+
+
+@lru_cache(maxsize=32)
+def _load_templates() -> dict[str, str]:
+    prompt_path = Path(__file__).parent.parent.parent / "data/prompt_template.yaml"
+    data = yaml.safe_load(prompt_path.read_text(encoding="utf-8"))
+    return data["prompt"]
+
+
+def load_prompt(
+    input_text: str, philosopher: str, user_name: str, user_age: int
+) -> dict[str, str]:
+    template_config = _load_templates()
+    format_args = {
+        "input_text": input_text,
+        "philosopher": philosopher,
+        "user_name": user_name,
+        "user_age": user_age,
+    }
+    template_config = template_config.format(**format_args)
+    return template_config

philo_chat-0.1.0/src/data/philosophers.json

@@ -0,0 +1,22 @@
+[
+    {
+        "id": 0,
+        "name": "Nietzsche"
+    },
+    {
+        "id": 1,
+        "name": "Schopenhauer"
+    },
+    {
+        "id": 2,
+        "name": "Marx"
+    },
+    {
+        "id": 3,
+        "name": "Machiavelli"
+    },
+    {
+        "id": 4,
+        "name": "Socrates"
+    }
+]

philo_chat-0.1.0/src/data/prompt_template.yaml

@@ -0,0 +1,20 @@
+prompt: |
+  You are {philosopher}. 
+  Always respond in the language of the user. Do not use any other language.
+  Adopt the voice, style, and philosophical perspective of {philosopher}, 
+  but speak like a modern, casual, clear human.
+  - Introduce yourself if user asked to.
+  - Speak only as {philosopher}, never as an AI or narrator.
+  - Keep answers concise, natural, and relatable.
+  - Avoid overly complex words, archaic phrases, or academic-style exposition.
+  - Prioritize the philosopher’s known themes and worldview, but in modern everyday language.
+  - Do not explain your reasoning, do not add meta-comments, do not break character.
+
+  Consider user info:
+  Name = {user_name}
+  Age = {user_age}
+  
+  {user_name} said:
+  {input_text}
+
+  {philosopher} replies:

philo_chat-0.1.0/src/philo_chat.py

@@ -0,0 +1,111 @@
+import json
+from pathlib import Path
+
+from .core.entities.chat import Chat
+from .core.entities.chat_completer import ChatCompleter
+from .core.entities.message import Message
+from .core.entities.philosopher import Philosopher
+from .core.entities.user import User
+from .core.exceptions import BadRequestError, NotFoundError, PermissionDeniedError
+
+
+class PhiloChat:
+    def __init__(self, base_url: str, api_key: str, model_name: str) -> None:
+        self.chat_completer = ChatCompleter(base_url, api_key, model_name)
+        self.users: dict[str, User] = {}
+        self.philosophers: dict[int, Philosopher] = self._load_philosophers()
+        self.logged_in_user: User | None = None
+
+    def signup(self, username: str, password: str, name: str, age: int) -> None:
+        if self.logged_in_user:
+            raise PermissionDeniedError("You are already logged in")
+        elif self._find_user(username):
+            raise BadRequestError(f"Username {username} already taken")
+
+        new_user = User(username, password, name, age)
+        self.users[username] = new_user
+
+    def login(self, username: str, password: str) -> None:
+        user = self._find_user(username)
+
+        if self.logged_in_user:
+            raise PermissionDeniedError("You've already logged in")
+        elif not user:
+            raise NotFoundError("Username not found")
+        elif user.password != password:
+            raise PermissionDeniedError("Wrong password")
+
+        self.logged_in_user = user
+
+    def logout(self) -> None:
+        if not self.logged_in_user:
+            raise PermissionDeniedError("No user is logged in")
+
+        self.logged_in_user = None
+
+    def delete_account(self) -> None:
+        if not self.logged_in_user:
+            raise PermissionDeniedError("No user is logged in")
+
+        del self.users[self.logged_in_user.username]
+        self.logout()
+
+    def new_chat(self, name: str, philosopher_id: int) -> None:
+        if not self.logged_in_user:
+            raise BadRequestError("No user is logged in")
+
+        philosopher = self._find_philosopher(philosopher_id)
+        return self.logged_in_user.new_chat(name, philosopher)
+
+    def select_chat(self, name: str) -> list[Message]:
+        if not self.logged_in_user:
+            raise BadRequestError("No user is logged in")
+
+        return self.logged_in_user.select_chat(name)
+
+    def list_chats(self) -> list[Chat]:
+        if not self.logged_in_user:
+            raise BadRequestError("No user is logged in")
+
+        return self.logged_in_user.list_chats()
+
+    def exit_chat(self) -> None:
+        if not self.logged_in_user:
+            raise BadRequestError("No user is logged in")
+
+        return self.logged_in_user.exit_chat()
+
+    def delete_chat(self, name: str) -> None:
+        if not self.logged_in_user:
+            raise BadRequestError("No user is logged in")
+
+        return self.logged_in_user.delete_chat(name)
+
+    def list_philosophers(self) -> list[Philosopher]:
+        if not self.philosophers:
+            raise NotFoundError("No philosopher found")
+
+        return list(self.philosophers.values())
+
+    def complete_chat(self, input_text: str) -> tuple[Message, Message]:
+        if not self.logged_in_user:
+            raise BadRequestError("No user is logged in")
+
+        return self.logged_in_user.complete_chat(input_text, self.chat_completer)
+
+    def _find_user(self, username: str) -> User | None:
+        return self.users.get(username)
+
+    def _find_philosopher(self, philosopher_id: int) -> Philosopher | None:
+        return self.philosophers.get(philosopher_id)
+
+    def _load_philosophers(self) -> dict[int, Philosopher]:
+        data_dir = Path(__file__).parent / "data/philosophers.json"
+
+        with open(data_dir, "r", encoding="utf-8") as f:
+            raw_philosophers = json.load(f)
+
+        philosophers = {}
+        for p in raw_philosophers:
+            philosophers[p["id"]] = Philosopher(p["id"], p["name"])
+        return philosophers