Merge branch 'release/1.2.0.1' into main

Author: dotchetter

.gitignore

@@ -129,4 +129,5 @@ dmypy.json
 .pyre/
 
 # Editor
-.idea
+.idea
+/dev_env/

CHANGELOG.md

@@ -1,5 +1,81 @@
 # Pyttman Changelog
 
+# V 1.2.0.1
+
+This is a hotfix release, fixing an issue with EntityFields with `as_list` 
+configured, where it would append an infinite amount of matching strings, 
+when in fact, it should only add as many as defined in `span`.
+
+
+### **🐛 Splatted bugs and corrected issues** 
+* **Fixes [#66](https://github.com/dotchetter/Pyttman/issues/66)**
+    
+
+
+
+# V 1.2.0
+This is a minor release, containing new improved features, some changes 
+and bug fixes, where the first point on the News list is the reason for this release being a minor release.
+
+### :star2: News
+* **Accessing the `Ability` instance in an `Intent` class**
+
+  in Pyttman, the relationship between an Ability and Intent classes have 
+  been parent->child, with no way to access the Ability instance from the Intent. 
+  This is now possible, which allows for accessing methods which Intents may share.
+  To access the Ability from an Intent, you can do so with `self.ability` in all Intent methods.
+  This is, however, not a breaking change: backwards compatibility is still supported, meaning 
+  apps with `EntityParser` inner classes will continue to work normally.
+
+
+* **`BoolEntityField` defaults to False**
+
+  Instead of defaulting to `None`, the `BoolEntityField` class now more appropriately 
+  defaults to `False` if the sought pattern isn't found in the message.
+
+
+* **New mode in Pyttman CLI: `shell`**
+
+  The `shell` mode allows you to open your Pyttman app bootstrapped with 
+  dependencies and environment loaded up, in an interactive shell. This is 
+  useful where you want to try your classes using an interactive shell.
+  This feature is invoked using `pyttman shell <app name>`.
+   
+
+### 👀 Changes
+
+* **Removed pytz dependency from the library**
+
+
+* **Internal refactoring and code cleanup**
+
+
+* **The inner class "EntityParser" is no longer used and is unsupported.**
+  
+   The inner class `EntityParser` inside `Intent` classes was optional, and
+   added EntityParser functionality to an intent class. This class proved 
+   to be redundant however, as the EntityParser API continues to evolve. 
+   The need for an inner class is thus removed, and `EntityField` classes 
+   are instead directly declared inside the `Intent` class as class fields, 
+   more resembling other declarative API:s. 
+   
+   ```python
+    # Old
+    class SomeIntent(Intent):
+        class EntityParser:
+            name = StringEntityField()
+  
+  
+    # New
+    class SomeIntent(Intent):
+        name = StringEntityField()
+   ```
+  
+
+
+### **🐛 Splatted bugs and corrected issues** 
+* **Fixes [#64](https://github.com/dotchetter/Pyttman/issues/63)**
+    
 
 
 # v 1.1.12

pyttman/core/entity_parsing/fields.py

@@ -1,6 +1,5 @@
 import inspect
 from abc import ABC
-from functools import singledispatchmethod
 from typing import Any, Sequence, Type
 
 from pyttman.core.entity_parsing.identifiers import IntegerIdentifier, \
@@ -27,7 +26,6 @@ class EntityFieldBase(EntityFieldValueParser, ABC):
 
     def __init__(self,
                  identifier: Type[Identifier] | None = None,
-                 as_list: bool = False,
                  default: Any = None,
                  **kwargs):
         """
@@ -54,9 +52,7 @@ def __init__(self,
                                                 f"a valid value for "
                                                 f"'type_cls'.")
 
-        self.as_list = as_list
         _default_arg = default if default is not None else self.default
-
         super().__init__(identifier=identifier or self.identifier_cls,
                          default=_default_arg, **kwargs)
 

pyttman/core/entity_parsing/parsers.py

@@ -28,6 +28,7 @@ def __init__(self,
                  span: int | typing.Callable = 0,
                  identifier: Type[Identifier] | None = None,
                  exclude: typing.Iterable[str] = None,
+                 as_list: bool = False,
                  **kwargs):
 
         if hasattr(self, "value"):
@@ -45,6 +46,7 @@ def __init__(self,
         self.default = default if default is not None else None
         self.identifier = identifier
         self.span = span
+        self.as_list = as_list
         self._properties_for_evaluation = {
             "prefixes": self.prefixes,
             "suffixes": self.suffixes,
@@ -119,7 +121,9 @@ def parse_message(self, message: MessageMixin,
             common_occurrences = tuple(
                 OrderedSet(casefolded_msg).intersection(self.valid_strings))
 
-            for word in common_occurrences:
+            for i, word in enumerate(common_occurrences):
+                if i > self.span and not self.as_list:
+                    break
                 word_index = casefolded_msg.index(word)
                 output.append(message.content[word_index])
 
@@ -129,6 +133,14 @@ def parse_message(self, message: MessageMixin,
                 self.value = Entity(output.pop())
             else:
                 self.value = Entity(self.default, is_fallback_default=True)
+
+            if self.value:
+                entity = self.value
+                if isinstance(entity.value, list):
+                    [message.content.remove(i) for i in entity.value]
+                    entity.index_in_message += len(entity.value)
+                elif isinstance(entity.value, str):
+                    message.content.remove(self.value)
             return
 
         if self.truncates_message_in_parsing is False:
@@ -137,7 +149,6 @@ def parse_message(self, message: MessageMixin,
         for i, _ in enumerate(message.content):
             parsed_entity: Entity = self._identify_value(message,
                                                          start_index=i)
-
             # An entity has been identified, and it's unique.
             if parsed_entity is not None and memoization.get(
                     parsed_entity.index_in_message) is None:
@@ -292,43 +303,43 @@ def _identify_value(self, message: MessageMixin,
         # for each span iteration as the walk in the message progresses.
         # If an Identifier is does not comply with a string, the walk is
         # cancelled.
-        if parsed_entity is not None:
-            while parsed_entity.value.casefold() in self.exclude:
-                parsed_entity.index_in_message += 1
-                # Traverse the message for as long as the current found
-                # entity is in the 'exclude' tuple. If the end of message
-                # is reached, quietly break the loop.
-                try:
-                    parsed_entity.value = message.content[
-                        parsed_entity.index_in_message]
-                except IndexError:
-                    return None
-
-            current_index = parsed_entity.index_in_message
+        if parsed_entity is None:
+            return parsed_entity
+
+        while parsed_entity.value.casefold() in self.exclude:
+            parsed_entity.index_in_message += 1
+            # Traverse the message for as long as the current found
+            # entity is in the 'exclude' tuple. If the end of message
+            # is reached, quietly break the loop.
+            try:
+                parsed_entity.value = message.content[
+                    parsed_entity.index_in_message]
+            except IndexError:
+                return None
 
-            for i in range(1, self.span):
-                try:
-                    current_index += 1
-                    if self.identifier:
-                        identifier_object: Identifier = self.identifier(
-                            start_index=current_index)
-                        # Identifier did not find
-                        span_entity = identifier_object.try_identify_entity(
-                            message)
-                        if span_entity is None or span_entity.index_in_message != current_index:
-                            break
-                        span_value = span_entity.value
-                    else:
-                        span_value = message.content[current_index]
-
-                # There are not enough elements in message.content to walk
-                # as far as the span property requests - abort.
-                except IndexError:
-                    break
+        # Now, add words for as long as `span` allows us to iterate.
+        for i in range(1, self.span):
+            parsed_entity.index_in_message += 1
+            try:
+                if self.identifier:
+                    identifier_object: Identifier = self.identifier(
+                        start_index=parsed_entity.index_in_message)
+                    # Identifier did not find
+                    span_entity = identifier_object.try_identify_entity(
+                        message)
+                    if span_entity is None or span_entity.index_in_message != parsed_entity.index_in_message:
+                        break
+                    span_value = span_entity.value
                 else:
-                    if span_value not in self.exclude:
-                        print(f"{span_value} is not in {self.exclude} for {self}")
-                        parsed_entity.value += f" {span_value}"
+                    span_value = message.content[parsed_entity.index_in_message]
+
+            # There are not enough elements in message.content to walk
+            # as far as the span property requests - abort.
+            except IndexError:
+                break
+            else:
+                if span_value not in self.exclude:
+                    parsed_entity.value += f" {span_value}"
         return parsed_entity
 
 

pyttman/version.py

@@ -1,2 +1,2 @@
 
-__version__ = "1.2.0"
+__version__ = "1.2.0.1"

tests/core/entity_parsing/base.py

@@ -20,7 +20,8 @@ class ImplementedTestIntent(Intent):
     with the intent to be tested.
     """
     def respond(self, message: Message) -> Reply | ReplyStream:
-        return Reply(f"'{self.__class__.__name__}' matched a message")
+        return Reply(f"'{self.__class__.__name__}' "
+                     f"matched message: {message}")
 
 
 class PyttmanInternalTestBaseCase(PyttmanInternalBaseTestCase):

tests/core/entity_parsing/test_entity_fields/test_entity_parsing.py

@@ -38,10 +38,36 @@ class IntentClass(ImplementedTestIntent):
         # Test that both SoundCloud and Spotify are found despite being
         # misspelled in comparison to the mock message above
         platform_all = TextEntityField(as_list=True,
+                                       span=2,
                                        valid_strings=("spOtifY",
                                                       "soundcloud"))
 
 
+class PyttmanIntentInternalEntityParserTestTwoTextFields(
+    PyttmanInternalTestBaseCase
+):
+    process_message = True
+    mock_message = Message("Adam and Eve were out walking on green grass")
+    expected_entities = {
+        "person_one": "Adam",
+        "person_two": "Eve",
+        "grass_color": "green"
+    }
+
+    class IntentClass(ImplementedTestIntent):
+        """
+        Test a combination of custom Identifier class for a TextEntityField
+        with valid_strings, message_contains all in combinations.
+        """
+        valid_strings = ("Adam", "Eve")
+        lead = ("walking",)
+        person_one = TextEntityField(identifier=CapitalizedIdentifier,
+                                     valid_strings=valid_strings)
+        person_two = TextEntityField(identifier=CapitalizedIdentifier,
+                                     valid_strings=valid_strings)
+        grass_color = TextEntityField(suffixes=("grass",))
+
+
 class PyttmanIntentInternalEntityParserTestBookKeeperApp(
     PyttmanInternalTestBaseCase
 ):