emilia 0.1.0__tar.gz

emilia-0.1.0/PKG-INFO

@@ -0,0 +1,7 @@
+Metadata-Version: 2.5
+Name: emilia
+Version: 0.1.0
+Requires-Dist: ddgs
+Requires-Dist: kopilogs
+Requires-Dist: ollama
+Requires-Dist: trafilatura

emilia-0.1.0/pyproject.toml

@@ -0,0 +1,22 @@
+[build-system]
+requires = [
+    "hatchling",
+]
+build-backend = "hatchling.build"
+
+[project]
+name = "emilia"
+version = "0.1.0"
+dependencies = [
+    "ollama",
+    "ddgs",
+    "kopilogs",
+    "trafilatura",
+]
+
+[project.scripts]
+emilia = "emilia.main:main"
+
+[tool.kuvy.run-paths]
+main = "src/emilia/main.py"
+tests = "tests/tests.py"

emilia-0.1.0/src/emilia/emilia.py

@@ -0,0 +1,89 @@
+from ollama import (
+    chat,
+    Message,
+    ChatResponse,
+)
+from kopilogs.paint import paint
+
+from typing import Sequence
+
+from emilia.tools import (
+    search_internet,
+    what_time_is_it,
+    testing,
+)
+from emilia.hardcoded import context
+
+class Emilia:
+    def __init__(self, model: str):
+        self.model = model
+        self.context = []
+        self._append_context("system", context)
+        self.tools = {
+            "search_internet": search_internet,
+            "testing": testing,
+            "what_time_is_it": what_time_is_it,
+        }
+
+    def talk(self) -> str:
+        while True:
+            request = input(paint(">>> ").bold().magenta())
+            self._append_context("user", request)
+
+            response = self._generate_content()
+            tool_calls = response.message.tool_calls
+            content = response.message.content
+            self._append_context("assistant", response.message)
+
+            if tool_calls is not None:
+                while True:
+                    response_tool = self._handle_tool_call(tool_calls)
+                    self._append_context("assistant", response_tool.message)
+
+                    if response_tool.message.tool_calls is None:
+                        content = response_tool.message.content
+                        break
+
+                    tool_calls = response_tool.message.tool_calls
+
+            print()
+            paint(">>> ", end="").bold().green().show()
+            print(content)
+            print()
+
+    def _handle_tool_call(self, tool_calls: Sequence) -> ChatResponse:
+        for tc in tool_calls:
+            result = self.tools[tc.function.name](**tc.function.arguments)
+            self._append_context("tool", result, tool_call=tc.function.name)
+
+        return self._generate_content()
+
+    def _generate_content(self) -> ChatResponse:
+        return chat(
+            model=self.model,
+            messages=self.context,
+            tools=list(self.tools.values()),
+        )
+
+    def _append_context(
+        self,
+        role: str,
+        content: str | Message,
+        tool_call: str | None = None,
+    ):
+        if type(content) == Message:
+            self.context.append(content)
+            return
+
+        if role == "tool" and tool_call is not None:
+            self.context.append({
+                "role": role,
+                "tool_name": tool_call,
+                "content": content,
+            })
+            return
+
+        self.context.append({
+            "role": role,
+            "content": content,
+        })

emilia-0.1.0/src/emilia/hardcoded.py

@@ -0,0 +1,18 @@
+import datetime
+
+context = f"""
+Today is {datetime.datetime.now()}
+
+You are Emilia and you assist Peter
+
+You have several tools to facilitate your assisting process:
+
+    1. search_internet
+    2. what_time_is_it
+
+1. Use this tool when Peter needs up-to-date accurate information about something, you have to generate a single search request based on Peter's initial question, then, pass the search request to "search_internet" and wait for the results.
+
+After getting the results, you provide Peter with a detailed message explaining what you got.
+
+2. Use tool whenever you or Peter needs to know what time it is right in the moment.
+"""

emilia-0.1.0/src/emilia/main.py

@@ -0,0 +1,11 @@
+from emilia.emilia import Emilia
+import sys
+
+def main() -> int:
+    emilia = Emilia("qwen3")
+    emilia.talk()
+
+    return 0
+
+if __name__ == "__main__":
+    sys.exit(main())

emilia-0.1.0/src/emilia/tools.py

@@ -0,0 +1,87 @@
+from ddgs import DDGS
+from ddgs.exceptions import DDGSException
+from trafilatura import (
+    fetch_url,
+    extract,
+)
+
+from kopilogs.paint import paint
+
+from concurrent.futures import ThreadPoolExecutor
+import sys 
+import textwrap
+import datetime
+
+def what_time_is_it() -> str:
+    """
+    Use this tool whenever you want to know what time it is right now.
+
+    Args:
+        None
+
+    Returns:
+        str -> Formatted string containing the exact datetime
+    """
+    paint(f"Getting datetime...").bold().magenta().show()
+
+    return datetime.datetime.now().strftime(r"%Y/%m/%d -- %H:%M:%S")
+
+def search_internet(search_query: str) -> str:
+    """
+    Use this tool when Peter need up-to-date accurate facts about something.
+
+    Args:
+        str -> Search query
+
+    Returns:
+        str -> Formatted str containing webpages: [title, href, information]
+
+    Use the information retrieved to answer Peter
+    """
+    paint(f"Searching the internet... {search_query}").bold().magenta().show()
+
+    def fetch(result: dict[str, str]) -> str | None:
+        extracted = extract(fetch_url(result["href"]))
+        return extracted
+
+    results = list(DDGS().text(search_query, max_results=3))
+    with ThreadPoolExecutor() as exec:
+        threads = []
+
+        for result in results:
+            thread = exec.submit(fetch, result)
+            threads.append(thread)
+
+    formatted_results = ""
+    for i, thread in enumerate(threads):
+        try:
+            result = thread.result()
+        except Exception:
+            continue
+
+        if result is not None:
+            formatted_results += textwrap.dedent(
+                f"""
+
+                RESULT {i}
+
+                {result[:5000]}
+
+                """
+            )
+
+    paint("Done.").bold().green().show()
+    return formatted_results
+
+def testing() -> None:
+    """
+    This is a testing tool, only execute this when commanded
+
+    Args:
+        None
+
+    Returns:
+        None
+    """
+
+    print("Executed testing tool!")

emilia-0.1.0/tests/tests.py

@@ -0,0 +1,3 @@
+import datetime
+
+print(datetime.datetime.now())