version 0.1

Author: YonkoSam

.env.example

@@ -1,4 +1,21 @@
+# Required settings
 GEMINI_API_KEY="YOUR_GEMINI_API_KEY"
 WASENDER_API_TOKEN="YOUR_WASENDER_API_TOKEN"
-# Optional: If you change the port in script.py, update it here too for ngrok or other services
-# FLASK_RUN_PORT=5000
+
+# Optional settings
+WEBHOOK_SECRET="YOUR_WEBHOOK_SECRET"  # For additional webhook verification security
+GEMINI_MODEL="gemini-2.0-flash"  # Or another model like "gemini-1.5-pro"
+CONVERSATIONS_DIR="conversations"  # Directory to store conversation histories
+PERSONA_FILE_PATH="persona.json"  # Path to your persona configuration file
+
+# Performance settings
+MAX_RETRIES=3  # Maximum number of retry attempts for WaSenderAPI calls
+MESSAGE_CHUNK_MAX_LINES=3  # Max lines per WhatsApp message
+MESSAGE_CHUNK_MAX_CHARS=100  # Max characters per line in WhatsApp messages
+MESSAGE_DELAY_MIN=0.55  # Minimum delay between sequential messages (seconds)
+MESSAGE_DELAY_MAX=1.5  # Maximum delay between sequential messages (seconds)
+
+# Server settings
+PORT=5001  # HTTP server port
+FLASK_DEBUG=False  # Set to True in development only
+# Optional: LOG_LEVEL=INFO  # DEBUG, INFO, WARNING, ERROR, CRITICAL

conversations/test_user_s_whatsapp_net.json

@@ -0,0 +1,50 @@
+[
+  {
+    "role": "user",
+    "parts": [
+      "Hello, chatbot!"
+    ]
+  },
+  {
+    "role": "model",
+    "parts": [
+      "Test response from Gemini"
+    ]
+  },
+  {
+    "role": "user",
+    "parts": [
+      "Generate a long response"
+    ]
+  },
+  {
+    "role": "model",
+    "parts": [
+      "Line 1\nLine 2\nLine 3\nLine 4\nLine 5\nLine 6\nLine 7\nLine 8"
+    ]
+  },
+  {
+    "role": "user",
+    "parts": [
+      "Generate a long response"
+    ]
+  },
+  {
+    "role": "model",
+    "parts": [
+      "Line 1\nLine 2\nLine 3\nLine 4\nLine 5\nLine 6\nLine 7\nLine 8"
+    ]
+  },
+  {
+    "role": "user",
+    "parts": [
+      "Generate a long response"
+    ]
+  },
+  {
+    "role": "model",
+    "parts": [
+      "Line 1\nLine 2\nLine 3\nLine 4\nLine 5\nLine 6\nLine 7\nLine 8"
+    ]
+  }
+]

message_splitter.py

@@ -0,0 +1,151 @@
+import re
+
+"""
+message_splitter.py - Implementation of the message splitting functionality
+"""
+
+def split_message(text, max_lines=3, max_chars_per_line=100):
+    """
+    The main message splitting function, used throughout the application.
+    This is just an alias to keep backwards compatibility.
+    """
+    return split_message_impl(text, max_lines, max_chars_per_line)
+
+def split_message_impl(text, max_lines=3, max_chars_per_line=100):
+    """
+    Split a long message into smaller chunks for better WhatsApp readability.
+    This improved implementation properly handles long lines without newlines.
+    
+    Args:
+        text: The text to split
+        max_lines: Maximum lines per message chunk
+        max_chars_per_line: Maximum characters per line
+        
+    Returns:
+        List of message chunks ready to send
+    """
+    if not text:
+        return []
+    
+    # Convert escaped newlines and normalize line endings
+    normalized_text = text.replace('\\n', '\n').replace('\r\n', '\n')
+    
+    # Remove standalone backslashes using regex
+    normalized_text = re.sub(r'\n\s*\\\s*\n', '\n', normalized_text)
+    normalized_text = re.sub(r'^\s*\\\s*\n', '', normalized_text)
+    normalized_text = re.sub(r'\n\s*\\\s*$', '', normalized_text)
+    
+    # Split by existing newlines
+    paragraphs = normalized_text.split('\n')
+    chunks = []
+    current_chunk = []
+    current_line_count = 0
+    
+    for paragraph in paragraphs:
+        # Handle empty paragraphs
+        if not paragraph.strip():
+            if current_line_count >= max_lines:
+                if current_chunk:
+                    chunks.append('\n'.join(current_chunk))
+                    current_chunk = []
+                    current_line_count = 0
+            
+            if current_line_count < max_lines:
+                current_chunk.append('')
+                current_line_count += 1
+            continue
+        
+        # For paragraphs longer than max_chars_per_line, break them up
+        if len(paragraph) > max_chars_per_line:
+            words = paragraph.split()
+            
+            # Special case: single very long word
+            if len(words) == 1:
+                word = words[0]
+                for i in range(0, len(word), max_chars_per_line):
+                    if current_line_count >= max_lines:
+                        if current_chunk:
+                            chunks.append('\n'.join(current_chunk))
+                        current_chunk = []
+                        current_line_count = 0
+                    current_chunk.append(word[i:i+max_chars_per_line])
+                    current_line_count += 1
+                continue
+            
+            # Regular case: paragraph with multiple words
+            current_line = []
+            current_length = 0
+            
+            for word in words:
+                # Handle very long words
+                if len(word) > max_chars_per_line:
+                    # Add accumulated words first
+                    if current_line:
+                        if current_line_count >= max_lines:
+                            if current_chunk:
+                                chunks.append('\n'.join(current_chunk))
+                            current_chunk = []
+                            current_line_count = 0
+                        current_chunk.append(' '.join(current_line))
+                        current_line_count += 1
+                        current_line = []
+                        current_length = 0
+                    
+                    # Split the long word
+                    for i in range(0, len(word), max_chars_per_line):
+                        if current_line_count >= max_lines:
+                            if current_chunk:
+                                chunks.append('\n'.join(current_chunk))
+                            current_chunk = []
+                            current_line_count = 0
+                        current_chunk.append(word[i:i+max_chars_per_line])
+                        current_line_count += 1
+                
+                # Normal word handling
+                elif current_length + len(word) + (1 if current_line else 0) > max_chars_per_line:
+                    # Finalize current line
+                    if current_line:
+                        if current_line_count >= max_lines:
+                            if current_chunk:
+                                chunks.append('\n'.join(current_chunk))
+                            current_chunk = []
+                            current_line_count = 0
+                        current_chunk.append(' '.join(current_line))
+                        current_line_count += 1
+                    
+                    # Start new line with this word
+                    current_line = [word]
+                    current_length = len(word)
+                
+                else:
+                    # Word fits on current line
+                    if current_line:
+                        current_length += 1  # space
+                    current_line.append(word)
+                    current_length += len(word)
+            
+            # Add the last line if it exists
+            if current_line:
+                if current_line_count >= max_lines:
+                    if current_chunk:
+                        chunks.append('\n'.join(current_chunk))
+                    current_chunk = []
+                    current_line_count = 0
+                current_chunk.append(' '.join(current_line))
+                current_line_count += 1
+        
+        else:
+            # Paragraph fits on one line
+            if current_line_count >= max_lines:
+                if current_chunk:
+                    chunks.append('\n'.join(current_chunk))
+                current_chunk = []
+                current_line_count = 0
+            current_chunk.append(paragraph)
+            current_line_count += 1
+    
+    # Add the final chunk
+    if current_chunk:
+        chunks.append('\n'.join(current_chunk))
+    
+    return chunks

pytest.ini

@@ -0,0 +1,19 @@
+[pytest]
+testpaths = tests
+python_files = test_*.py
+python_functions = test_*
+python_classes = Test*
+
+[coverage:run]
+source = .
+omit = 
+    tests/*
+    */__pycache__/*
+    */venv/*
+    */virtualenv/*
+
+[coverage:report]
+exclude_lines =
+    pragma: no cover
+    def __repr__
+    if __name__ == .__main__.:

requirements-dev.txt

@@ -0,0 +1,7 @@
+pytest>=7.4.0
+pytest-cov>=4.1.0
+pytest-mock>=3.11.1
+pytest-asyncio>=0.21.1
+requests-mock>=1.11.0
+coverage>=7.3.2
+colorama>=0.4.6

requirements.txt

@@ -1,4 +1,8 @@
-flask
-requests
-python-dotenv
-google-generativeai
+flask>=2.2.0
+requests>=2.28.0
+python-dotenv>=1.0.0
+google-generativeai>=0.3.0
+wasenderapi>=0.3.1
+httpx>=0.23.0
+pydantic>=2.0.0
+gunicorn>=21.0.0  # For production deployment