PyPI - fusesell - Versions diffs - 1.2.0__py3-none-any.whl - Mend

fusesell 1.2.0__py3-none-any.whl

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Potentially problematic release.

This version of fusesell might be problematic. Click here for more details.

Files changed (31) hide show

fusesell-1.2.0.dist-info/METADATA +872 -0
fusesell-1.2.0.dist-info/RECORD +31 -0
fusesell-1.2.0.dist-info/WHEEL +5 -0
fusesell-1.2.0.dist-info/entry_points.txt +2 -0
fusesell-1.2.0.dist-info/licenses/LICENSE +21 -0
fusesell-1.2.0.dist-info/top_level.txt +2 -0
fusesell.py +15 -0
fusesell_local/__init__.py +37 -0
fusesell_local/api.py +341 -0
fusesell_local/cli.py +1450 -0
fusesell_local/config/__init__.py +11 -0
fusesell_local/config/prompts.py +245 -0
fusesell_local/config/settings.py +277 -0
fusesell_local/pipeline.py +932 -0
fusesell_local/stages/__init__.py +19 -0
fusesell_local/stages/base_stage.py +602 -0
fusesell_local/stages/data_acquisition.py +1820 -0
fusesell_local/stages/data_preparation.py +1231 -0
fusesell_local/stages/follow_up.py +1590 -0
fusesell_local/stages/initial_outreach.py +2337 -0
fusesell_local/stages/lead_scoring.py +1452 -0
fusesell_local/tests/test_api.py +65 -0
fusesell_local/tests/test_cli.py +37 -0
fusesell_local/utils/__init__.py +15 -0
fusesell_local/utils/birthday_email_manager.py +467 -0
fusesell_local/utils/data_manager.py +4050 -0
fusesell_local/utils/event_scheduler.py +618 -0
fusesell_local/utils/llm_client.py +283 -0
fusesell_local/utils/logger.py +203 -0
fusesell_local/utils/timezone_detector.py +914 -0
fusesell_local/utils/validators.py +416 -0

fusesell_local/utils/llm_client.py ADDED Viewed

@@ -0,0 +1,283 @@
+"""
+LLM Client for OpenAI API integration
+"""
+try:
+    import openai
+    OPENAI_AVAILABLE = True
+except ImportError:
+    OPENAI_AVAILABLE = False
+    openai = None
+from typing import Dict, Any, List, Optional
+import logging
+import time
+import json
+class LLMClient:
+    """
+    Client for interacting with OpenAI's API.
+    Handles authentication, rate limiting, and error handling.
+    """
+    def __init__(self, api_key: str, model: str = "gpt-4o-mini", base_url: Optional[str] = None):
+        """
+        Initialize LLM client.
+        Args:
+            api_key: OpenAI API key
+            model: Model to use for completions
+            base_url: Optional base URL for API (for custom endpoints)
+        """
+        if not OPENAI_AVAILABLE:
+            raise ImportError("OpenAI package not installed. Run: pip install openai")
+        self.api_key = api_key
+        self.model = model
+        self.logger = logging.getLogger("fusesell.llm_client")
+        # Initialize OpenAI client
+        if base_url:
+            self.client = openai.OpenAI(api_key=api_key, base_url=base_url)
+        else:
+            self.client = openai.OpenAI(api_key=api_key)
+    def chat_completion(
+        self,
+        messages: List[Dict[str, str]],
+        temperature: float = 0.7,
+        max_tokens: Optional[int] = None,
+        response_format: Optional[Dict[str, str]] = None,
+        **kwargs
+    ) -> str:
+        """
+        Create a chat completion.
+        Args:
+            messages: List of message dictionaries with 'role' and 'content'
+            temperature: Sampling temperature (0-2)
+            max_tokens: Maximum tokens in response
+            response_format: Optional response format specification
+            **kwargs: Additional parameters for the API call
+        Returns:
+            Response content as string
+        Raises:
+            Exception: If API call fails after retries
+        """
+        try:
+            # Prepare API call parameters
+            api_params = {
+                "model": self.model,
+                "messages": messages,
+                "temperature": temperature,
+                **kwargs
+            }
+            if max_tokens:
+                api_params["max_tokens"] = max_tokens
+            if response_format:
+                api_params["response_format"] = response_format
+            self.logger.debug(f"Making API call with {len(messages)} messages")
+            # Make API call with retry logic
+            response = self._make_api_call_with_retry(api_params)
+            # Extract content from response
+            # Handle both OpenAI format and direct string responses
+            if isinstance(response, str):
+                # Check if response is HTML (indicates error)
+                if response.strip().startswith('<!doctype html') or response.strip().startswith('<html'):
+                    raise ValueError(f"Received HTML response instead of JSON from LLM endpoint. This usually indicates an authentication or endpoint configuration issue.")
+                content = response
+            elif hasattr(response, 'choices') and len(response.choices) > 0:
+                content = response.choices[0].message.content
+                # Check if content is HTML
+                if content and (content.strip().startswith('<!doctype html') or content.strip().startswith('<html')):
+                    raise ValueError(f"Received HTML response instead of text from LLM endpoint. This usually indicates an authentication or endpoint configuration issue.")
+            else:
+                # Fallback: try to extract content from response
+                content = str(response)
+                if content.strip().startswith('<!doctype html') or content.strip().startswith('<html'):
+                    raise ValueError(f"Received HTML response instead of JSON from LLM endpoint. This usually indicates an authentication or endpoint configuration issue.")
+            # Log token usage if available
+            if hasattr(response, 'usage'):
+                self.logger.debug(f"Token usage - Prompt: {response.usage.prompt_tokens}, "
+                                f"Completion: {response.usage.completion_tokens}, "
+                                f"Total: {response.usage.total_tokens}")
+            return content
+        except Exception as e:
+            self.logger.error(f"Chat completion failed: {str(e)}")
+            raise
+    def _make_api_call_with_retry(self, api_params: Dict[str, Any], max_retries: int = 3) -> Any:
+        """
+        Make API call with exponential backoff retry logic.
+        Args:
+            api_params: Parameters for the API call
+            max_retries: Maximum number of retry attempts
+        Returns:
+            API response object
+        Raises:
+            Exception: If all retry attempts fail
+        """
+        last_exception = None
+        for attempt in range(max_retries + 1):
+            try:
+                response = self.client.chat.completions.create(**api_params)
+                return response
+            except openai.RateLimitError as e:
+                last_exception = e
+                if attempt < max_retries:
+                    wait_time = (2 ** attempt) + 1  # Exponential backoff
+                    self.logger.warning(f"Rate limit hit, waiting {wait_time}s before retry {attempt + 1}")
+                    time.sleep(wait_time)
+                    continue
+                else:
+                    self.logger.error("Rate limit exceeded, max retries reached")
+                    raise
+            except openai.APIError as e:
+                last_exception = e
+                if attempt < max_retries and e.status_code >= 500:
+                    wait_time = (2 ** attempt) + 1
+                    self.logger.warning(f"API error {e.status_code}, retrying in {wait_time}s")
+                    time.sleep(wait_time)
+                    continue
+                else:
+                    self.logger.error(f"API error: {str(e)}")
+                    raise
+            except Exception as e:
+                last_exception = e
+                self.logger.error(f"Unexpected error in API call: {str(e)}")
+                raise
+        # If we get here, all retries failed
+        raise last_exception
+    def structured_completion(
+        self,
+        prompt: str,
+        schema: Dict[str, Any],
+        temperature: float = 0.3
+    ) -> Dict[str, Any]:
+        """
+        Get structured JSON response from LLM.
+        Args:
+            prompt: The prompt to send
+            schema: JSON schema for the expected response
+            temperature: Sampling temperature
+        Returns:
+            Parsed JSON response
+        Raises:
+            ValueError: If response doesn't match schema or isn't valid JSON
+        """
+        # Add JSON formatting instruction to prompt
+        json_prompt = f"""{prompt}
+Please respond with valid JSON that matches this schema:
+{json.dumps(schema, indent=2)}
+Response:"""
+        messages = [{"role": "user", "content": json_prompt}]
+        try:
+            # Try with JSON response format if supported
+            response = self.chat_completion(
+                messages=messages,
+                temperature=temperature,
+                response_format={"type": "json_object"}
+            )
+        except Exception:
+            # Fallback to regular completion
+            response = self.chat_completion(
+                messages=messages,
+                temperature=temperature
+            )
+        # Parse JSON response
+        try:
+            return json.loads(response)
+        except json.JSONDecodeError:
+            # Try to extract JSON from response
+            return self._extract_json_from_response(response)
+    def _extract_json_from_response(self, response: str) -> Dict[str, Any]:
+        """
+        Extract JSON from LLM response that may contain additional text.
+        Args:
+            response: Raw LLM response
+        Returns:
+            Extracted JSON dictionary
+        Raises:
+            ValueError: If no valid JSON found
+        """
+        # Try to find JSON in code blocks
+        if "```json" in response:
+            start = response.find("```json") + 7
+            end = response.find("```", start)
+            if end != -1:
+                json_str = response[start:end].strip()
+                try:
+                    return json.loads(json_str)
+                except json.JSONDecodeError:
+                    pass
+        # Try to find JSON by braces
+        start = response.find("{")
+        end = response.rfind("}") + 1
+        if start != -1 and end > start:
+            json_str = response[start:end]
+            try:
+                return json.loads(json_str)
+            except json.JSONDecodeError:
+                pass
+        # Try to find JSON array
+        start = response.find("[")
+        end = response.rfind("]") + 1
+        if start != -1 and end > start:
+            json_str = response[start:end]
+            try:
+                return json.loads(json_str)
+            except json.JSONDecodeError:
+                pass
+        raise ValueError(f"Could not extract valid JSON from response: {response[:200]}...")
+    def validate_api_key(self) -> bool:
+        """
+        Validate that the API key works by making a simple test call.
+        Returns:
+            True if API key is valid, False otherwise
+        """
+        try:
+            response = self.chat_completion(
+                messages=[{"role": "user", "content": "Hello"}],
+                max_tokens=5
+            )
+            return len(response) > 0
+        except Exception as e:
+            self.logger.error(f"API key validation failed: {str(e)}")
+            return False

fusesell_local/utils/logger.py ADDED Viewed

@@ -0,0 +1,203 @@
+"""
+Logging configuration for FuseSell Local
+"""
+import logging
+import sys
+from typing import Optional
+from pathlib import Path
+from datetime import datetime
+# Global flag to prevent multiple logging setups
+_logging_configured = False
+def setup_logging(
+    level: str = "INFO",
+    log_file: Optional[str] = None,
+    verbose: bool = False,
+    force_reconfigure: bool = False
+) -> logging.Logger:
+    """
+    Set up logging configuration for FuseSell.
+    Args:
+        level: Logging level (DEBUG, INFO, WARNING, ERROR)
+        log_file: Optional log file path
+        verbose: Enable verbose logging
+        force_reconfigure: Force reconfiguration even if already configured
+    Returns:
+        Configured logger instance
+    """
+    global _logging_configured
+    # Check if logging is already configured
+    if _logging_configured and not force_reconfigure:
+        logger = logging.getLogger("fusesell")
+        logger.debug("Logging already configured, skipping setup")
+        return logger
+    # Convert string level to logging constant
+    numeric_level = getattr(logging, level.upper(), logging.INFO)
+    # Create formatter
+    if verbose:
+        formatter = logging.Formatter(
+            '%(asctime)s - %(name)s - %(levelname)s - %(filename)s:%(lineno)d - %(message)s'
+        )
+    else:
+        formatter = logging.Formatter(
+            '%(asctime)s - %(levelname)s - %(message)s'
+        )
+    # Configure root logger
+    root_logger = logging.getLogger()
+    root_logger.setLevel(numeric_level)
+    # Remove existing handlers
+    for handler in root_logger.handlers[:]:
+        root_logger.removeHandler(handler)
+    # Console handler
+    console_handler = logging.StreamHandler(sys.stdout)
+    console_handler.setLevel(numeric_level)
+    console_handler.setFormatter(formatter)
+    root_logger.addHandler(console_handler)
+    # File handler if specified
+    if log_file:
+        try:
+            # Create log directory if it doesn't exist
+            log_path = Path(log_file)
+            log_path.parent.mkdir(parents=True, exist_ok=True)
+            file_handler = logging.FileHandler(log_file, encoding='utf-8')
+            file_handler.setLevel(numeric_level)
+            file_handler.setFormatter(formatter)
+            root_logger.addHandler(file_handler)
+        except Exception as e:
+            print(f"Warning: Could not set up file logging: {e}", file=sys.stderr)
+    # Get FuseSell logger
+    logger = logging.getLogger("fusesell")
+    logger.info(f"Logging initialized at {level} level")
+    if log_file:
+        logger.info(f"Logging to file: {log_file}")
+    # Mark logging as configured
+    _logging_configured = True
+    return logger
+def get_logger(name: str) -> logging.Logger:
+    """
+    Get a logger instance for a specific component.
+    Args:
+        name: Logger name (will be prefixed with 'fusesell.')
+    Returns:
+        Logger instance
+    """
+    return logging.getLogger(f"fusesell.{name}")
+class LoggerMixin:
+    """
+    Mixin class to add logging capabilities to other classes.
+    """
+    @property
+    def logger(self) -> logging.Logger:
+        """Get logger for this class."""
+        class_name = self.__class__.__name__.lower()
+        return get_logger(class_name)
+def log_execution_start(execution_id: str, config: dict) -> None:
+    """
+    Log the start of a FuseSell execution.
+    Args:
+        execution_id: Unique execution identifier
+        config: Execution configuration
+    """
+    logger = get_logger("execution")
+    logger.info(f"Starting execution {execution_id}")
+    logger.info(f"Organization: {config.get('org_name')} ({config.get('org_id')})")
+    logger.info(f"Customer: {config.get('customer_website')}")
+    logger.info(f"Language: {config.get('language', 'english')}")
+def log_execution_complete(execution_id: str, status: str, duration: float) -> None:
+    """
+    Log the completion of a FuseSell execution.
+    Args:
+        execution_id: Unique execution identifier
+        status: Execution status (completed, failed, etc.)
+        duration: Execution duration in seconds
+    """
+    logger = get_logger("execution")
+    logger.info(f"Execution {execution_id} {status} in {duration:.2f} seconds")
+def log_stage_start(stage_name: str, execution_id: str) -> None:
+    """
+    Log the start of a pipeline stage.
+    Args:
+        stage_name: Name of the stage
+        execution_id: Execution identifier
+    """
+    logger = get_logger("stage")
+    logger.info(f"Starting {stage_name} stage for execution {execution_id}")
+def log_stage_complete(stage_name: str, execution_id: str, status: str, duration: float) -> None:
+    """
+    Log the completion of a pipeline stage.
+    Args:
+        stage_name: Name of the stage
+        execution_id: Execution identifier
+        status: Stage status
+        duration: Stage duration in seconds
+    """
+    logger = get_logger("stage")
+    logger.info(f"Stage {stage_name} {status} for execution {execution_id} in {duration:.2f} seconds")
+def log_api_call(service: str, endpoint: str, status_code: int, duration: float) -> None:
+    """
+    Log API call details.
+    Args:
+        service: Service name (e.g., 'openai', 'serper')
+        endpoint: API endpoint
+        status_code: HTTP status code
+        duration: Call duration in seconds
+    """
+    logger = get_logger("api")
+    logger.debug(f"{service} API call to {endpoint}: {status_code} in {duration:.3f}s")
+def log_error(component: str, error: Exception, context: Optional[dict] = None) -> None:
+    """
+    Log error with context information.
+    Args:
+        component: Component where error occurred
+        error: Exception instance
+        context: Optional context information
+    """
+    logger = get_logger("error")
+    logger.error(f"Error in {component}: {str(error)}")
+    if context:
+        logger.error(f"Context: {context}")
+    logger.debug("Exception details:", exc_info=True)