dandy 0.0.3__tar.gz

dandy-0.0.3/CHANGELOG.md

@@ -0,0 +1,30 @@
+# Changelog
+
+# v0.0.2
+
+### Features
+- LLM Service Retries
+- LLM Prompt Validation Retries
+- Single and Multiple Choice LLM Bots added into contributions
+- Custom Exceptions that are based on the DandyException
+- Much improved testing on base LLM service
+
+# v0.0.1
+
+### Features
+- LLM Service
+- LLM Prompts
+- Bot
+- LlmBot
+- Workflow
+
+# v0.0.0
+
+### Features
+- Initial Release
+
+### Changes
+- Initial Release
+
+### Fixes
+- Initial Release

dandy-0.0.3/LICENSE.md

@@ -0,0 +1,22 @@
+Copyright (c) 2024 Stratus Advanced Technologies and Contributors.
+
+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.

dandy-0.0.3/MANIFEST.in

@@ -0,0 +1,9 @@
+include README.md
+include LICENSE.md
+include CHANGELOG.md
+include CONTRIBUTORS.md
+recursive-include dandy *
+exclude *.db
+recursive-exclude tests
+recursive-exclude docs
+recursive-exclude .github

dandy-0.0.3/PKG-INFO

@@ -0,0 +1,21 @@
+Metadata-Version: 2.1
+Name: dandy
+Version: 0.0.3
+Summary: Intelligence Bot Framework
+Home-page: https://github.com/stratusadv/dandy
+Author: Nathan Johnson
+Author-email: info@stratusadv.com
+License: MIT
+Keywords: dandy,ai,llm,agent,prompt,gpt
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.11
+License-File: LICENSE.md
+
+Dandy is a framework for developing programmatic intelligent bots and workflows. It's opinionated, magical, and designed to be incredibly pythonic.

dandy-0.0.3/README.md

@@ -0,0 +1,11 @@
+<p align="center">
+  <img src="./docs/images/dandy_logo_512.png" alt="Dandy AI Framework">
+</p>
+
+## What
+
+Dandy is a framework for developing programmatic intelligent bots and workflows. It's opinionated, magical, and designed to be incredibly pythonic.
+
+## Why
+
+In the pursuit of delivering incredible outcomes to our client we felt we needed a framework that could handle the demands of the future when it comes to artificial intelligence.

dandy-0.0.3/dandy/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.0.3"

dandy-0.0.3/dandy/bot/__init__.py

@@ -0,0 +1,2 @@
+from .bot import Bot
+from .llm_bot import LlmBot

dandy-0.0.3/dandy/bot/bot.py

@@ -0,0 +1,8 @@
+from abc import ABC, abstractmethod
+from typing import Any
+
+from dandy.handler.handler import Handler
+
+
+class Bot(Handler, ABC):
+    ...

dandy-0.0.3/dandy/bot/exceptions.py

@@ -0,0 +1,2 @@
+class BotException(Exception):
+    pass

dandy-0.0.3/dandy/bot/llm_bot.py

@@ -0,0 +1,30 @@
+from abc import ABC
+from typing import Type
+
+from dandy.bot.bot import Bot
+from dandy.core.type_vars import ModelType
+from dandy.llm.config import LlmConfig
+from dandy.llm.prompt import Prompt
+
+
+class LlmBot(Bot, ABC):
+    role_prompt: Prompt
+    instructions_prompt: Prompt
+    llm_config: LlmConfig
+
+    @classmethod
+    def process_prompt_to_model_object(
+            cls,
+            prompt: Prompt,
+            model: Type[ModelType],
+    ) -> ModelType:
+
+        return cls.llm_config.service.process_prompt_to_model_object(
+            prompt=prompt,
+            model=model,
+            prefix_system_prompt=(
+                Prompt()
+                .prompt(cls.role_prompt)
+                .prompt(cls.instructions_prompt)
+            )
+        )

dandy-0.0.3/dandy/contrib/bots/__init__.py

@@ -0,0 +1 @@
+from dandy.contrib.bots.choice_llm_bot import SingleChoiceLlmBot, MultipleChoiceLlmBot

dandy-0.0.3/dandy/contrib/bots/choice_llm_bot.py

@@ -0,0 +1,148 @@
+from abc import ABC
+from enum import Enum
+from typing import Tuple, List, Union, overload, Type
+
+from pydantic import BaseModel
+
+from dandy.bot import LlmBot
+from dandy.bot.exceptions import BotException
+from dandy.llm.prompt import Prompt
+
+
+NO_CHOICE_FOUND_RESPONSE = 'no-choice-match-found'
+
+
+class SingleChoiceResponse(BaseModel):
+    selected_choice: str
+
+
+class MultipleChoiceResponse(BaseModel):
+    selected_choices: List[str]
+
+
+class _ChoiceLlmBot(LlmBot, ABC):
+    role_prompt = (
+        Prompt()
+        .text('You are an choice bot.')
+    )
+
+    @classmethod
+    def process(
+            cls,
+            user_input: str,
+            choices: Union[Type[Enum], List[str], Tuple[str]],
+            choice_response_model: Union[Type[SingleChoiceResponse], Type[MultipleChoiceResponse]]
+    ) -> Union[SingleChoiceResponse, MultipleChoiceResponse]:
+
+        prompt = (
+            Prompt()
+            .text('This is the user input:')
+            .text(user_input, triple_quote=True)
+            .text('These are the choices:')
+        )
+
+        if isinstance(choices, type) and issubclass(choices, Enum):
+            prompt.unordered_random_list([choice.value for choice in choices], triple_quote=True)
+        elif isinstance(choices, (list, tuple)):
+            prompt.unordered_random_list(choices, triple_quote=True)
+        else:
+            raise BotException('Choices must be an Enum, a list or a tuple.')
+
+        return cls.process_prompt_to_model_object(
+            prompt=prompt,
+            model=choice_response_model
+        )
+
+
+class _ChoiceOverloadMixin:
+    @classmethod
+    @overload
+    def process(
+            cls,
+            user_input: str,
+            choices: Union[List[str], Tuple[str]],
+            choice_response_model: Type[BaseModel]
+    ) -> Union[str, List[str], None]:
+        ...
+
+    @classmethod
+    @overload
+    def process(
+            cls,
+            user_input: str,
+            choices: Type[Enum],
+            choice_response_model: Type[BaseModel]
+    ) -> Union[Enum, List[Enum], None]:
+        ...
+
+    @classmethod
+    def process(
+            cls,
+            user_input: str,
+            choices: Union[Type[Enum], List[str], Tuple[str]],
+            **kwargs
+    ) -> Union[Enum, List[Enum], str, List[str], None]:
+        ...
+
+
+class SingleChoiceLlmBot(_ChoiceLlmBot, _ChoiceOverloadMixin):
+    instructions_prompt = (
+        Prompt()
+        .text('Your job is to identify the intent of the user input and match it to the provided choices.')
+        .text(f'If there is no good matches in the choices reply with value "{NO_CHOICE_FOUND_RESPONSE}".')
+    )
+
+    @classmethod
+    def process(
+            cls,
+            user_input: str,
+            choices: Union[Type[Enum], List[str], Tuple[str]],
+            **kwargs
+    ) -> Union[Enum, str, None]:
+
+        choice_response = super().process(
+            user_input=user_input,
+            choices=choices,
+            choice_response_model=SingleChoiceResponse,
+        )
+
+        selected_choice = choice_response.selected_choice
+        if selected_choice == NO_CHOICE_FOUND_RESPONSE:
+            return None
+        else:
+            if isinstance(choices, type) and issubclass(choices, Enum):
+                return choices(selected_choice)
+            else:
+                return selected_choice
+
+
+class MultipleChoiceLlmBot(_ChoiceLlmBot, _ChoiceOverloadMixin):
+    instructions_prompt = (
+        Prompt()
+        .text('Your job is to identify the intent of the user input and match it to the provided choices.')
+        .text('Return as many choices as you see relevant to the user input.')
+        .text(f'If there is no good matches in the choices reply with value "{NO_CHOICE_FOUND_RESPONSE}".')
+    )
+
+    @classmethod
+    def process(
+            cls,
+            user_input: str,
+            choices: Union[Type[Enum], List[str], Tuple[str]],
+            **kwargs
+    ) -> Union[List[Enum], List[str], None]:
+
+        choice_response = super().process(
+            user_input=user_input,
+            choices=choices,
+            choice_response_model=MultipleChoiceResponse
+        )
+
+        select_choices = choice_response.selected_choices
+        if NO_CHOICE_FOUND_RESPONSE in select_choices:
+            return None
+        else:
+            if isinstance(choices, type) and issubclass(choices, Enum):
+                return [choices(choice) for choice in select_choices]
+            else:
+                return select_choices

dandy-0.0.3/dandy/core/exceptions.py

@@ -0,0 +1,2 @@
+class DandyException(Exception):
+    pass

dandy-0.0.3/dandy/core/singleton.py

@@ -0,0 +1,7 @@
+class Singleton:
+    _instance = None
+
+    def __new__(cls, *args, **kwargs):
+        if cls._instance is None:
+            cls._instance = super(Singleton, cls).__new__(cls, *args, **kwargs)
+        return cls._instance

dandy-0.0.3/dandy/core/type_vars.py

@@ -0,0 +1,6 @@
+from typing import TypeVar
+
+from pydantic import BaseModel
+
+
+ModelType = TypeVar('ModelType', bound=BaseModel)

dandy-0.0.3/dandy/core/url.py

@@ -0,0 +1,38 @@
+from dataclasses import dataclass
+from typing import List, Dict
+from urllib.parse import urlencode, urlparse, ParseResult, quote
+
+
+@dataclass(kw_only=True)
+class Url:
+    host: str
+    path_parameters: List[str] = list
+    query_parameters: Dict[str, str] = dict
+
+
+    @property
+    def parsed_url(self) -> ParseResult:
+        return urlparse(self.host)
+
+    @property
+    def path(self) -> str:
+        return self.path_parameters_to_str + self.query_parameters_to_str
+
+    @property
+    def is_https(self) -> bool:
+        return self.parsed_url.scheme == 'https'
+
+    @property
+    def path_parameters_to_str(self) -> str:
+        if self.path_parameters:
+            return '/' + '/'.join([quote(parameter) for parameter in self.path_parameters])
+
+        return ''
+
+    @property
+    def query_parameters_to_str(self) -> str:
+        if self.query_parameters:
+            query = urlencode(self.query_parameters)
+            return '?' + query
+
+        return ''

dandy-0.0.3/dandy/handler/handler.py

@@ -0,0 +1,9 @@
+from abc import abstractmethod, ABC
+from typing import Any
+
+
+class Handler(ABC):
+    @classmethod
+    @abstractmethod
+    def process(cls, **kwargs: Any) -> Any:
+        ...

dandy-0.0.3/dandy/llm/config.py

@@ -0,0 +1,95 @@
+from abc import abstractmethod
+from typing import Optional, List
+
+from dandy.core.url import Url
+from dandy.llm.service import Service
+
+
+class LlmConfig:
+    def __init__(
+            self,
+            host: str,
+            port: int,
+            model: str,
+            path_parameters: Optional[List[str]] = None,
+            query_parameters: Optional[dict] = None,
+            headers: Optional[dict] = None,
+            api_key: Optional[str] = None,
+            retry_count: int = 10,
+    ):
+        if headers is None:
+            headers = {
+                "Content-Type": "application/json",
+                "Accept": "application/json",
+            }
+
+        if api_key is not None:
+            headers["Authorization"] = f"Bearer {api_key}"
+
+        self.url=Url(
+            host=host,
+            path_parameters=path_parameters,
+            query_parameters=query_parameters,
+        )
+        self.port=port
+        self.model=model
+        self.headers=headers
+
+        self.retry_count = retry_count
+
+    @property
+    def service(self):
+        return Service(self)
+
+    @abstractmethod
+    def get_response_content(self, response) -> str:
+        ...
+
+
+class OllamaLlmConfig(LlmConfig):
+    def __init__(
+            self,
+            host: str,
+            port: int,
+            model: str,
+            api_key: Optional[str] = None,
+    ):
+        super().__init__(
+            host=host,
+            port=port,
+            model=model,
+            path_parameters=[
+                'api',
+                'chat',
+            ],
+            api_key=api_key,
+        )
+
+    def get_response_content(self, response) -> str:
+        return response['message']['content']
+
+
+class OpenaiLlmConfig(LlmConfig):
+    def __init__(
+            self,
+            host: str,
+            port: int,
+            model: str,
+            api_key: Optional[str] = None,
+    ):
+        super().__init__(
+            host=host,
+            port=port,
+            model=model,
+            path_parameters=[
+                'v1',
+                'chat',
+                'completions',
+            ],
+            api_key=api_key,
+        )
+
+    def get_response_content(self, response) -> str:
+        return response['choices'][0]['message']['content']
+
+

dandy-0.0.3/dandy/llm/exceptions.py

@@ -0,0 +1,12 @@
+from typing import List
+
+from dandy.core.exceptions import DandyException
+
+
+class LlmException(DandyException):
+    pass
+
+
+class LlmValidationException(LlmException):
+    def __init__(self, name: str, choices: List[str]):
+        super().__init__(f'Did not get a valid response format from llm service')

dandy-0.0.3/dandy/llm/prompt/__init__.py

@@ -0,0 +1,2 @@
+from dandy.llm.prompt.prompt import Prompt
+from dandy.llm.prompt.snippet import Snippet