Merge branch 'release/1.2.0.4' into main

Author: dotchetter

CHANGELOG.md

@@ -1,5 +1,17 @@
 # Pyttman Changelog
 
+
+# V 1.2.0.4
+This is a hotfix release, fixing an issue with BoolEntityField instances 
+not parsing the values correctly if the sought word is also part of the 
+'lead' and/or 'trail' tuples.
+
+
+### **🐛 Splatted bugs and corrected issues** 
+* **Fixes [#69](https://github.com/dotchetter/Pyttman/issues/68)**
+    
+
+
 # V 1.2.0.3
 This is a hotfix release, fixing an issue with default values in 
 TextEntityFields, causing a crash if it was combined with `as_list=True`, and

pyttman/core/entity_parsing/entity.py

@@ -27,3 +27,10 @@ def __eq__(self, other):
                and other.index_in_message == self.index_in_message
         except AttributeError:
             return False
+
+    def is_boolean(self) -> bool:
+        """
+        Returns whether the value held in `self.value` is a bool,
+        in which case it cannot be evaluated with string methods.
+        """
+        return isinstance(self.value, bool)

pyttman/core/entity_parsing/fields.py

@@ -2,6 +2,10 @@
 from abc import ABC
 from typing import Any, Sequence, Type
 
+from pyttman.core.entity_parsing.entity import Entity
+
+from pyttman.core.containers import MessageMixin, Message
+
 from pyttman.core.entity_parsing.identifiers import IntegerIdentifier, \
     Identifier
 from pyttman.core.entity_parsing.parsers import EntityFieldValueParser
@@ -155,6 +159,15 @@ def __init__(self, *args,
                  **kwargs):
         super().__init__(*args, valid_strings=message_contains, **kwargs)
 
+    def parse_message(self,
+                      message: MessageMixin,
+                      original_message_content: tuple[str],
+                      memoization: dict = None) -> None:
+        original_content = Message(original_message_content).lowered_content()
+        self.value = Entity(value=self.default, is_fallback_default=True)
+        if set(self.valid_strings).intersection(original_content):
+            self.value = Entity(value=True)
+
 
 if __name__ != "__main__":
     StringEntityField = TextEntityField

pyttman/core/entity_parsing/parsers.py

@@ -99,13 +99,23 @@ def reset(self) -> None:
         """
         self.value = None
 
-    def parse_message(self, message: MessageMixin,
+    def parse_message(self,
+                      message: MessageMixin,
+                      original_message_content: tuple[str],
                       memoization: dict = None) -> None:
         """
         Walk the message and parse it for values.
         If the identified value exists in memoization,
         traverse on until value is returned or the
         message is exhausted.
+
+        :param message: A Message object to pass to each EntityField,
+        for parsing entities.
+        :param original_message_content: The original untouched contents of
+        the message as received from the client. This is used for a source
+        of truth, since the content in `message` is mutated with each entity
+        field parsing it.
+        :param memoization: Dictionary with previously identified entities
         """
         self._prepare_params()
         if self.valid_strings:
@@ -305,7 +315,7 @@ def _identify_value(self, message: MessageMixin,
         # sure it complies with Pre- and/or suffix values, if configured
         if self.identifier is not None:
             identifier_object = self.identifier(start_index=start_index)
-            identifier_entity = identifier_object .try_identify_entity(message)
+            identifier_entity = identifier_object.try_identify_entity(message)
 
             if identifier_entity is not None:
                 allowed_scenarios = {
@@ -393,17 +403,22 @@ def _identify_value(self, message: MessageMixin,
 
 
 def parse_entities(message: MessageMixin,
-                   entity_fields: dict,
-                   exclude: tuple = None) -> dict:
+                   entity_fields: dict[str, EntityFieldValueParser],
+                   original_message_content: tuple[str],
+                   exclude: tuple = None) -> dict[str, str]:
     """
     Traverse over all fields which are EntityFieldValueParser subclasses.
     Have them identify their values according to their
     constraints and conditions, and store them in a
     dictionary, returned at the end of parsing.
-    :param exclude:
-    :param entity_fields:
+    :param original_message_content: The original untouched contents of
+        the message as received from the client. This is used for a source
+        of truth, since the content in `message` is mutated with each entity
+        field parsing it.
+    :param exclude: Optional tuple of strings to ignore in parsing.
+    :param entity_fields: Dictionary with `name: EntityField` mapped
     :param message: MessageMixin subclass object to be parsed.
-    :return:
+    :return: Dictionary with the name of the entity against its parsed value.
     """
     output = {}
     if exclude is None:
@@ -426,7 +441,8 @@ def parse_entities(message: MessageMixin,
         entity_field_instance.exclude = exclude
         entity_field_instance.parse_message(
             message,
-            memoization=parsers_memoization)
+            memoization=parsers_memoization,
+            original_message_content=original_message_content)
 
         # See what the parser found - Entity or None.
         # Ignore entities in self.exclude.
@@ -458,6 +474,9 @@ def parse_entities(message: MessageMixin,
         parser_joined_suffixes_and_prefixes)
 
     for field_name, entity in reversed(output.items()):
+        if entity.is_boolean():
+            continue
+
         entity_field = entity_fields.get(field_name)
         duplicate_cache.update(entity_field.case_preserved_cache)
         value_for_type_conversion = entity_field.default

pyttman/core/middleware/routing.py

@@ -1,6 +1,7 @@
 import abc
 import random
 import warnings
+from copy import copy
 from typing import List, Any
 
 import pyttman
@@ -95,9 +96,10 @@ def process(message: Message,
                              if i.casefold() not in joined_patterns]
         truncated_message = Message(content=truncated_content)
         entities: dict[str: Any] = parse_entities(
-            truncated_message,
-            intent.user_entity_fields,
-            intent.ignore_in_entities)
+            message=truncated_message,
+            entity_fields=intent.user_entity_fields,
+            original_message_content=copy(message.content),
+            exclude=intent.ignore_in_entities)
 
         message.entities = {k: v.value for k, v in entities.items()}
 

pyttman/version.py

@@ -1,2 +1,2 @@
 
-__version__ = "1.2.0.3"
+__version__ = "1.2.0.4"

tests/core/entity_parsing/test_entity_fields/test_entity_parsing.py

@@ -205,21 +205,22 @@ class PyttmanIntentInternalEntityParserTestWebscraperApp(
     PyttmanInternalTestBaseCase
 ):
     process_message = True
-    mock_message = Message("Search for ManufacturerA ManufacturerB Model123 "
+    mock_message = Message("monitor ManufacturerA ManufacturerB Model123 "
                            "on page_a and page_b price 45000 60 results")
     expected_entities = {
         "manufacturer": "ManufacturerA ManufacturerB",
         "model": "Model123",
         "pages": ["page_a", "page_b"],
         "minimum_price": 45000,
+        "create_monitor": True,
         "maximum_results": 60}
 
     class IntentClass(ImplementedTestIntent):
         """
         This test checks The TextEntityField, and asserts that the 'default'
         argument works as expected.
         """
-        lead = ("Search",)
+        lead = ("monitor", "search")
         ignore_in_entities = ("search", "for", "on")
         manufacturer = TextEntityField(span=2)
         model = TextEntityField(prefixes=(manufacturer,))
@@ -230,6 +231,7 @@ class IntentClass(ImplementedTestIntent):
                                            prefixes=("price",))
         maximum_results = IntegerEntityField(suffixes=("results",),
                                              identifier=NumberIdentifier)
+        create_monitor = BoolEntityField(message_contains=("monitor", "monitoring"))
 
 
 def get_valid_strings() -> tuple:
@@ -331,7 +333,7 @@ class PyttmanIntentInternalTestTrailAndLeadAreIgnored(
     mock_message = Message("Start workshift")
     process_message = True
     expected_entities = {
-        "is_workshift": False,
+        "is_workshift": True,
         "is_break": False
     }