django-spire 0.16.11__py3-none-any.whl → 0.16.13__py3-none-any.whl

django_spire/ai/prompt/bots.py

@@ -1,44 +1,26 @@
-from pathlib import Path
+from __future__ import annotations
 
-from dandy.llm import BaseLlmBot
-from django.conf import settings
+from dandy import Bot
 
 from django_spire.ai.prompt import prompts
 from django_spire.ai.prompt import intel
 
 
+class DandyPythonPromptBot(Bot):
+    llm_role = prompts.dandy_prompt_python_file_instruction_bot_prompt()
 
-class DandyPythonPromptBot(BaseLlmBot):
-    instructions_prompt = prompts.dandy_prompt_python_file_instruction_bot_prompt()
-    intel_class = intel.DandyPromptPythonFileIntel
-
-    @classmethod
-    def process(
-            cls,
-            prompt: str,
-
-    ) -> intel.DandyPromptPythonFileIntel:
-        """
-            Takes in an enhanced prompt and turn it into a python file that uses the dandy library.
-        """
-        return cls.process_prompt_to_intel(
-            prompt=prompts.dandy_prompt_python_file_input_prompt(prompt)
+    def process(self, prompt: str) -> intel.DandyPromptPythonFileIntel:
+        return self.llm.prompt_to_intel(
+            prompt=prompts.dandy_prompt_python_file_input_prompt(prompt),
+            intel_class=intel.DandyPromptPythonFileIntel
         )
 
 
-class TextToMarkdownPromptBot(BaseLlmBot):
-    instructions_prompt = prompts.text_to_markdown_instruction_bot_prompt()
-    intel_class = intel.TextToMarkdownIntel
-
-    @classmethod
-    def process(
-            cls,
-            text: str,
+class TextToMarkdownPromptBot(Bot):
+    llm_role = prompts.text_to_markdown_instruction_bot_prompt()
 
-    ) -> intel.TextToMarkdownIntel:
-        """
-            Takes in user text and converts it to properly formatted Markdown.
-        """
-        return cls.process_prompt_to_intel(
-            prompt=prompts.text_to_markdown_input_prompt(text)
+    def process(self, text: str) -> intel.TextToMarkdownIntel:
+        return self.llm.prompt_to_intel(
+            prompt=prompts.text_to_markdown_input_prompt(text),
+            intel_class=intel.TextToMarkdownIntel
         )

django_spire/ai/prompt/intel.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 from pathlib import Path
 
-from dandy.intel import BaseIntel
+from dandy import BaseIntel
 from django.conf import settings
 
 _MARKDOWN_OUTPUT_PATH = Path(settings.BASE_DIR, '.markdown')

django_spire/ai/prompt/prompts.py

@@ -1,12 +1,15 @@
+from __future__ import annotations
+
 from pathlib import Path
 
-from dandy.llm import Prompt
+from dandy import Prompt
 
 
 _RELATIVE_BASE_DIR = Path(Path(__file__).parent.parent.parent.parent.resolve())
 dandy_prompting_path = Path(_RELATIVE_BASE_DIR, '.venv/Lib/site-packages/dandy/llm/prompt/prompt.py')
 dandy_tutorial_path = Path(_RELATIVE_BASE_DIR, 'django_spire/ai/prompt/docs/prompt_tutorial.md')
 
+
 def dandy_prompt_python_file_instruction_bot_prompt():
     return (
         Prompt()
@@ -37,6 +40,7 @@ def dandy_prompt_python_file_instruction_bot_prompt():
         .file(dandy_prompting_path)
     )
 
+
 def text_to_markdown_instruction_bot_prompt():
     return (
         Prompt()
@@ -67,6 +71,7 @@ def text_to_markdown_instruction_bot_prompt():
         .text('Return the converted Markdown content and a suitable filename with .md extension.')
     )
 
+
 def dandy_prompt_python_file_input_prompt(user_prompt: str):
     return (
         Prompt()
@@ -74,6 +79,7 @@ def dandy_prompt_python_file_input_prompt(user_prompt: str):
         .text(user_prompt)
     )
 
+
 def text_to_markdown_input_prompt(user_text: str):
     return (
         Prompt()

django_spire/ai/prompt/system/bots.py

@@ -1,102 +1,69 @@
-from dandy.llm import BaseLlmBot, LlmConfigOptions
+from __future__ import annotations
+
+from dandy import Bot, LlmConfigOptions
 
 from django_spire.ai.prompt.system import prompts
 from django_spire.ai.prompt.system import intel
 from django_spire.ai.prompt.system.intel import SystemPromptIntel
 
 
-class RoleSystemPromptBot(BaseLlmBot):
-    instructions_prompt = prompts.role_bot_prompt()
-    intel_class = intel.SystemPromptResultIntel
-    config_options = LlmConfigOptions(
-        temperature=0.5
-    )
-
-    @classmethod
-    def process(
-            cls,
-            user_story: str
-
-    ) -> intel.SystemPromptResultIntel:
+class RoleSystemPromptBot(Bot):
+    llm_role = prompts.role_bot_prompt()
+    llm_config_options = LlmConfigOptions(temperature=0.5)
 
-        return cls.process_prompt_to_intel(
-            prompt=prompts.system_user_input_prompt(user_story)
+    def process(self, user_story: str) -> intel.SystemPromptResultIntel:
+        return self.llm.prompt_to_intel(
+            prompt=prompts.system_user_input_prompt(user_story),
+            intel_class=intel.SystemPromptResultIntel
         )
 
 
-class TaskSystemPromptBot(BaseLlmBot):
-    instructions_prompt = prompts.task_bot_prompt()
-    intel_class = intel.SystemPromptResultIntel
-    config_options = LlmConfigOptions(
-        temperature=0.5
-    )
+class TaskSystemPromptBot(Bot):
+    llm_role = prompts.task_bot_prompt()
+    llm_config_options = LlmConfigOptions(temperature=0.5)
 
-    @classmethod
-    def process(
-            cls,
-            user_story: str
-
-    ) -> intel.SystemPromptResultIntel:
-
-        return cls.process_prompt_to_intel(
-            prompt=prompts.system_user_input_prompt(user_story)
+    def process(self, user_story: str) -> intel.SystemPromptResultIntel:
+        return self.llm.prompt_to_intel(
+            prompt=prompts.system_user_input_prompt(user_story),
+            intel_class=intel.SystemPromptResultIntel
         )
 
 
-class GuidelinesSystemPromptBot(BaseLlmBot):
-    instructions_prompt = prompts.guidelines_bot_prompt()
-    intel_class = intel.SystemPromptResultIntel
-    config_options = LlmConfigOptions(
-        temperature=0.2
-    )
-
-    @classmethod
-    def process(
-            cls,
-            user_story: str
+class GuidelinesSystemPromptBot(Bot):
+    llm_role = prompts.guidelines_bot_prompt()
+    llm_config_options = LlmConfigOptions(temperature=0.2)
 
-    ) -> intel.SystemPromptResultIntel:
-
-        return cls.process_prompt_to_intel(
-            prompt=prompts.system_user_input_prompt(user_story)
+    def process(self, user_story: str) -> intel.SystemPromptResultIntel:
+        return self.llm.prompt_to_intel(
+            prompt=prompts.system_user_input_prompt(user_story),
+            intel_class=intel.SystemPromptResultIntel
         )
 
 
-class OutputFormatSystemPromptBot(BaseLlmBot):
-    instructions_prompt = prompts.output_format_bot_prompt()
-    intel_class = intel.SystemPromptResultIntel
-    config_options = LlmConfigOptions(
-        temperature=0.5
-    )
-
-    @classmethod
-    def process(
-            cls,
-            user_story: str
-
-    ) -> intel.SystemPromptResultIntel:
+class OutputFormatSystemPromptBot(Bot):
+    llm_role = prompts.output_format_bot_prompt()
+    llm_config_options = LlmConfigOptions(temperature=0.5)
 
-        return cls.process_prompt_to_intel(
-            prompt=prompts.system_user_input_prompt(user_story)
+    def process(self, user_story: str) -> intel.SystemPromptResultIntel:
+        return self.llm.prompt_to_intel(
+            prompt=prompts.system_user_input_prompt(user_story),
+            intel_class=intel.SystemPromptResultIntel
         )
 
 
-class SystemPromptBot(BaseLlmBot):
-    instructions_prompt = prompts.system_prompt_instruction_bot_prompt()
-    intel_class = intel.SystemPromptIntel
-
-
-    @classmethod
-    def process(
-            cls,
-            user_story: str
+class SystemPromptBot(Bot):
+    llm_role = prompts.system_prompt_instruction_bot_prompt()
 
-    ) -> intel.SystemPromptIntel:
+    def process(self, user_story: str) -> intel.SystemPromptIntel:
+        role_bot = RoleSystemPromptBot()
+        task_bot = TaskSystemPromptBot()
+        guidelines_bot = GuidelinesSystemPromptBot()
+        output_format_bot = OutputFormatSystemPromptBot()
 
-        role_future = RoleSystemPromptBot.process_to_future(user_story)
-        task_future = TaskSystemPromptBot.process_to_future(user_story)
-        guidelines_future = GuidelinesSystemPromptBot.process_to_future(user_story)
-        output_format_future = OutputFormatSystemPromptBot.process_to_future(user_story)
+        role_future = role_bot.process_to_future(user_story)
+        task_future = task_bot.process_to_future(user_story)
+        guidelines_future = guidelines_bot.process_to_future(user_story)
+        output_format_future = output_format_bot.process_to_future(user_story)
 
         role = role_future.result
         task = task_future.result

django_spire/ai/prompt/system/intel.py

@@ -1,9 +1,8 @@
 from __future__ import annotations
 
-from dandy.intel import BaseIntel
+from dandy import BaseIntel
 
 from django_spire.ai.prompt.bots import DandyPythonPromptBot, TextToMarkdownPromptBot
-from django_spire.knowledge.entry.version.intelligence.bots.markdown_format_llm_bot import MarkdownFormatLlmBot
 
 
 class SystemPromptResultIntel(BaseIntel):
@@ -17,10 +16,12 @@ class SystemPromptIntel(BaseIntel):
     output_format: str | None
 
     def to_markdown(self):
-        return TextToMarkdownPromptBot.process(self.to_string())
+        bot = TextToMarkdownPromptBot()
+        return bot.process(self.to_string())
 
     def to_python(self):
-        return DandyPythonPromptBot.process(self.to_string())
+        bot = DandyPythonPromptBot()
+        return bot.process(self.to_string())
 
     def to_string(self):
         prompt = (

django_spire/ai/prompt/system/prompts.py

@@ -1,4 +1,7 @@
-from dandy.llm import Prompt
+from __future__ import annotations
+
+from dandy import Prompt
+
 
 def role_bot_prompt():
     return (
@@ -142,6 +145,7 @@ def system_prompt_instruction_bot_prompt():
         .text('Your response should be a complete system prompt that addresses the user\'s specific needs, ensuring it is structured as a system prompt for an LLM interaction. Extract the relevant information from the user\'s input to create this system prompt.')
     )
 
+
 def system_user_input_prompt(user_input: str):
     return (
         Prompt()

django_spire/ai/prompt/system/system_prompt_cli.py

@@ -1,16 +1,23 @@
-from django_spire.ai.prompt.tuning.bots import SimplePromptTuningBot
-from dandy.recorder import Recorder
+from __future__ import annotations
+
+from dandy import Recorder
 
 from django_spire.ai.prompt.bots import DandyPythonPromptBot
 from django_spire.ai.prompt.system import bots
+from django_spire.ai.prompt.tuning.bots import SimplePromptTuningBot
+
 
-def create_system_prompt_cli():
+def create_system_prompt_cli() -> None:
     Recorder.start_recording(recording_name='system_prompt')
 
     user_story = input('Enter your user story: ')
-    prompt = bots.SystemPromptBot.process(user_story)
+
+    bot = bots.SystemPromptBot()
+    prompt = bot.process(user_story)
     print(prompt)
 
+    tuning_bot = SimplePromptTuningBot()
+
     while True:
         print("\nEnter your feedback (or type 'stop' to finish):")
         feedback = input()
@@ -19,10 +26,7 @@ def create_system_prompt_cli():
             break
 
         print('Creating new prompt from feedback.....')
-        new_prompt = (
-            SimplePromptTuningBot()
-            .process(prompt, feedback)
-        )
+        new_prompt = tuning_bot.process(prompt, feedback)
         print('----------------------------------------------------')
         print()
         print(new_prompt.prompt)
@@ -33,5 +37,7 @@ def create_system_prompt_cli():
     Recorder.to_html_file(recording_name='system_prompt')
 
     prompt_file = input('Do you want to create a Prompt File y/n?')
+
     if prompt_file.strip().lower() == 'y':
-        DandyPythonPromptBot().process(prompt)
+        python_bot = DandyPythonPromptBot()
+        python_bot.process(prompt)

django_spire/ai/prompt/tests/test_bots.py

@@ -1,9 +1,10 @@
+from __future__ import annotations
+
 from django_spire.ai.prompt.system import bots
 from django_spire.core.tests.test_cases import BaseTestCase
 
 
 class PromptBotTestCase(BaseTestCase):
-
     def test_system_prompt_system_prompt(self):
         ISSUE_PROMPT = (
             "I am using jira to plan developer workloads And I want to be able to build very clear issues  that"
@@ -13,16 +14,18 @@ class PromptBotTestCase(BaseTestCase):
             "before they get into the details of it "
         )
 
-        role_bot = bots.RoleSystemPromptBot.process(ISSUE_PROMPT)
-        self.assertIsNotNone(role_bot)
-
-        task_bot = bots.TaskSystemPromptBot.process(ISSUE_PROMPT)
-        self.assertIsNotNone(task_bot)
+        role_bot = bots.RoleSystemPromptBot()
+        role_result = role_bot.process(ISSUE_PROMPT)
+        self.assertIsNotNone(role_result)
 
+        task_bot = bots.TaskSystemPromptBot()
+        task_result = task_bot.process(ISSUE_PROMPT)
+        self.assertIsNotNone(task_result)
 
-        guidelines_bot = bots.GuidelinesSystemPromptBot.process(ISSUE_PROMPT)
-        self.assertIsNotNone(guidelines_bot)
+        guidelines_bot = bots.GuidelinesSystemPromptBot()
+        guidelines_result = guidelines_bot.process(ISSUE_PROMPT)
+        self.assertIsNotNone(guidelines_result)
 
-        output_format_bot = bots.OutputFormatSystemPromptBot.process(ISSUE_PROMPT)
-        self.assertIsNotNone(output_format_bot)
-                
+        output_format_bot = bots.OutputFormatSystemPromptBot()
+        output_format_result = output_format_bot.process(ISSUE_PROMPT)
+        self.assertIsNotNone(output_format_result)

django_spire/ai/prompt/text_to_prompt_cli.py

@@ -1,5 +1,8 @@
+from __future__ import annotations
+
 from django_spire.ai.prompt.bots import DandyPythonPromptBot
 
+
 def text_to_prompt_cli(prompt: str):
-    prompt = prompt
-    DandyPythonPromptBot().process(prompt)
+    bot = DandyPythonPromptBot()
+    bot.process(prompt)

django_spire/ai/prompt/tuning/bot_tuning_cli.py

@@ -1,22 +1,24 @@
-from typing import Type
+from __future__ import annotations
 
-from dandy.llm import BaseLlmBot, Prompt
-from dandy.recorder import Recorder
+from dandy import Bot, Prompt, Recorder
 
 from django_spire.ai.prompt.bots import DandyPythonPromptBot
 from django_spire.ai.prompt.tuning.bots import SimplePromptTuningBot
 
 
-def bot_tuning_cli(bot: Type[BaseLlmBot], **bot_parmas):
+def bot_tuning_cli(bot_class: type[Bot], **bot_params):
     Recorder.start_recording(recording_name='prompt_tuning')
 
-    tuned_prompt = bot.instructions_prompt
+    bot = bot_class()
+    tuned_prompt = bot.llm_role
     print(tuned_prompt)
-    bot_tuning = bot.process(**bot_parmas)
+    bot_tuning = bot.process(**bot_params)
     print(bot_tuning)
 
     print('----------------------------------------------------')
 
+    tuning_bot = SimplePromptTuningBot()
+
     while True:
         print("\nEnter your feedback (or type 'stop' to finish):")
         feedback = input()
@@ -26,10 +28,7 @@ def bot_tuning_cli(bot: Type[BaseLlmBot], **bot_parmas):
 
         print('Attempting to tune prompt.....')
 
-        new_prompt = (
-            SimplePromptTuningBot()
-            .process(tuned_prompt, feedback)
-        )
+        new_prompt = tuning_bot.process(tuned_prompt, feedback)
 
         print('----------------------NEW PROMPT START------------------------------')
         print()
@@ -38,8 +37,8 @@ def bot_tuning_cli(bot: Type[BaseLlmBot], **bot_parmas):
         print('----------------------NEW PROMPT END------------------------------')
         print()
         print('----------------------BOT TUNING START------------------------------')
-        bot.instructions_prompt = Prompt().text(new_prompt.prompt)
-        bot_tuning = bot.process(**bot_parmas)
+        bot.llm_role = Prompt().text(new_prompt.prompt)
+        bot_tuning = bot.process(**bot_params)
         print(bot_tuning)
         print('----------------------BOT TUNING END------------------------------')
 
@@ -51,5 +50,7 @@ def bot_tuning_cli(bot: Type[BaseLlmBot], **bot_parmas):
     Recorder.to_html_file(recording_name='prompt_tuning')
 
     output_prompt = input('Do you want to output the final prompt y/n?')
+
     if output_prompt.strip().lower() == 'y':
-        DandyPythonPromptBot().process(tuned_prompt)
+        python_bot = DandyPythonPromptBot()
+        python_bot.process(tuned_prompt)