ChatterBot 1.2.2__py3-none-any.whl → 1.2.3__py3-none-any.whl

chatterbot/__init__.py

@@ -4,7 +4,7 @@ ChatterBot is a machine learning, conversational dialog engine.
 from .chatterbot import ChatBot
 
 
-__version__ = '1.2.2'
+__version__ = '1.2.3'
 
 __all__ = (
     'ChatBot',

chatterbot/logic/specific_response.py

@@ -1,4 +1,7 @@
 from chatterbot.logic import LogicAdapter
+from chatterbot.conversation import Statement
+from chatterbot import constants, languages
+import spacy
 
 
 class SpecificResponseAdapter(LogicAdapter):
@@ -8,30 +11,70 @@ class SpecificResponseAdapter(LogicAdapter):
     :kwargs:
         * *input_text* (``str``) --
           The input text that triggers this logic adapter.
-        * *output_text* (``str``) --
+        * *output_text* (``str`` or ``function``) --
           The output text returned by this logic adapter.
+          If a function is provided, it should return a string.
     """
 
     def __init__(self, chatbot, **kwargs):
         super().__init__(chatbot, **kwargs)
-        from chatterbot.conversation import Statement
 
         self.input_text = kwargs.get('input_text')
 
-        output_text = kwargs.get('output_text')
-        self.response_statement = Statement(text=output_text)
+        self.matcher = None
+
+        if MatcherClass := kwargs.get('matcher'):
+            language = kwargs.get('language', languages.ENG)
+
+            self.nlp = self._initialize_nlp(language)
+
+            self.matcher = MatcherClass(self.nlp.vocab)
+
+            self.matcher.add('SpecificResponse', [self.input_text])
+
+        self._output_text = kwargs.get('output_text')
+
+    def _initialize_nlp(self, language):
+        try:
+            model = constants.DEFAULT_LANGUAGE_TO_SPACY_MODEL_MAP[language]
+        except KeyError as e:
+            raise KeyError(
+                f'Spacy model is not available for language {language}'
+            ) from e
+
+        return spacy.load(model)
 
     def can_process(self, statement):
-        if statement.text == self.input_text:
+        if self.matcher:
+            doc = self.nlp(statement.text)
+            matches = self.matcher(doc)
+
+            if matches:
+                return True
+        elif statement.text == self.input_text:
             return True
 
         return False
 
     def process(self, statement, additional_response_selection_parameters=None):
 
-        if statement.text == self.input_text:
-            self.response_statement.confidence = 1
+        if callable(self._output_text):
+            response_statement = Statement(text=self._output_text())
+        else:
+            response_statement = Statement(text=self._output_text)
+
+        if self.matcher:
+            doc = self.nlp(statement.text)
+            matches = self.matcher(doc)
+
+            if matches:
+                response_statement.confidence = 1
+            else:
+                response_statement.confidence = 0
+
+        elif statement.text == self.input_text:
+            response_statement.confidence = 1
         else:
-            self.response_statement.confidence = 0
+            response_statement.confidence = 0
 
-        return self.response_statement
+        return response_statement

chatterbot/logic/unit_conversion.py

@@ -158,7 +158,8 @@ class UnitConversion(LogicAdapter):
                     response = func(p)
                     if response.confidence == 1.0:
                         break
-        except Exception:
+        except Exception as e:
+            self.chatbot.logger.warning('Error during UnitConversion: {}'.format(str(e)))
             response.confidence = 0.0
-        finally:
-            return response
+
+        return response

chatterbot/search.py

@@ -149,3 +149,58 @@ class TextSearch:
                 ))
 
                 yield statement
+
+
+class VectorSearch:
+    """
+    .. note:: BETA feature: this search method is new and experimental.
+
+    Search for similar text based on a :term:`vector database`.
+    """
+
+    name = 'vector_search'
+
+    def __init__(self, chatbot, **kwargs):
+        from chatterbot.storage import RedisVectorStorageAdapter
+
+        # Good documentation:
+        # https://python.langchain.com/docs/integrations/vectorstores/redis/
+        #
+        # https://hub.docker.com/r/redis/redis-stack
+
+        # Mondodb:
+        # > Vector Search is only supported on Atlas Clusters
+        # https://www.mongodb.com/community/forums/t/can-a-local-mongodb-instance-be-used-when-working-with-langchain-mongodbatlasvectorsearch/265356
+
+        # FAISS:
+        # https://python.langchain.com/docs/integrations/vectorstores/faiss/
+
+        print("Starting Redis Vector Store")
+
+        # TODO: look into:
+        # https://python.langchain.com/api_reference/redis/chat_message_history/langchain_redis.chat_message_history.RedisChatMessageHistory.html
+
+        # The VectorSearch class is only compatible with the RedisVectorStorageAdapter
+        if not isinstance(chatbot.storage, RedisVectorStorageAdapter):
+            raise Exception(
+                'The VectorSearch search method requires the RedisVectorStorageAdapter storage adapter.'
+            )
+
+    def search(self, input_statement, **additional_parameters):
+        print("Querying Vector Store")
+
+        # Similarity search with score and filter
+        # NOTE: It looks like `return_all` is needed to return the full document
+        # specifically what we need here is the ID
+        scored_results = self.storage.vector_store.similarity_search_with_score(
+            input_statement.text, k=2, return_all=True
+        )
+        # sort_by="score", filter={"category": "likes"})
+
+        print("Similarity Search with Score Results:\n")
+        for doc, score in scored_results:
+            print(f"Content: {doc.page_content[:150]}...")
+            print(f"ID: {doc.id}")
+            print(f"Metadata: {doc.metadata}")
+            print(f"Score: {score}")
+            print()

chatterbot/storage/__init__.py

@@ -2,6 +2,7 @@ from chatterbot.storage.storage_adapter import StorageAdapter
 from chatterbot.storage.django_storage import DjangoStorageAdapter
 from chatterbot.storage.mongodb import MongoDatabaseAdapter
 from chatterbot.storage.sql_storage import SQLStorageAdapter
+from chatterbot.storage.redis import RedisVectorStorageAdapter
 
 
 __all__ = (
@@ -9,4 +10,5 @@ __all__ = (
     'DjangoStorageAdapter',
     'MongoDatabaseAdapter',
     'SQLStorageAdapter',
+    'RedisVectorStorageAdapter',
 )

chatterbot/storage/redis.py

@@ -0,0 +1,390 @@
+from datetime import datetime
+from chatterbot.storage import StorageAdapter
+from chatterbot.conversation import Statement as StatementObject
+
+
+# TODO: This list may not be exhaustive.
+# Is there a full list of characters reserved by redis?
+REDIS_ESCAPE_CHARACTERS = {
+    '\\': '\\\\',
+    ':': '\\:',
+    '|': '\\|',
+    '%': '\\%',
+    '!': '\\!',
+    '-': '\\-',
+}
+
+REDIS_TRANSLATION_TABLE = str.maketrans(REDIS_ESCAPE_CHARACTERS)
+
+def _escape_redis_special_characters(text):
+    """
+    Escape special characters in a string that are used in redis queries.
+    """
+    return text.translate(REDIS_TRANSLATION_TABLE)
+
+
+class RedisVectorStorageAdapter(StorageAdapter):
+    """
+    .. warning:: BETA feature (Released March, 2025): this storage adapter is new
+        and experimental. Its functionality and default parameters might change
+        in the future and its behavior has not yet been finalized.
+
+    The RedisVectorStorageAdapter allows ChatterBot to store conversation
+    data in a redis instance.
+
+    All parameters are optional, by default a redis instance on localhost is assumed.
+
+    :keyword database_uri: eg: redis://localhost:6379/0',
+        The database_uri can be specified to choose a redis instance.
+    :type database_uri: str
+    """
+
+    class RedisMetaDataType:
+        """
+        Subclass for redis config metadata type enumerator.
+        """
+        TAG = 'tag'
+        TEXT = 'text'
+        NUMERIC = 'numeric'
+
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        from chatterbot.vectorstores import RedisVectorStore
+        from langchain_redis import RedisConfig  # RedisVectorStore
+        from langchain_huggingface import HuggingFaceEmbeddings
+
+        self.database_uri = kwargs.get('database_uri', 'redis://localhost:6379/0')
+
+        config = RedisConfig(
+            index_name='chatterbot',
+            redis_url=self.database_uri,
+            content_field='in_response_to',
+            metadata_schema=[
+                {
+                    'name': 'conversation',
+                    'type': self.RedisMetaDataType.TAG,
+                },
+                {
+                    'name': 'text',
+                    'type': self.RedisMetaDataType.TEXT,
+                },
+                {
+                    'name': 'created_at',
+                    'type': self.RedisMetaDataType.NUMERIC,
+                },
+                {
+                    'name': 'persona',
+                    'type': self.RedisMetaDataType.TEXT,
+                },
+                {
+                    'name': 'tags',
+                    'type': self.RedisMetaDataType.TAG,
+                    # 'separator': '|'
+                },
+            ],
+        )
+
+        # TODO should this call from_existing_index if connecting to
+        # a redis instance that already contains data?
+
+        self.logger.info('Loading HuggingFace embeddings')
+
+        # TODO: Research different embeddings
+        # https://python.langchain.com/docs/integrations/vectorstores/mongodb_atlas/#initialization
+
+        embeddings = HuggingFaceEmbeddings(
+            model_name='sentence-transformers/all-mpnet-base-v2'
+        )
+
+        self.logger.info('Creating Redis Vector Store')
+
+        self.vector_store = RedisVectorStore(embeddings, config=config)
+
+    def get_statement_model(self):
+        """
+        Return the statement model.
+        """
+        from langchain_core.documents import Document
+
+        return Document
+
+    def model_to_object(self, document):
+
+        in_response_to = document.page_content
+
+        # If the value is an empty string, set it to None
+        # to match the expected type (the vector store does
+        # not use null values)
+        if in_response_to == '':
+            in_response_to = None
+
+        values = {
+            'in_response_to': in_response_to,
+        }
+
+        if document.id:
+            values['id'] = document.id
+
+        values.update(document.metadata)
+
+        tags = values['tags']
+        values['tags'] = list(set(tags.split('|') if tags else []))
+
+        return StatementObject(**values)
+
+    def count(self):
+        """
+        Return the number of entries in the database.
+        """
+
+        '''
+        TODO
+        faiss_vector_store = FAISS(
+            embedding_function=embedding_function,
+            index=IndexFlatL2(embedding_size),
+            docstore=InMemoryDocstore(),
+            index_to_docstore_id={}
+        )
+        doc_count = faiss_vector_store.index.ntotal
+        '''
+
+        client = self.vector_store.index.client
+        return client.dbsize()
+
+    def remove(self, statement):
+        """
+        Removes the statement that matches the input text.
+        Removes any responses from statements where the response text matches
+        the input text.
+        """
+        self.vector_store.delete(ids=[statement.id.split(':')[1]])
+
+    def filter(self, page_size=4, **kwargs):
+        """
+        Returns a list of objects from the database.
+        The kwargs parameter can contain any number
+        of attributes. Only objects which contain all
+        listed attributes and in which all values match
+        for all listed attributes will be returned.
+
+        kwargs:
+            - conversation
+            - persona
+            - tags
+            - in_response_to
+            - text
+            - exclude_text
+            - exclude_text_words
+            - persona_not_startswith
+            - search_in_response_to_contains
+            - order_by
+        """
+        from redisvl.query.filter import Tag, Text
+
+        # https://redis.io/docs/latest/develop/interact/search-and-query/advanced-concepts/query_syntax/
+        filter_condition = None
+
+        if 'in_response_to' in kwargs:
+            filter_condition = Text('in_response_to') == kwargs['in_response_to']
+
+        if 'conversation' in kwargs:
+            query = Tag('conversation') == kwargs['conversation']
+            if filter_condition:
+                filter_condition &= query
+            else:
+                filter_condition = query
+
+        if 'persona' in kwargs:
+            query = Tag('persona') == kwargs['persona']
+            if filter_condition:
+                filter_condition &= query
+            else:
+                filter_condition = query
+
+        if 'tags' in kwargs:
+            query = Tag('tags') == kwargs['tags']
+            if filter_condition:
+                filter_condition &= query
+            else:
+                filter_condition = query
+
+        if 'exclude_text' in kwargs:
+            query = Text('text') != '|'.join([
+                f'%%{text}%%' for text in kwargs['exclude_text']
+            ])
+            if filter_condition:
+                filter_condition &= query
+            else:
+                filter_condition = query
+
+        if 'exclude_text_words' in kwargs:
+            _query = '|'.join([
+                f'%%{text}%%' for text in kwargs['exclude_text_words']
+            ])
+            query = Text('text') % f'-({ _query })'
+            if filter_condition:
+                filter_condition &= query
+            else:
+                filter_condition = query
+
+        if 'persona_not_startswith' in kwargs:
+            _query = _escape_redis_special_characters(kwargs['persona_not_startswith'])
+            query = Text('persona') % f'-(%%{_query}%%)'
+            if filter_condition:
+                filter_condition &= query
+            else:
+                filter_condition = query
+
+        if 'text' in kwargs:
+            _query = _escape_redis_special_characters(kwargs['text'])
+            query = Text('text') % '|'.join([f'%%{_q}%%' for _q in _query.split()])
+            if filter_condition:
+                filter_condition &= query
+            else:
+                filter_condition = query
+
+        ordering = kwargs.get('order_by', None)
+
+        if ordering:
+            ordering = ','.join(ordering)
+
+        if 'search_in_response_to_contains' in kwargs:
+            _search_text = kwargs.get('search_in_response_to_contains', '')
+
+            # TODO similarity_search_with_score
+            documents = self.vector_store.similarity_search(
+                _search_text,
+                k=page_size,  # The number of results to return
+                return_all=True,  # Include the full document with IDs
+                filter=filter_condition,
+                sort_by=ordering
+            )
+        else:
+            documents = self.vector_store.query_search(
+                k=page_size,
+                filter=filter_condition,
+                sort_by=ordering
+            )
+
+        return [self.model_to_object(document) for document in documents]
+
+    def create(
+        self,
+        text,
+        in_response_to=None,
+        tags=None,
+        **kwargs
+    ):
+        """
+        Creates a new statement matching the keyword arguments specified.
+        Returns the created statement.
+        """
+        # from langchain_community.vectorstores.redis.constants import REDIS_TAG_SEPARATOR
+
+        _default_date = datetime.now()
+
+        metadata = {
+            'text': text,
+            'category': kwargs.get('category', ''),
+            # NOTE: `created_at` must have a valid numeric value or results will
+            # not be returned for similarity_search for some reason
+            'created_at': kwargs.get('created_at') or int(_default_date.strftime('%y%m%d')),
+            'tags': '|'.join(tags) if tags else '',
+            'conversation': kwargs.get('conversation', ''),
+            'persona': kwargs.get('persona', ''),
+        }
+
+        ids = self.vector_store.add_texts([in_response_to or ''], [metadata])
+
+        metadata['created_at'] = _default_date
+        metadata['tags'] = tags or []
+        metadata.pop('text')
+        statement = StatementObject(
+            id=ids[0],
+            text=text,
+            **metadata
+        )
+        return statement
+
+    def create_many(self, statements):
+        """
+        Creates multiple statement entries.
+        """
+        Document = self.get_statement_model()
+        documents = [
+            Document(
+                page_content=statement.in_response_to or '',
+                metadata={
+                    'text': statement.text,
+                    'conversation': statement.conversation or '',
+                    'created_at': int(statement.created_at.strftime('%y%m%d')),
+                    'persona': statement.persona or '',
+                    'tags': '|'.join(statement.tags) if statement.tags else '',
+                }
+            ) for statement in statements
+        ]
+
+        self.logger.info('Adding documents to the vector store')
+
+        self.vector_store.add_documents(documents)
+
+    def update(self, statement):
+        """
+        Modifies an entry in the database.
+        Creates an entry if one does not exist.
+        """
+        metadata = {
+            'text': statement.text,
+            'conversation': statement.conversation or '',
+            'created_at': int(statement.created_at.strftime('%y%m%d')),
+            'persona': statement.persona or '',
+            'tags': '|'.join(statement.tags) if statement.tags else '',
+        }
+
+        Document = self.get_statement_model()
+        document = Document(
+            page_content=statement.in_response_to or '',
+            metadata=metadata,
+        )
+
+        if statement.id:
+            self.vector_store.add_texts(
+                [document.page_content], [metadata], keys=[statement.id.split(':')[1]]
+            )
+        else:
+            self.vector_store.add_documents([document])
+
+    def get_random(self):
+        """
+        Returns a random statement from the database.
+        """
+        client = self.vector_store.index.client
+
+        random_key = client.randomkey()
+
+        if random_key:
+            random_id = random_key.decode().split(':')[1]
+
+            documents = self.vector_store.get_by_ids([random_id])
+
+            if documents:
+                return self.model_to_object(documents[0])
+        
+        raise self.EmptyDatabaseException()
+
+    def drop(self):
+        """
+        Remove all existing documents from the database.
+        """
+        index_name = self.vector_store.config.index_name
+        client = self.vector_store.index.client
+
+        for key in client.scan_iter(f'{index_name}:*'):
+            # self.vector_store.index.drop_keys(key)
+            client.delete(key)
+
+        # Commenting this out for now because there is no step
+        # to recreate the index after it is dropped (really what
+        # we want is to delete all the keys in the index, but
+        # keep the index itself)
+        # self.vector_store.index.delete(drop=True)

chatterbot/vectorstores.py

@@ -0,0 +1,74 @@
+"""
+Redis vector store.
+"""
+from __future__ import annotations
+
+from typing import Any, List, Sequence
+
+from langchain_core.documents import Document
+from redisvl.redis.utils import convert_bytes
+from redisvl.query import FilterQuery
+
+from langchain_core.documents import Document
+from langchain_redis.vectorstores import RedisVectorStore as LangChainRedisVectorStore
+
+
+class RedisVectorStore(LangChainRedisVectorStore):
+    """
+    Redis vector store integration.
+    """
+
+    def query_search(
+        self,
+        k=4,
+        filter=None,
+        sort_by=None,
+    ) -> List[Document]:
+        """
+        Return docs based on the provided query.
+
+        k: int, default=4
+            Number of documents to return.
+        filter: str, default=None
+            A filter expression to apply to the query.
+        sort_by: str, default=None
+            A field to sort the results by.
+
+        returns:
+            A list of Documents most matching the query.
+        """
+        from chatterbot import ChatBot
+
+        return_fields = [
+            self.config.content_field
+        ]
+        return_fields += [
+            field.name
+            for field in self._index.schema.fields.values()
+            if field.name
+            not in [self.config.embedding_field, self.config.content_field]
+        ]
+
+        query = FilterQuery(
+            return_fields=return_fields,
+            num_results=k,
+            filter_expression=filter,
+            sort_by=sort_by,
+        )
+
+        try:
+            results = self._index.query(query)
+        except Exception as e:
+            raise ChatBot.ChatBotException(f'Error querying index: {query}') from e
+
+        if results:
+            with self._index.client.pipeline(transaction=False) as pipe:
+                for document in results:
+                    pipe.hgetall(document['id'])
+                full_documents = convert_bytes(pipe.execute())
+        else:
+            full_documents = []
+
+        return self._prepare_docs_full(
+            True, results, full_documents, True
+        )

{chatterbot-1.2.2.dist-info → chatterbot-1.2.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: ChatterBot
-Version: 1.2.2
+Version: 1.2.3
 Summary: ChatterBot is a machine learning, conversational dialog engine
 Author: Gunther Cox
 License: Copyright (c) 2016 - 2025, Gunther Cox
@@ -53,11 +53,18 @@ Requires-Dist: flake8; extra == "test"
 Requires-Dist: coverage; extra == "test"
 Requires-Dist: nose; extra == "test"
 Requires-Dist: sphinx<8.2,>=5.3; extra == "test"
+Requires-Dist: sphinx-sitemap>=2.6.0; extra == "test"
 Provides-Extra: dev
 Requires-Dist: pint>=0.8.1; extra == "dev"
-Requires-Dist: pymongo<4.12,>=4.11; extra == "dev"
 Requires-Dist: pyyaml<7.0,>=6.0; extra == "dev"
 Requires-Dist: chatterbot-corpus>=1.2.2; extra == "dev"
+Provides-Extra: redis
+Requires-Dist: redis[hiredis]; extra == "redis"
+Requires-Dist: langchain-redis; extra == "redis"
+Requires-Dist: langchain-huggingface; extra == "redis"
+Requires-Dist: sentence-transformers; extra == "redis"
+Provides-Extra: mongodb
+Requires-Dist: pymongo<4.12,>=4.11; extra == "mongodb"
 
 ![ChatterBot: Machine learning in Python](https://i.imgur.com/b3SCmGT.png)
 
@@ -70,7 +77,6 @@ to be trained to speak any language.
 
 [![Package Version](https://img.shields.io/pypi/v/chatterbot.svg)](https://pypi.python.org/pypi/chatterbot/)
 [![Python 3.9](https://img.shields.io/badge/python-3.9-blue.svg)](https://www.python.org/downloads/release/python-360/)
-[![Django 2.0](https://img.shields.io/badge/Django-2.0-blue.svg)](https://docs.djangoproject.com/en/2.1/releases/2.0/)
 [![Coverage Status](https://img.shields.io/coveralls/gunthercox/ChatterBot.svg)](https://coveralls.io/r/gunthercox/ChatterBot)
 [![Code Climate](https://codeclimate.com/github/gunthercox/ChatterBot/badges/gpa.svg)](https://codeclimate.com/github/gunthercox/ChatterBot)
 [![Join the chat at https://gitter.im/chatterbot/Lobby](https://badges.gitter.im/chatterbot/Lobby.svg)](https://gitter.im/chatterbot/Lobby?utm_source=badge&utm_medium=badge&utm_content=badge)

{chatterbot-1.2.2.dist-info → chatterbot-1.2.3.dist-info}/RECORD

@@ -1,4 +1,4 @@
-chatterbot/__init__.py,sha256=a8HpoSxm94mcHPYO24QiFVYS4WzYafqOGq7j_VuTIr8,158
+chatterbot/__init__.py,sha256=PhC2oXazQN3HNYXvWb33IAqEzwyt5QtqcfESq8eg3sg,158
 chatterbot/__main__.py,sha256=nk19D56TlPT9Zdqkq4qZZrOnLKEc4YTwUVWmXYwSyHg,207
 chatterbot/adapters.py,sha256=LJ_KqLpHKPdYAFpMGK63RVH4weV5X0Zh5uGyan6qdVU,878
 chatterbot/chatterbot.py,sha256=YLKLkQ-XI4Unr3rbzjpGIupOqenuevm21tAnx-yFFgQ,10400
@@ -13,10 +13,11 @@ chatterbot/languages.py,sha256=XSenfc5FxHk_JWG5gGHsZvjvrPBbCaVCm_OU-BeER_M,32784
 chatterbot/parsing.py,sha256=vS-w70cMkjq4YEpDOv_pXWhAI6Zj06WYDAcMDhYDj0M,23174
 chatterbot/preprocessors.py,sha256=aI4v987dZc7GOKhO43i0i73EX748hehYSpzikFHpEXs,1271
 chatterbot/response_selection.py,sha256=aYeZ54jpGIcQnI-1-TDcua_f1p3PiM5_iMg4hF5ZaIU,2951
-chatterbot/search.py,sha256=FTwwON2eKPWqoc5uoKh4AUmuXDCqyfMcMcXB4wijpxg,4910
+chatterbot/search.py,sha256=S4MFL1JzPqT-pv7tCgd-MIqf0T9Ia_KOLoNgzdoCP4Y,7035
 chatterbot/tagging.py,sha256=GLY9wg_rvn6pSYVML-HcxkIo_3BZ3SAyj-q1oNZY8pI,2584
 chatterbot/trainers.py,sha256=U1yh0_V7FFL51MeQe1P1Q59weceDbkHh_2kDiDYpSEc,13315
 chatterbot/utils.py,sha256=ckQXvsjp2FO9GcWxziY67JovN7mShnE4RlzdYarQY5k,3277
+chatterbot/vectorstores.py,sha256=-S1NB8PrZzoFIu95n2W7N4UaXuCUpyDUXIGYFebjv08,2056
 chatterbot/ext/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 chatterbot/ext/django_chatterbot/__init__.py,sha256=iWzmBzpAsYwkwi1faxAPFY9L1bbL97RgVXK2uqULIMc,92
 chatterbot/ext/django_chatterbot/abstract_models.py,sha256=PkuBGS0uv2toL3jGE1U6HJLCLXoKwpRNohm9JbVT_y4,3303
@@ -51,16 +52,17 @@ chatterbot/logic/__init__.py,sha256=28-5swBCPfSVMl8xB5C8frOKZ2oj28rQfenbd9E4r-4,
 chatterbot/logic/best_match.py,sha256=8TNW0uZ_Uq-XPfaZUMUZDVH6KzDT65j59xblxQBv-dQ,4820
 chatterbot/logic/logic_adapter.py,sha256=5kNEirh5fiF5hhSMFXD7bIkKwXHmrSsSS4qDm-6xry0,4694
 chatterbot/logic/mathematical_evaluation.py,sha256=GPDKUwNFajERof2R-MkPGi2jJRP-rKAGm_f0V9JHDHE,2282
-chatterbot/logic/specific_response.py,sha256=_VeJaa3kun0J7cVzLOlTYK1tBpth0B6UWms7QwtcNpY,1082
+chatterbot/logic/specific_response.py,sha256=o17YIeu9DzucO8MXMP3kwNIBb1b8br60bbAhSE7AZWc,2386
 chatterbot/logic/time_adapter.py,sha256=mxdoQGeC5IjREH4PU5iHYOIPEvnYnzgysocR8xMYWXc,2406
-chatterbot/logic/unit_conversion.py,sha256=DT50HHE3njUo_ttDSU8S-fwBylarhDF3l_McRLSX6Ic,5823
-chatterbot/storage/__init__.py,sha256=IymIHfeisvULQzUYsQSiUBbWIZ1m5EzyMVI082tTw5w,369
+chatterbot/logic/unit_conversion.py,sha256=-ENMLqZqtZx0riUi0guda2oJECST0M7pZG4cSIv3ieM,5898
+chatterbot/storage/__init__.py,sha256=ADw0WQe0YKr1UIDQLaxwf0mHDnuKW_CSzgz11K4TM-4,465
 chatterbot/storage/django_storage.py,sha256=S5S4GipD7FyNJy4RWu5-S8sLPuSJIObwTtqTpnJu-ok,6159
 chatterbot/storage/mongodb.py,sha256=Ozvdvcjb3LGZxcvbSQGzwP9VloYQbmsa2FaKunFpMyU,7934
+chatterbot/storage/redis.py,sha256=FKROrzZ-7WXZ8ZoK0dKmTDdS45TxL04XOSeu0p3Jrak,12675
 chatterbot/storage/sql_storage.py,sha256=VVYZvclG_74IN-MrG0edc-RQ2gUO6gRQyCWWSO0MmCk,13082
 chatterbot/storage/storage_adapter.py,sha256=fvyb-qNiB0HMJ0siVMCWUIY--6d-C47N1_kKZVFZAv4,6110
-chatterbot-1.2.2.dist-info/LICENSE,sha256=5b04U8mi0wp5gJMYlKi49EalnD9Q2nwY_6UEI_Avgu4,1476
-chatterbot-1.2.2.dist-info/METADATA,sha256=EGYwvpQjhqJOfjlQWI83memJr0sXKo9QwM_wbp1wtrg,8311
-chatterbot-1.2.2.dist-info/WHEEL,sha256=nn6H5-ilmfVryoAQl3ZQ2l8SH5imPWFpm1A5FgEuFV4,91
-chatterbot-1.2.2.dist-info/top_level.txt,sha256=W2TzAbAJ-eBXTIKZZhVlkrh87msJNmBQpyhkrHqjSrE,11
-chatterbot-1.2.2.dist-info/RECORD,,
+chatterbot-1.2.3.dist-info/LICENSE,sha256=5b04U8mi0wp5gJMYlKi49EalnD9Q2nwY_6UEI_Avgu4,1476
+chatterbot-1.2.3.dist-info/METADATA,sha256=xnofLrmf6knmhcwBVcodzvxpZQ-eb4tbLB970dXQG8I,8503
+chatterbot-1.2.3.dist-info/WHEEL,sha256=52BFRY2Up02UkjOa29eZOS2VxUrpPORXg1pkohGGUS8,91
+chatterbot-1.2.3.dist-info/top_level.txt,sha256=W2TzAbAJ-eBXTIKZZhVlkrh87msJNmBQpyhkrHqjSrE,11
+chatterbot-1.2.3.dist-info/RECORD,,

{chatterbot-1.2.2.dist-info → chatterbot-1.2.3.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.8.1)
+Generator: setuptools (76.0.0)
 Root-Is-Purelib: true
 Tag: py3-none-any