Merge branch 'release/1.3.0' into main

Author: dotchetter

CHANGELOG.md

@@ -1,5 +1,83 @@
 # Pyttman Changelog
 
+# V 1.3.0
+In this release, we're introducing some cool new features along with 
+some bug fixes.
+The star of the show this time is the test suite class for improved
+testability of Pyttman applications.
+
+### :star2: News
+* **Test suite class for developing tests**
+
+  A new Test suite class has been developed for use in Pyttman apps, for
+  making it easier to write unit test for Pyttman applications. The test automatically
+  loads the app context for the app in which the tests are created in.
+
+  ```python
+  from pyttman.testing import PyttmanTestCase
+  
+  class TestUserSynchronizer(PyttmanTestCase):
+
+    def setUp(self) -> None:
+        # This setup hook works as with any TestCase class.        
+        # You have access to your pyttman app just as if the app was running.
+        app = self.app
+  
+    def test_some_func(self):
+        self.fail()  
+  ```
+
+* **New EntityField class for Decimal type**
+
+  For finance and other domains, the floating point precision
+  `float` isn't high enough. An industry standard is the `Decimal` type 
+  and it's now supported in the `EntityField` ecosystem in Pyttman. 
+  
+  ```python
+  
+  class EnterIncome(Intent):
+    income = DecimalEntityField()
+  ```
+
+* **New mode in Pyttman CLI: `runfile` - Run single scripts with Pyttman**
+
+  Some times a single script does the job, or the app you've developed 
+  isn't designed to be conversational. For these situations, the new 
+  PyttmanCLI command `runfile` is perfect. It will invoke a Python file 
+  with the app loaded, providing you all the benefits of using Pyttman 
+  without having to develop your app with a conversational approach.
+  
+  ```python
+  # someapp/script.py
+  
+  from pyttman import app
+  
+  if __name__ == "__main__":
+    print(f"Hello! I'm using {app.name} as context.")
+  
+  ```
+  Running the file above with PyttmanCLI:
+  ```python  
+  $ pyttman runfile pyttman_app_name script.py
+    
+  > Hello! I'm using pyttman_app_name as context.
+  ```
+  
+* **New mode in Pyttman CLI: `-V` - See the version you're at**
+   
+  This mode is quite simple. It returns the version of the installed
+  the version of the installation of Pyttman.
+  
+  ```python
+  pyttman -V
+  1.3.0
+  ```
+
+### **🐛 Splatted bugs and corrected issues** 
+* **Fixes problem where words with special characters where ignored in entities**
+    
+
+
 
 # V 1.2.1.1
 This is a hotfix release, addressing an issue with the integration with discord.py 2.0 API

pyttman/clients/base.py

@@ -24,11 +24,10 @@ def __repr__(self):
         return f"{self.name}({vars(self)})"
 
     @abc.abstractmethod
-    def run_client(self):
+    def run_client(self, *args, **kwargs) -> None:
         """
         Starts the main method for the client, opening
         a session to the front end with which it is
         associated with.
-        :return: None
         """
         pass

pyttman/clients/builtin/script_client.py

@@ -0,0 +1,38 @@
+import sys
+
+import pyttman
+from pyttman.clients.base import BaseClient
+from pyttman.core.containers import Message, Reply, \
+    ReplyStream
+
+
+class ScriptClient(BaseClient):
+    """
+    The ScriptClient runs a single file within a Pyttman app
+    context.
+    This client is suitable for applications which don't have
+    a program loop, but are designed to be executed as a script
+    to run once.
+    """
+    def run_client(self, *args, **kwargs):
+        print(f"\nPyttman v.{pyttman.__version__} - "
+              f"Script client", end="\n")
+        try:
+            print(f"{pyttman.settings.APP_NAME} is online! Start chatting"
+                  f" with your app below."
+                  "\n(?) Use Ctrl-Z or Ctrl-C plus Return to exit",
+                  end="\n\n")
+            while True:
+                message = Message(input("[YOU]: "), client=self)
+                reply: Reply | ReplyStream = self.\
+                    message_router.get_reply(message)
+
+                if isinstance(reply, ReplyStream):
+                    while reply.qsize():
+                        print(f"[{pyttman.settings.APP_NAME.upper()}]: ",
+                              reply.get().as_str())
+                elif isinstance(reply, Reply):
+                    print(f"{pyttman.settings.APP_NAME}:", reply.as_str())
+                print()
+        except (KeyboardInterrupt, EOFError):
+            sys.exit(0)

pyttman/core/entity_parsing/fields.py

@@ -1,4 +1,5 @@
 import inspect
+from decimal import Decimal
 from abc import ABC
 from typing import Any, Sequence, Type
 
@@ -169,6 +170,16 @@ def parse_message(self,
             self.value = Entity(value=True)
 
 
+class DecimalEntityField(FloatEntityField):
+    """
+    Converts floating point numbers to Decimal. Useful
+    when dealing with currencies or in other areas where
+    decimal precision is not trivial.
+    """
+    type_cls = Decimal
+    default = Decimal(0)
+
+
 if __name__ != "__main__":
     StringEntityField = TextEntityField
     StrEntityField = TextEntityField

pyttman/core/entity_parsing/parsers.py

@@ -250,11 +250,11 @@ def _identify_value(self, message: MessageMixin,
         suffix_entity = None
         prefixes = []
         suffixes = []
-        prefix_indexes = []
-        suffix_indexes = []
+        prefix_indices = []
+        suffix_incides = []
         last_prefix_index, earliest_suffix_index = 0, 0
         parsed_entity: Union[Entity, None] = None
-        sanitized_msg_content = message.sanitized_content(preserve_case=False)
+        lowered_msg_content = message.lowered_content()
 
         # First - traverse over the pre- and suffixes and
         # collect them in separate lists
@@ -276,19 +276,19 @@ def _identify_value(self, message: MessageMixin,
             try:
                 # Save the index of this prefix in the message
                 if prefix is not None:
-                    prefix_indexes.append(sanitized_msg_content.index(prefix))
+                    prefix_indices.append(lowered_msg_content.index(prefix))
                 if suffix is not None:
-                    suffix_indexes.append(sanitized_msg_content.index(suffix))
+                    suffix_incides.append(lowered_msg_content.index(suffix))
             except ValueError:
                 # The prefix was not in the message
                 continue
 
         # Let's extract the last occurring prefix,
         # and the earliest suffix of the ones present
         if len(prefixes):
-            if not len(prefix_indexes):
+            if not len(prefix_indices):
                 return None
-            last_prefix_index = max(prefix_indexes)
+            last_prefix_index = max(prefix_indices)
             try:
                 index_for_value = last_prefix_index + 1
                 value_at_index = message.content[index_for_value]
@@ -299,10 +299,10 @@ def _identify_value(self, message: MessageMixin,
             start_index = last_prefix_index + 1
 
         if len(suffixes):
-            if not len(suffix_indexes):
+            if not len(suffix_incides):
                 return None
 
-            earliest_suffix_index = min(suffix_indexes)
+            earliest_suffix_index = min(suffix_incides)
             try:
                 index_for_value = earliest_suffix_index - 1
                 value_at_index = message.content[index_for_value]

pyttman/core/middleware/routing.py

@@ -2,14 +2,14 @@
 import random
 import warnings
 from copy import copy
-from typing import List, Any
+from typing import List, Any, Iterable
 
 import pyttman
+from pyttman.core.exceptions import PyttmanProjectInvalidException
 from pyttman.core.entity_parsing.parsers import parse_entities
 from pyttman.core.ability import Ability
 from pyttman.core.intent import Intent
-from pyttman.core.containers import MessageMixin, \
-    Reply, ReplyStream, Message
+from pyttman.core.containers import MessageMixin, Reply, ReplyStream, Message
 from pyttman.core.internals import _generate_error_entry
 
 
@@ -112,6 +112,19 @@ def process(message: Message,
             if keep_alive_on_exc is False:
                 raise e
 
+        original_reply = copy(reply)
+        try:
+            if not any((isinstance(reply, Reply), isinstance(reply, ReplyStream))):
+                if isinstance(reply, Iterable) and not isinstance(reply, str):
+                    reply = Reply(reply)
+                else:
+                    reply = ReplyStream(reply)
+        except Exception:
+            raise PyttmanProjectInvalidException(
+                f"Could not return reply from intent '{intent}' due to "
+                f"a misconfiguration of the response type. '{intent.respond}' "
+                f"returned: '{original_reply}'")
+
         constraints = {
             bool(reply is not None),
             bool(isinstance(reply, Reply) or isinstance(reply, ReplyStream))

pyttman/testing/__init__.py

@@ -0,0 +1,3 @@
+
+
+from pyttman.testing.pyttman_test_case import PyttmanTestCase

pyttman/testing/pyttman_test_case.py

@@ -0,0 +1,66 @@
+import traceback
+from pathlib import Path
+from unittest import TestCase
+
+from pyttman.core.decorators import LifeCycleHookType
+from pyttman.core.exceptions import PyttmanProjectInvalidException
+from pyttman.tools.pyttmancli import bootstrap_app
+
+
+class PyttmanTestCase(TestCase):
+    devmode = False
+    application_abspath = None
+    app_name = None
+    override_devmode_warning = False
+
+    def __init__(self, *args, **kwargs):
+        if self.application_abspath is None:
+            self.application_abspath = self.find_app_path()
+        if self.app_name is None:
+            self.app_name = self.application_abspath.name
+
+        try:
+            self.app = bootstrap_app(
+                devmode=self.devmode,
+                module=self.app_name,
+                application_abspath=self.application_abspath.parent)
+        except Exception as e:
+            print(traceback.format_exc())
+            raise PyttmanProjectInvalidException(
+                "\n\nPyttman could not boostrap the application for "
+                "testing. Full traceback above"
+            ) from e
+
+        super().__init__(*args, **kwargs)
+        if not any((self.devmode, self.app.settings.DEV_MODE, self.override_devmode_warning)):
+            raise Warning("Warning! This test class does not declare 'devmode' as a "
+                          "True, and 'DEV_MODE' in settings.py for "
+                          "this app is False. This could potentially lead to "
+                          "a test executing to production environment. "
+                          "To override this warning, set 'override_devmode_warning = True' "
+                          "as a class variable in this unit test.")
+        self.app.settings.DEV_MODE = self.devmode
+        self.app.hooks.trigger(LifeCycleHookType.before_start)
+
+    @staticmethod
+    def find_app_path(start_dir: Path = None) -> Path:
+        """
+        Look for signature catalog which looks like a
+        Pyttman app root directory.
+
+        Walk up the file structure until the directory is found.
+        :raise ModuleNotFoundError: The file hierarchy was exhausted
+        and no pyttman app directory wasn't found
+        """
+        sought_file = "settings.py"
+        start_dir = start_dir or Path.cwd()
+        next_dir = start_dir
+        while not next_dir.joinpath(sought_file).exists():
+            if next_dir.parent == start_dir:
+                raise ModuleNotFoundError(
+                    "Could not find a Pyttman app in the "
+                    "same directory as the test, or in any "
+                    "parent folder above it. Is the test "
+                    "module placed in a Pyttman application?")
+            next_dir = next_dir.parent
+        return next_dir

pyttman/tools/pyttmancli/__init__.py

@@ -52,7 +52,7 @@ def run(argv=None, dev_args: typing.List = None):
     pyttman_cli = PyttmanCli()
     dot = "\u2022"
     default_response = [pyttman_cli.description]
-    default_response.extend([f"\n{dot} {i.example}"
+    default_response.extend([f"\n{dot} {i.example}{i.__doc__}"
                              for i in pyttman_cli.intents])
     default_response = str(" ").join(default_response) + "\n"
 

pyttman/tools/pyttmancli/ability.py

@@ -1,25 +1,23 @@
 import pyttman
+import pyttman.tools.pyttmancli.intents as intents
 from pyttman.core.internals import PyttmanApp
 from pyttman.core.ability import Ability
-from pyttman.tools.pyttmancli.intents import (
-    CreateNewApp,
-    RunAppInDevMode,
-    RunAppInClientMode,
-    CreateNewAbilityIntent,
-    ShellMode
-)
 
 
 class PyttmanCli(Ability):
     """
     Encapsulates the Pyttman CLI tool 'pyttman'
     used in the terminal by framework users.
     """
-    intents = (CreateNewApp,
-               RunAppInDevMode,
-               RunAppInClientMode,
-               CreateNewAbilityIntent,
-               ShellMode)
+    intents = (
+        intents.CreateNewApp,
+        intents.RunAppInDevMode,
+        intents.RunAppInClientMode,
+        intents.CreateNewAbilityIntent,
+        intents.ShellMode,
+        intents.VersionInfo,
+        intents.RunFile,
+    )
 
     description = f"\nPyttman v{pyttman.__version__}\n\n" \
                   "For help about a commend, type pyttman help [command]" \