ChatterBot 1.2.11__tar.gz → 1.2.12__tar.gz

{chatterbot-1.2.11 → chatterbot-1.2.12}/ChatterBot.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ChatterBot
-Version: 1.2.11
+Version: 1.2.12
 Summary: ChatterBot is a machine learning, conversational dialog engine
 Author: Gunther Cox
 License-Expression: BSD-3-Clause
@@ -39,7 +39,7 @@ Requires-Dist: tqdm
 Provides-Extra: test
 Requires-Dist: flake8; extra == "test"
 Requires-Dist: coverage; extra == "test"
-Requires-Dist: sphinx<8.2,>=5.3; extra == "test"
+Requires-Dist: sphinx<9.2,>=5.3; extra == "test"
 Requires-Dist: sphinx-sitemap>=2.6.0; extra == "test"
 Requires-Dist: huggingface_hub; extra == "test"
 Requires-Dist: django<6.0,<=4.1; extra == "test"
@@ -50,13 +50,13 @@ Requires-Dist: chatterbot-corpus<1.3.0,>=1.2.2; extra == "dev"
 Requires-Dist: ollama<1.0,>=0.6.0; extra == "dev"
 Requires-Dist: openai; extra == "dev"
 Provides-Extra: redis
-Requires-Dist: redis[hiredis]<7.0; extra == "redis"
-Requires-Dist: langchain-redis<=0.2.5; extra == "redis"
-Requires-Dist: langchain-huggingface<=0.1.2; extra == "redis"
-Requires-Dist: accelerate<=1.6.0; extra == "redis"
-Requires-Dist: sentence-transformers<=4.0.2; extra == "redis"
+Requires-Dist: redis[hiredis]<7.2,>=7.0; extra == "redis"
+Requires-Dist: langchain-redis<0.3.0; extra == "redis"
+Requires-Dist: langchain-huggingface<1.3.0,>=0.1.2; extra == "redis"
+Requires-Dist: accelerate<1.13,>=1.6.0; extra == "redis"
+Requires-Dist: sentence-transformers<5.3.0,>=4.0.2; extra == "redis"
 Provides-Extra: mongodb
-Requires-Dist: pymongo<4.16,>=4.11; extra == "mongodb"
+Requires-Dist: pymongo<4.17,>=4.11; extra == "mongodb"
 Dynamic: license-file
 
 ![ChatterBot: Machine learning in Python](https://i.imgur.com/b3SCmGT.png)
@@ -162,9 +162,9 @@ https://docs.chatterbot.us/contributing/
 
 ChatterBot is sponsored by:
 
-<p style="font-size:21px; color:black;">Browser testing via 
+<p>
    <a href="https://www.lambdatest.com/?utm_source=chatterbot&utm_medium=sponsor" target="_blank">
-      <img src="https://www.lambdatest.com/blue-logo.png" style="vertical-align: middle;" width="250" height="45" />
+      <img src="docs/_static/testmu-ai-white-logo.png" style="vertical-align: middle;" width="250" height="80" />
    </a>
 </p>
 

{chatterbot-1.2.11 → chatterbot-1.2.12}/ChatterBot.egg-info/SOURCES.txt

@@ -56,6 +56,7 @@ chatterbot/ext/django_chatterbot/migrations/0017_tags_unique.py
 chatterbot/ext/django_chatterbot/migrations/0018_text_max_length.py
 chatterbot/ext/django_chatterbot/migrations/0019_alter_statement_id_alter_tag_id_and_more.py
 chatterbot/ext/django_chatterbot/migrations/0020_alter_statement_conversation_and_more.py
+chatterbot/ext/django_chatterbot/migrations/0021_increase_text_max_length_to_1100.py
 chatterbot/ext/django_chatterbot/migrations/__init__.py
 chatterbot/ext/sqlalchemy_app/__init__.py
 chatterbot/ext/sqlalchemy_app/models.py
@@ -77,7 +78,6 @@ tests/test_benchmarks.py
 tests/test_chatbot.py
 tests/test_cli.py
 tests/test_comparisons.py
-tests/test_connection_pool.py
 tests/test_conversations.py
 tests/test_corpus.py
 tests/test_examples.py
@@ -85,7 +85,6 @@ tests/test_filters.py
 tests/test_initialization.py
 tests/test_languages.py
 tests/test_parsing.py
-tests/test_poc_vulnerability.py
 tests/test_preprocessors.py
 tests/test_response_selection.py
 tests/test_search.py

{chatterbot-1.2.11 → chatterbot-1.2.12}/ChatterBot.egg-info/requires.txt

@@ -12,19 +12,19 @@ ollama<1.0,>=0.6.0
 openai
 
 [mongodb]
-pymongo<4.16,>=4.11
+pymongo<4.17,>=4.11
 
 [redis]
-redis[hiredis]<7.0
-langchain-redis<=0.2.5
-langchain-huggingface<=0.1.2
-accelerate<=1.6.0
-sentence-transformers<=4.0.2
+redis[hiredis]<7.2,>=7.0
+langchain-redis<0.3.0
+langchain-huggingface<1.3.0,>=0.1.2
+accelerate<1.13,>=1.6.0
+sentence-transformers<5.3.0,>=4.0.2
 
 [test]
 flake8
 coverage
-sphinx<8.2,>=5.3
+sphinx<9.2,>=5.3
 sphinx-sitemap>=2.6.0
 huggingface_hub
 django<6.0,<=4.1

{chatterbot-1.2.11 → chatterbot-1.2.12}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ChatterBot
-Version: 1.2.11
+Version: 1.2.12
 Summary: ChatterBot is a machine learning, conversational dialog engine
 Author: Gunther Cox
 License-Expression: BSD-3-Clause
@@ -39,7 +39,7 @@ Requires-Dist: tqdm
 Provides-Extra: test
 Requires-Dist: flake8; extra == "test"
 Requires-Dist: coverage; extra == "test"
-Requires-Dist: sphinx<8.2,>=5.3; extra == "test"
+Requires-Dist: sphinx<9.2,>=5.3; extra == "test"
 Requires-Dist: sphinx-sitemap>=2.6.0; extra == "test"
 Requires-Dist: huggingface_hub; extra == "test"
 Requires-Dist: django<6.0,<=4.1; extra == "test"
@@ -50,13 +50,13 @@ Requires-Dist: chatterbot-corpus<1.3.0,>=1.2.2; extra == "dev"
 Requires-Dist: ollama<1.0,>=0.6.0; extra == "dev"
 Requires-Dist: openai; extra == "dev"
 Provides-Extra: redis
-Requires-Dist: redis[hiredis]<7.0; extra == "redis"
-Requires-Dist: langchain-redis<=0.2.5; extra == "redis"
-Requires-Dist: langchain-huggingface<=0.1.2; extra == "redis"
-Requires-Dist: accelerate<=1.6.0; extra == "redis"
-Requires-Dist: sentence-transformers<=4.0.2; extra == "redis"
+Requires-Dist: redis[hiredis]<7.2,>=7.0; extra == "redis"
+Requires-Dist: langchain-redis<0.3.0; extra == "redis"
+Requires-Dist: langchain-huggingface<1.3.0,>=0.1.2; extra == "redis"
+Requires-Dist: accelerate<1.13,>=1.6.0; extra == "redis"
+Requires-Dist: sentence-transformers<5.3.0,>=4.0.2; extra == "redis"
 Provides-Extra: mongodb
-Requires-Dist: pymongo<4.16,>=4.11; extra == "mongodb"
+Requires-Dist: pymongo<4.17,>=4.11; extra == "mongodb"
 Dynamic: license-file
 
 ![ChatterBot: Machine learning in Python](https://i.imgur.com/b3SCmGT.png)
@@ -162,9 +162,9 @@ https://docs.chatterbot.us/contributing/
 
 ChatterBot is sponsored by:
 
-<p style="font-size:21px; color:black;">Browser testing via 
+<p>
    <a href="https://www.lambdatest.com/?utm_source=chatterbot&utm_medium=sponsor" target="_blank">
-      <img src="https://www.lambdatest.com/blue-logo.png" style="vertical-align: middle;" width="250" height="45" />
+      <img src="docs/_static/testmu-ai-white-logo.png" style="vertical-align: middle;" width="250" height="80" />
    </a>
 </p>
 

{chatterbot-1.2.11 → chatterbot-1.2.12}/README.md

@@ -101,9 +101,9 @@ https://docs.chatterbot.us/contributing/
 
 ChatterBot is sponsored by:
 
-<p style="font-size:21px; color:black;">Browser testing via 
+<p>
    <a href="https://www.lambdatest.com/?utm_source=chatterbot&utm_medium=sponsor" target="_blank">
-      <img src="https://www.lambdatest.com/blue-logo.png" style="vertical-align: middle;" width="250" height="45" />
+      <img src="docs/_static/testmu-ai-white-logo.png" style="vertical-align: middle;" width="250" height="80" />
    </a>
 </p>
 

{chatterbot-1.2.11 → chatterbot-1.2.12}/chatterbot/__init__.py

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

{chatterbot-1.2.11 → chatterbot-1.2.12}/chatterbot/constants.py

@@ -5,11 +5,11 @@ from chatterbot import languages
 
 '''
 The maximum length of characters that the text of a statement can contain.
-The number 255 is used because that is the maximum length of a char field
-in most databases. This value should be enforced on a per-model basis by
-the data model for each storage adapter.
+The number 1100 is used to support longer conversational statements while
+remaining within VARCHAR limits for most databases. This value should be
+enforced on a per-model basis by the data model for each storage adapter.
 '''
-STATEMENT_TEXT_MAX_LENGTH = 255
+STATEMENT_TEXT_MAX_LENGTH = 1100
 
 '''
 The maximum length of characters that the text label of a conversation can contain.

chatterbot-1.2.12/chatterbot/ext/django_chatterbot/migrations/0021_increase_text_max_length_to_1100.py

@@ -0,0 +1,55 @@
+"""
+Django migration to increase text field max_length from 255 to 1100.
+
+This migration alters all text-related fields in the Statement model:
+- text
+- search_text
+- in_response_to
+- search_in_response_to
+
+This change supports longer conversational statements while remaining
+within VARCHAR limits for most databases.
+"""
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('django_chatterbot', '0020_alter_statement_conversation_and_more'),
+    ]
+
+    operations = [
+        migrations.AlterField(
+            model_name='statement',
+            name='text',
+            field=models.CharField(max_length=1100, help_text='The text of the statement.'),
+        ),
+        migrations.AlterField(
+            model_name='statement',
+            name='search_text',
+            field=models.CharField(
+                blank=True,
+                max_length=1100,
+                help_text='A modified version of the statement text optimized for searching.'
+            ),
+        ),
+        migrations.AlterField(
+            model_name='statement',
+            name='in_response_to',
+            field=models.CharField(
+                max_length=1100,
+                null=True,
+                help_text='The text of the statement that this statement is in response to.'
+            ),
+        ),
+        migrations.AlterField(
+            model_name='statement',
+            name='search_in_response_to',
+            field=models.CharField(
+                blank=True,
+                max_length=1100,
+                help_text='A modified version of the in_response_to text optimized for searching.'
+            ),
+        ),
+    ]

{chatterbot-1.2.11 → chatterbot-1.2.12}/chatterbot/storage/redis.py

@@ -65,6 +65,7 @@ class RedisVectorStorageAdapter(StorageAdapter):
             index_name='chatterbot',
             redis_url=self.database_uri,
             content_field='in_response_to',
+            legacy_key_format=False,
             metadata_schema=[
                 {
                     'name': 'conversation',
@@ -212,12 +213,16 @@ class RedisVectorStorageAdapter(StorageAdapter):
             - search_in_response_to_contains
             - order_by
         """
-        from redisvl.query import VectorQuery
         from redisvl.query.filter import Tag, Text
 
         # https://redis.io/docs/latest/develop/interact/search-and-query/advanced-concepts/query_syntax/
         filter_condition = None
 
+        ordering = kwargs.get('order_by', None)
+
+        if ordering:
+            ordering = ','.join(ordering)
+
         if 'in_response_to' in kwargs:
             filter_condition = Text('in_response_to') == kwargs['in_response_to']
 
@@ -255,7 +260,7 @@ class RedisVectorStorageAdapter(StorageAdapter):
             _query = '|'.join([
                 f'%%{text}%%' for text in kwargs['exclude_text_words']
             ])
-            query = Text('text') % f'-({ _query })'
+            query = Text('text') % f'-({_query})'
             if filter_condition:
                 filter_condition &= query
             else:
@@ -290,67 +295,20 @@ class RedisVectorStorageAdapter(StorageAdapter):
             # similar responses.
             _search_query = kwargs['search_text_contains']
 
-            # Use vector similarity to find statements responding to similar contexts
-            embedding = self.vector_store.embeddings.embed_query(_search_query)
-
-            return_fields = [
-                'text', 'in_response_to', 'conversation', 'persona', 'tags', 'created_at'
-            ]
-
-            query = VectorQuery(
-                vector=embedding,
-                vector_field_name='embedding',
-                return_fields=return_fields,
-                num_results=page_size,
-                filter_expression=filter_condition
+            documents = self.vector_store.similarity_search(
+                _search_query,
+                k=page_size,  # The number of results to return
+                return_all=True,  # Include the full document with IDs
+                filter=filter_condition,
+                sort_by=ordering
             )
 
-            results = self.vector_store.index.query(query)
-
-            Document = self.get_statement_model()
-            documents = []
-
-            # Calculate confidence from vector distances
+            # Add confidence scores based on similarity ordering
             # Results are ordered by similarity (best match first)
-            for idx, result in enumerate(results):
-                in_response_to = result.get('in_response_to', '')
-
-                # Redis vector_score is cosine distance (lower is better)
-                # Convert to confidence: confidence = 1 - distance
-                # If vector_score not available, use result order
-                vector_score = result.get('vector_score')
-                if vector_score is not None:
-                    # Cosine distance ranges from 0 (identical) to 2 (opposite)
-                    # Normalize to confidence: 1.0 (identical) to 0.0 (opposite)
-                    confidence = max(0.0, 1.0 - (float(vector_score) / 2.0))
-                else:
-                    # Fallback: use result order (first result = highest confidence)
-                    # Start at 0.95 for first result, decay by 0.05 per position
-                    confidence = max(0.0, 0.95 - (idx * 0.05))
-
-                # Parse timestamp
-                created_at_value = result.get('created_at', 0)
-                if isinstance(created_at_value, str):
-                    created_at = datetime.fromtimestamp(float(created_at_value))
-                elif created_at_value:
-                    created_at = datetime.fromtimestamp(float(created_at_value))
-                else:
-                    created_at = datetime.now()
-
-                metadata = {
-                    'text': result.get('text', ''),
-                    'conversation': result.get('conversation', ''),
-                    'persona': result.get('persona', ''),
-                    'tags': result.get('tags', ''),
-                    'created_at': created_at,
-                    'confidence': confidence,
-                }
-                doc = Document(
-                    page_content=in_response_to,
-                    metadata=metadata,
-                    id=result['id']
-                )
-                documents.append(doc)
+            for idx, doc in enumerate(documents):
+                # Start at 0.95 for first result, decay by 0.05 per position
+                confidence = max(0.0, 0.95 - (idx * 0.05))
+                doc.metadata['confidence'] = confidence
 
             return [self.model_to_object(document) for document in documents]
 
@@ -379,74 +337,20 @@ class RedisVectorStorageAdapter(StorageAdapter):
         if 'search_in_response_to_contains' in kwargs:
             _search_text = kwargs.get('search_in_response_to_contains', '')
 
-            # Get embedding for the search text
-            embedding = self.vector_store.embeddings.embed_query(_search_text)
-
-            # Build return fields from metadata schema
-            return_fields = [
-                'text', 'in_response_to', 'conversation', 'persona', 'tags', 'created_at'
-            ]
-
-            # Use direct index query via RedisVL
-            # langchain's similarity_search has issues with filters in v0.2.4
-            # and may not work properly with existing indexes
-            # TODO: Look into similarity_search_with_score implementation
-            query = VectorQuery(
-                vector=embedding,
-                vector_field_name='embedding',
-                return_fields=return_fields,
-                num_results=page_size,
-                filter_expression=filter_condition
+            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
             )
 
-            # Execute query
-            results = self.vector_store.index.query(query)
-
-            # Convert results to Document objects
-            Document = self.get_statement_model()
-            documents = []
-
-            # Calculate confidence from vector distances
+            # Add confidence scores based on similarity ordering
             # Results are ordered by similarity (best match first)
-            for idx, result in enumerate(results):
-                # Extract metadata and content
-                in_response_to = result.get('in_response_to', '')
-
-                # Redis vector_score is cosine distance (lower is better)
-                # Convert to confidence: confidence = 1 - distance
-                # If vector_score not available, use result order
-                vector_score = result.get('vector_score')
-                if vector_score is not None:
-                    # Cosine distance ranges from 0 (identical) to 2 (opposite)
-                    # Normalize to confidence: 1.0 (identical) to 0.0 (opposite)
-                    confidence = max(0.0, 1.0 - (float(vector_score) / 2.0))
-                else:
-                    # Fallback: use result order (first result = highest confidence)
-                    # Start at 0.95 for first result, decay by 0.05 per position
-                    confidence = max(0.0, 0.95 - (idx * 0.05))
-
-                # Convert Unix timestamp back to datetime
-                # Redis returns numeric fields as strings
-                created_at_timestamp = result.get('created_at', '0')
-                if created_at_timestamp and created_at_timestamp != '0':
-                    created_at = datetime.fromtimestamp(float(created_at_timestamp))
-                else:
-                    created_at = datetime.now()
-
-                metadata = {
-                    'text': result.get('text', ''),
-                    'conversation': result.get('conversation', ''),
-                    'persona': result.get('persona', ''),
-                    'tags': result.get('tags', ''),
-                    'created_at': created_at,
-                    'confidence': confidence,
-                }
-                doc = Document(
-                    page_content=in_response_to,
-                    metadata=metadata,
-                    id=result['id']
-                )
-                documents.append(doc)
+            for idx, doc in enumerate(documents):
+                # Start at 0.95 for first result, decay by 0.05 per position
+                confidence = max(0.0, 0.95 - (idx * 0.05))
+                doc.metadata['confidence'] = confidence
         else:
             documents = self.vector_store.query_search(
                 k=page_size,
@@ -551,11 +455,8 @@ class RedisVectorStorageAdapter(StorageAdapter):
             client = self.vector_store.index.client
             client.delete(statement.id)
 
-            # NOTE: langchain-redis has an inconsistency - it uses :: for auto-generated
-            # IDs but : (single colon) when keys are explicitly provided
-            if '::' in statement.id:
-                key = statement.id.split('::', 1)[1]
-            elif ':' in statement.id:
+            # Extract the key from the full ID (format: prefix:key)
+            if ':' in statement.id:
                 key = statement.id.split(':', 1)[1]
             else:
                 # If no delimiter found, use the entire ID as the key
@@ -564,13 +465,6 @@ class RedisVectorStorageAdapter(StorageAdapter):
             ids = self.vector_store.add_texts(
                 [document.page_content], [metadata], keys=[key]
             )
-
-            # Normalize the ID to use :: delimiter (if langchain-redis returned single colon)
-            if ids and ':' in ids[0] and '::' not in ids[0]:
-                # Replace first occurrence of single colon with double colon
-                normalized_id = ids[0].replace(':', '::', 1)
-                # Update the key in Redis to use the correct format
-                client.rename(ids[0], normalized_id)
         else:
             self.vector_store.add_documents([document])
 

{chatterbot-1.2.11 → chatterbot-1.2.12}/pyproject.toml

@@ -71,7 +71,7 @@ dependencies = [
 test = [
     "flake8",
     "coverage",
-    "sphinx>=5.3,<8.2",
+    "sphinx>=5.3,<9.2",
     "sphinx-sitemap>=2.6.0",
     "huggingface_hub",
     "django<=4.1,<6.0"
@@ -84,12 +84,12 @@ dev = [
     "openai"
 ]
 redis = [
-    "redis[hiredis]<7.0",
-    "langchain-redis<=0.2.5",
-    "langchain-huggingface<=0.1.2",
-    "accelerate<=1.6.0",
-    "sentence-transformers<=4.0.2",
+    "redis[hiredis]>=7.0,<7.2",
+    "langchain-redis<0.3.0",
+    "langchain-huggingface>=0.1.2,<1.3.0",
+    "accelerate>=1.6.0,<1.13",
+    "sentence-transformers>=4.0.2,<5.3.0",
 ]
 mongodb = [
-    "pymongo>=4.11,<4.16",
+    "pymongo>=4.11,<4.17",
 ]

chatterbot-1.2.11/tests/test_connection_pool.py

@@ -1,268 +0,0 @@
-"""
-Tests for database connection pool management and concurrency.
-
-These tests verify that the fixes for the connection pool exhaustion
-vulnerability (CVE-TBD) are working correctly.
-"""
-import threading
-import time
-import unittest
-from chatterbot import ChatBot
-from chatterbot.trainers import ListTrainer
-
-
-class ConnectionPoolTestCase(unittest.TestCase):
-    """
-    Test cases for database connection pool management.
-    """
-
-    def setUp(self):
-        """
-        Set up test fixtures before each test.
-        """
-        # Use in-memory SQLite for fast testing
-        # Note: SQLite doesn't use QueuePool, so pool params are ignored
-        self.chatbot = ChatBot(
-            'TestBot',
-            database_uri='sqlite://',
-        )
-        
-        # Train with some basic responses
-        trainer = ListTrainer(self.chatbot)
-        trainer.train([
-            'Hi',
-            'Hello!',
-            'How are you?',
-            'I am doing well.',
-            'What is your name?',
-            'My name is TestBot.',
-        ])
-
-    def tearDown(self):
-        """
-        Clean up after each test.
-        """
-        self.chatbot.storage.drop()
-        self.chatbot.storage.close()
-
-    def test_concurrent_requests_no_exhaustion(self):
-        """
-        Test that concurrent requests don't exhaust the connection pool.
-        
-        This was the original vulnerability - concurrent get_response() calls
-        would leak sessions and exhaust the pool.
-        """
-        num_threads = 30  # More than pool_size + max_overflow
-        responses = []
-        errors = []
-        
-        def make_request():
-            try:
-                response = self.chatbot.get_response('Hi')
-                responses.append(str(response))
-            except Exception as e:
-                errors.append(e)
-        
-        threads = []
-        for _ in range(num_threads):
-            t = threading.Thread(target=make_request)
-            threads.append(t)
-            t.start()
-        
-        # Wait for all threads to complete
-        for t in threads:
-            t.join(timeout=10)
-        
-        # Verify no errors occurred
-        self.assertEqual(len(errors), 0, 
-                        f"Connection pool exhaustion occurred: {errors}")
-        
-        # Verify all threads got responses
-        self.assertEqual(len(responses), num_threads,
-                        "Not all threads received responses")
-
-    def test_rapid_sequential_requests(self):
-        """
-        Test that rapid sequential requests properly release connections.
-        """
-        num_requests = 50  # More than pool size
-        
-        for i in range(num_requests):
-            response = self.chatbot.get_response(f'Request {i}')
-            self.assertIsNotNone(response)
-
-    def test_partial_filter_consumption(self):
-        """
-        Test that partially consuming filter() results doesn't leak sessions.
-        
-        This was a key part of the vulnerability - the filter() generator
-        would not close the session if iteration stopped early.
-        """
-        # Create many statements
-        trainer = ListTrainer(self.chatbot)
-        for i in range(100):
-            trainer.train([f'Question {i}', f'Answer {i}'])
-        
-        # Partially consume filter results many times
-        for _ in range(50):
-            results = self.chatbot.storage.filter()
-            # Only consume first result
-            first = next(results, None)
-            self.assertIsNotNone(first)
-            # Don't consume the rest - this should still clean up the session
-        
-        # If sessions weren't cleaned up, this would fail
-        response = self.chatbot.get_response('Hi')
-        self.assertIsNotNone(response)
-
-    def test_concurrent_training(self):
-        """
-        Test that concurrent training operations don't leak connections.
-        """
-        errors = []
-        
-        def train_batch(batch_id):
-            try:
-                trainer = ListTrainer(self.chatbot)
-                trainer.train([
-                    f'Training question {batch_id}',
-                    f'Training answer {batch_id}',
-                ])
-            except Exception as e:
-                errors.append(e)
-        
-        threads = []
-        for i in range(20):
-            t = threading.Thread(target=train_batch, args=(i,))
-            threads.append(t)
-            t.start()
-        
-        for t in threads:
-            t.join(timeout=10)
-        
-        self.assertEqual(len(errors), 0,
-                        f"Errors during concurrent training: {errors}")
-
-    def test_session_cleanup_on_exception(self):
-        """
-        Test that sessions are cleaned up even when exceptions occur.
-        """
-        # Force an error during a database operation
-        try:
-            # Create a statement with invalid data
-            self.chatbot.storage.create(
-                text='',  # Empty text might cause issues
-                in_response_to=None
-            )
-        except Exception:
-            pass  # Expected to fail
-        
-        # Verify the pool is still usable
-        response = self.chatbot.get_response('Hi')
-        self.assertIsNotNone(response)
-
-    def test_scoped_session_thread_safety(self):
-        """
-        Test that scoped_session provides proper thread isolation.
-        """
-        results = {}
-        
-        def check_session_isolation(thread_id):
-            # Each thread should get its own session
-            session1 = self.chatbot.storage.Session()
-            time.sleep(0.01)  # Small delay to encourage thread interleaving
-            session2 = self.chatbot.storage.Session()
-            
-            # In the same thread, scoped_session should return the same session
-            results[thread_id] = (id(session1) == id(session2))
-            
-            session1.close()
-            # After close, scoped_session should return the same instance
-            # (it doesn't create a new one, just reuses the thread-local one)
-        
-        threads = []
-        for i in range(5):
-            t = threading.Thread(target=check_session_isolation, args=(i,))
-            threads.append(t)
-            t.start()
-        
-        for t in threads:
-            t.join()
-        
-        # All threads should have gotten consistent session behavior
-        for thread_id, same_session in results.items():
-            self.assertTrue(same_session,
-                          f"Thread {thread_id} got different sessions")
-
-
-class ConnectionPoolConfigTestCase(unittest.TestCase):
-    """
-    Test cases for connection pool configuration options.
-    Note: These tests are skipped for SQLite since it uses SingletonThreadPool.
-    """
-
-    def test_pool_config_not_applied_to_sqlite(self):
-        """
-        Test that pool config is not applied to SQLite (uses SingletonThreadPool).
-        """
-        chatbot = ChatBot(
-            'SQLiteBot',
-            database_uri='sqlite://',
-            pool_size=3,  # Should be ignored
-            max_overflow=2,  # Should be ignored
-        )
-        
-        # SQLite uses SingletonThreadPool, not QueuePool
-        from sqlalchemy.pool import SingletonThreadPool
-        self.assertIsInstance(chatbot.storage.engine.pool, SingletonThreadPool)
-        
-        chatbot.storage.close()
-
-    @unittest.skip("Requires PostgreSQL/MySQL database for testing")
-    def test_custom_pool_size_postgres(self):
-        """
-        Test that custom pool_size is respected for PostgreSQL.
-        """
-        # This test would require a PostgreSQL connection
-        # chatbot = ChatBot(
-        #     'ConfigBot',
-        #     database_uri='postgresql://user:pass@localhost/test',
-        #     pool_size=3,
-        #     max_overflow=2,
-        # )
-        # self.assertEqual(chatbot.storage.engine.pool.size(), 3)
-        # chatbot.storage.close()
-        pass
-
-    @unittest.skip("Requires PostgreSQL/MySQL database for testing")
-    def test_default_pool_config_postgres(self):
-        """
-        Test that default pool configuration is applied for PostgreSQL.
-        """
-        # This test would require a PostgreSQL connection
-        # chatbot = ChatBot(
-        #     'DefaultBot',
-        #     database_uri='postgresql://user:pass@localhost/test',
-        # )
-        # pool = chatbot.storage.engine.pool
-        # self.assertEqual(pool.size(), 10)  # Default pool_size
-        # chatbot.storage.close()
-        pass
-
-    @unittest.skip("Requires PostgreSQL/MySQL database for testing")
-    def test_pool_pre_ping_enabled_postgres(self):
-        """
-        Test that pool_pre_ping is enabled by default for PostgreSQL.
-        """
-        # This test would require a PostgreSQL connection
-        # chatbot = ChatBot(
-        #     'PingBot',
-        #     database_uri='postgresql://user:pass@localhost/test',
-        # )
-        # self.assertTrue(chatbot.storage.engine.pool._pre_ping)
-        # chatbot.storage.close()
-        pass
-
-
-if __name__ == '__main__':
-    unittest.main()

chatterbot-1.2.11/tests/test_poc_vulnerability.py

@@ -1,152 +0,0 @@
-"""
-Proof-of-Concept test for the connection pool exhaustion vulnerability (CVE-TBD).
-
-This test demonstrates that the original vulnerability has been fixed.
-The PoC from the security report would cause timeout errors before the fix.
-"""
-import threading
-import tempfile
-import os
-import unittest
-from chatterbot import ChatBot
-from chatterbot.trainers import ListTrainer
-
-
-class PoC_VulnerabilityTestCase(unittest.TestCase):
-    """
-    Test case demonstrating the fix for the connection pool exhaustion vulnerability.
-    
-    This uses a file-based SQLite database which doesn't have the same
-    thread-restrictions as in-memory databases.
-    """
-
-    def setUp(self):
-        """
-        Set up test fixtures.
-        """
-        # Create a temporary database file
-        self.db_fd, self.db_path = tempfile.mkstemp(suffix='.sqlite3')
-        
-        self.chatbot = ChatBot(
-            'TestBot',
-            database_uri=f'sqlite:///{self.db_path}',
-        )
-        
-        # Train with basic data
-        trainer = ListTrainer(self.chatbot)
-        trainer.train(['hello', 'hi there'])
-
-    def tearDown(self):
-        """
-        Clean up after test.
-        """
-        self.chatbot.storage.close()
-        os.close(self.db_fd)
-        os.unlink(self.db_path)
-
-    def test_original_poc_no_longer_causes_timeout(self):
-        """
-        Test that the original PoC from the security report no longer causes errors.
-        
-        Before the fix: This would cause SQLAlchemy TimeoutError due to pool exhaustion
-        After the fix: All requests complete successfully
-        """
-        def attack():
-            try:
-                response = self.chatbot.get_response("hello")
-                results.append(('success', str(response)))
-            except Exception as e:
-                results.append(('error', str(e)))
-        
-        results = []
-        threads = []
-        
-        # Original PoC used 30 threads
-        for _ in range(30):
-            t = threading.Thread(target=attack)
-            t.start()
-            threads.append(t)
-        
-        for t in threads:
-            t.join(timeout=15)  # Should complete well before timeout
-        
-        # Count successes and errors
-        successes = [r for r in results if r[0] == 'success']
-        errors = [r for r in results if r[0] == 'error']
-        
-        # Before fix: Would have many TimeoutError exceptions
-        # After fix: All should succeed
-        self.assertEqual(len(errors), 0,
-                        f"Got {len(errors)} errors (expected 0). Errors: {[e[1] for e in errors][:5]}")
-        self.assertEqual(len(successes), 30,
-                        f"Got {len(successes)} successes (expected 30)")
-
-    def test_high_concurrency_sustained(self):
-        """
-        Test sustained high concurrency doesn't cause issues.
-        """
-        request_count = 0
-        lock = threading.Lock()
-        
-        def make_many_requests():
-            nonlocal request_count
-            for _ in range(10):
-                try:
-                    self.chatbot.get_response("hello")
-                    with lock:
-                        request_count += 1
-                except Exception:
-                    pass
-        
-        threads = []
-        for _ in range(10):  # 10 threads × 10 requests = 100 total
-            t = threading.Thread(target=make_many_requests)
-            t.start()
-            threads.append(t)
-        
-        for t in threads:
-            t.join(timeout=30)
-        
-        # Should have completed all 100 requests
-        self.assertGreater(request_count, 90,  # Allow for some timing issues
-                          f"Only completed {request_count}/100 requests")
-
-
-class SequentialPerformanceTestCase(unittest.TestCase):
-    """
-    Test that the fixes don't negatively impact single-threaded performance.
-    """
-
-    def setUp(self):
-        """
-        Set up test fixtures.
-        """
-        self.db_fd, self.db_path = tempfile.mkstemp(suffix='.sqlite3')
-        
-        self.chatbot = ChatBot(
-            'PerfBot',
-            database_uri=f'sqlite:///{self.db_path}',
-        )
-        
-        trainer = ListTrainer(self.chatbot)
-        trainer.train(['hello', 'hi', 'how are you', 'good'])
-
-    def tearDown(self):
-        """
-        Clean up.
-        """
-        self.chatbot.storage.close()
-        os.close(self.db_fd)
-        os.unlink(self.db_path)
-
-    def test_sequential_requests_still_work(self):
-        """
-        Test that normal sequential usage still works correctly.
-        """
-        for i in range(50):
-            response = self.chatbot.get_response(f"message {i}")
-            self.assertIsNotNone(response)
-
-
-if __name__ == '__main__':
-    unittest.main()