ilovetools 0.1.1__tar.gz → 0.1.3__tar.gz

{ilovetools-0.1.1/ilovetools.egg-info → ilovetools-0.1.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ilovetools
-Version: 0.1.1
+Version: 0.1.3
 Summary: A comprehensive Python utility library with modular tools for AI/ML, data processing, and daily programming needs
 Home-page: https://github.com/AliMehdi512/ilovetools
 Author: Ali Mehdi

{ilovetools-0.1.1 → ilovetools-0.1.3}/ilovetools/__init__.py

@@ -2,7 +2,7 @@
 ilovetools - A comprehensive Python utility library
 """
 
-__version__ = "0.1.1"
+__version__ = "0.1.3"
 __author__ = "Ali Mehdi"
 __email__ = "ali.mehdi.dev579@gmail.com"
 

{ilovetools-0.1.1 → ilovetools-0.1.3}/ilovetools/ai/__init__.py

@@ -3,9 +3,11 @@ AI & Machine Learning utilities module
 """
 
 from .llm_helpers import token_counter
-from .embeddings import *
+from .embeddings import similarity_search, cosine_similarity
 from .inference import *
 
 __all__ = [
     'token_counter',
+    'similarity_search',
+    'cosine_similarity',
 ]

ilovetools-0.1.3/ilovetools/ai/embeddings.py

@@ -0,0 +1,270 @@
+"""
+Embedding utilities for text and vector operations
+"""
+
+import numpy as np
+from typing import List, Union, Tuple, Dict
+import re
+
+__all__ = ['similarity_search', 'cosine_similarity']
+
+
+def cosine_similarity(vec1: Union[List[float], np.ndarray], vec2: Union[List[float], np.ndarray]) -> float:
+    """
+    Calculate cosine similarity between two vectors.
+    
+    Args:
+        vec1: First vector
+        vec2: Second vector
+    
+    Returns:
+        float: Cosine similarity score between -1 and 1
+    """
+    vec1 = np.array(vec1)
+    vec2 = np.array(vec2)
+    
+    dot_product = np.dot(vec1, vec2)
+    norm1 = np.linalg.norm(vec1)
+    norm2 = np.linalg.norm(vec2)
+    
+    if norm1 == 0 or norm2 == 0:
+        return 0.0
+    
+    return float(dot_product / (norm1 * norm2))
+
+
+def similarity_search(
+    query: str,
+    documents: List[str],
+    top_k: int = 5,
+    method: str = "tfidf",
+    return_scores: bool = True
+) -> Union[List[str], List[Tuple[str, float]]]:
+    """
+    Find most similar documents to a query using various similarity methods.
+    
+    This function performs semantic similarity search without requiring external APIs
+    or heavy ML models. Perfect for quick document retrieval, search functionality,
+    and finding relevant content.
+    
+    Args:
+        query (str): Search query text
+        documents (list): List of document strings to search through
+        top_k (int): Number of top results to return. Default: 5
+        method (str): Similarity method to use:
+            - "tfidf": TF-IDF based similarity (default, fast)
+            - "jaccard": Jaccard similarity (word overlap)
+            - "levenshtein": Edit distance based similarity
+            - "ngram": N-gram based similarity
+        return_scores (bool): If True, returns (document, score) tuples.
+                             If False, returns only documents. Default: True
+    
+    Returns:
+        list: Top-k most similar documents
+              - If return_scores=True: [(doc, score), ...]
+              - If return_scores=False: [doc, ...]
+    
+    Examples:
+        >>> from ilovetools.ai import similarity_search
+        
+        # Basic usage
+        >>> docs = [
+        ...     "Python is a programming language",
+        ...     "Machine learning with Python",
+        ...     "Java programming basics",
+        ...     "Deep learning and AI"
+        ... ]
+        >>> results = similarity_search("Python ML", docs, top_k=2)
+        >>> print(results)
+        [('Machine learning with Python', 0.85), ('Python is a programming language', 0.72)]
+        
+        # Without scores
+        >>> results = similarity_search("Python ML", docs, return_scores=False)
+        >>> print(results)
+        ['Machine learning with Python', 'Python is a programming language']
+        
+        # Different methods
+        >>> results = similarity_search("Python", docs, method="jaccard")
+        >>> results = similarity_search("Python", docs, method="levenshtein")
+        
+        # Real-world use case: FAQ search
+        >>> faqs = [
+        ...     "How do I reset my password?",
+        ...     "What is the refund policy?",
+        ...     "How to contact support?",
+        ...     "Where is my order?"
+        ... ]
+        >>> user_query = "forgot password"
+        >>> answer = similarity_search(user_query, faqs, top_k=1, return_scores=False)[0]
+        >>> print(answer)
+        'How do I reset my password?'
+    
+    Notes:
+        - TF-IDF method is fastest and works well for most cases
+        - Jaccard is good for short texts and keyword matching
+        - Levenshtein is useful for typo-tolerant search
+        - No external dependencies or API calls required
+        - Works offline and is very fast
+    
+    Performance:
+        - TF-IDF: O(n*m) where n=docs, m=avg words
+        - Jaccard: O(n*m)
+        - Levenshtein: O(n*m^2)
+    """
+    
+    if not documents:
+        return []
+    
+    if top_k > len(documents):
+        top_k = len(documents)
+    
+    # Normalize query
+    query_lower = query.lower()
+    
+    if method == "tfidf":
+        scores = _tfidf_similarity(query_lower, documents)
+    elif method == "jaccard":
+        scores = _jaccard_similarity(query_lower, documents)
+    elif method == "levenshtein":
+        scores = _levenshtein_similarity(query_lower, documents)
+    elif method == "ngram":
+        scores = _ngram_similarity(query_lower, documents)
+    else:
+        raise ValueError(f"Unknown method: {method}. Use 'tfidf', 'jaccard', 'levenshtein', or 'ngram'")
+    
+    # Sort by score (descending)
+    doc_scores = list(zip(documents, scores))
+    doc_scores.sort(key=lambda x: x[1], reverse=True)
+    
+    # Get top-k results
+    top_results = doc_scores[:top_k]
+    
+    if return_scores:
+        return top_results
+    else:
+        return [doc for doc, _ in top_results]
+
+
+def _tfidf_similarity(query: str, documents: List[str]) -> List[float]:
+    """TF-IDF based similarity calculation."""
+    # Tokenize
+    query_words = set(re.findall(r'\w+', query.lower()))
+    
+    if not query_words:
+        return [0.0] * len(documents)
+    
+    # Calculate document frequencies
+    doc_freq = {}
+    for doc in documents:
+        doc_words = set(re.findall(r'\w+', doc.lower()))
+        for word in doc_words:
+            doc_freq[word] = doc_freq.get(word, 0) + 1
+    
+    num_docs = len(documents)
+    scores = []
+    
+    for doc in documents:
+        doc_words = re.findall(r'\w+', doc.lower())
+        doc_word_set = set(doc_words)
+        
+        # Calculate TF-IDF score
+        score = 0.0
+        for word in query_words:
+            if word in doc_word_set:
+                # TF: term frequency in document
+                tf = doc_words.count(word) / len(doc_words) if doc_words else 0
+                # IDF: inverse document frequency
+                idf = np.log(num_docs / (doc_freq.get(word, 0) + 1))
+                score += tf * idf
+        
+        scores.append(score)
+    
+    return scores
+
+
+def _jaccard_similarity(query: str, documents: List[str]) -> List[float]:
+    """Jaccard similarity based on word overlap."""
+    query_words = set(re.findall(r'\w+', query.lower()))
+    
+    if not query_words:
+        return [0.0] * len(documents)
+    
+    scores = []
+    for doc in documents:
+        doc_words = set(re.findall(r'\w+', doc.lower()))
+        
+        if not doc_words:
+            scores.append(0.0)
+            continue
+        
+        intersection = len(query_words & doc_words)
+        union = len(query_words | doc_words)
+        
+        score = intersection / union if union > 0 else 0.0
+        scores.append(score)
+    
+    return scores
+
+
+def _levenshtein_distance(s1: str, s2: str) -> int:
+    """Calculate Levenshtein distance between two strings."""
+    if len(s1) < len(s2):
+        return _levenshtein_distance(s2, s1)
+    
+    if len(s2) == 0:
+        return len(s1)
+    
+    previous_row = range(len(s2) + 1)
+    for i, c1 in enumerate(s1):
+        current_row = [i + 1]
+        for j, c2 in enumerate(s2):
+            insertions = previous_row[j + 1] + 1
+            deletions = current_row[j] + 1
+            substitutions = previous_row[j] + (c1 != c2)
+            current_row.append(min(insertions, deletions, substitutions))
+        previous_row = current_row
+    
+    return previous_row[-1]
+
+
+def _levenshtein_similarity(query: str, documents: List[str]) -> List[float]:
+    """Levenshtein distance based similarity."""
+    scores = []
+    for doc in documents:
+        doc_lower = doc.lower()
+        distance = _levenshtein_distance(query, doc_lower)
+        max_len = max(len(query), len(doc_lower))
+        
+        # Convert distance to similarity (0 to 1)
+        similarity = 1 - (distance / max_len) if max_len > 0 else 0.0
+        scores.append(similarity)
+    
+    return scores
+
+
+def _ngram_similarity(query: str, documents: List[str], n: int = 2) -> List[float]:
+    """N-gram based similarity."""
+    def get_ngrams(text: str, n: int) -> set:
+        text = text.lower()
+        return set(text[i:i+n] for i in range(len(text) - n + 1))
+    
+    query_ngrams = get_ngrams(query, n)
+    
+    if not query_ngrams:
+        return [0.0] * len(documents)
+    
+    scores = []
+    for doc in documents:
+        doc_ngrams = get_ngrams(doc, n)
+        
+        if not doc_ngrams:
+            scores.append(0.0)
+            continue
+        
+        intersection = len(query_ngrams & doc_ngrams)
+        union = len(query_ngrams | doc_ngrams)
+        
+        score = intersection / union if union > 0 else 0.0
+        scores.append(score)
+    
+    return scores

ilovetools-0.1.3/ilovetools/data/__init__.py

@@ -0,0 +1,27 @@
+"""
+Data processing and manipulation utilities
+"""
+
+from .preprocessing import train_test_split, normalize_data, standardize_data
+from .feature_engineering import (
+    create_polynomial_features,
+    bin_numerical_feature,
+    one_hot_encode,
+    label_encode,
+    extract_datetime_features,
+    handle_missing_values,
+    create_interaction_features
+)
+
+__all__ = [
+    'train_test_split',
+    'normalize_data',
+    'standardize_data',
+    'create_polynomial_features',
+    'bin_numerical_feature',
+    'one_hot_encode',
+    'label_encode',
+    'extract_datetime_features',
+    'handle_missing_values',
+    'create_interaction_features',
+]

ilovetools-0.1.3/ilovetools/data/feature_engineering.py

@@ -0,0 +1,497 @@
+"""
+Feature engineering utilities for ML workflows
+"""
+
+from typing import List, Union, Dict, Tuple, Optional
+import numpy as np
+from datetime import datetime
+
+__all__ = [
+    'create_polynomial_features',
+    'bin_numerical_feature',
+    'one_hot_encode',
+    'label_encode',
+    'extract_datetime_features',
+    'handle_missing_values',
+    'create_interaction_features'
+]
+
+
+def create_polynomial_features(
+    data: Union[List[float], np.ndarray],
+    degree: int = 2,
+    include_bias: bool = False
+) -> List[List[float]]:
+    """
+    Create polynomial features from numerical data.
+    
+    Transforms [x] into [x, x^2, x^3, ...] to capture non-linear relationships.
+    Essential for models that need to learn curved patterns.
+    
+    Args:
+        data: List or array of numerical values
+        degree: Maximum polynomial degree. Default: 2
+        include_bias: Include bias term (column of 1s). Default: False
+    
+    Returns:
+        list: Polynomial features as list of lists
+    
+    Examples:
+        >>> from ilovetools.data import create_polynomial_features
+        
+        # Basic usage
+        >>> ages = [20, 25, 30, 35, 40]
+        >>> poly_features = create_polynomial_features(ages, degree=2)
+        >>> print(poly_features)
+        [[20, 400], [25, 625], [30, 900], [35, 1225], [40, 1600]]
+        
+        # With bias term
+        >>> poly_features = create_polynomial_features(ages, degree=2, include_bias=True)
+        >>> print(poly_features[0])
+        [1, 20, 400]
+        
+        # Degree 3
+        >>> poly_features = create_polynomial_features([2, 3, 4], degree=3)
+        >>> print(poly_features)
+        [[2, 4, 8], [3, 9, 27], [4, 16, 64]]
+        
+        # Real-world: Age features for insurance pricing
+        >>> customer_ages = [25, 35, 45, 55, 65]
+        >>> age_features = create_polynomial_features(customer_ages, degree=2)
+        # Now model can learn: premium = a*age + b*age^2
+    
+    Notes:
+        - Useful for capturing non-linear relationships
+        - Common in regression problems
+        - Be careful with high degrees (overfitting risk)
+        - Normalize features after polynomial expansion
+    """
+    if isinstance(data, np.ndarray):
+        data = data.tolist()
+    
+    result = []
+    for value in data:
+        features = []
+        if include_bias:
+            features.append(1)
+        for d in range(1, degree + 1):
+            features.append(value ** d)
+        result.append(features)
+    
+    return result
+
+
+def bin_numerical_feature(
+    data: Union[List[float], np.ndarray],
+    bins: Union[int, List[float]] = 5,
+    labels: Optional[List[str]] = None
+) -> List[Union[int, str]]:
+    """
+    Bin continuous numerical data into discrete categories.
+    
+    Converts continuous values into groups/bins. Useful for creating
+    categorical features from numerical data.
+    
+    Args:
+        data: List or array of numerical values
+        bins: Number of equal-width bins OR list of bin edges
+        labels: Optional labels for bins. If None, returns bin indices
+    
+    Returns:
+        list: Binned values (indices or labels)
+    
+    Examples:
+        >>> from ilovetools.data import bin_numerical_feature
+        
+        # Age groups
+        >>> ages = [5, 15, 25, 35, 45, 55, 65, 75]
+        >>> age_groups = bin_numerical_feature(
+        ...     ages,
+        ...     bins=[0, 18, 35, 60, 100],
+        ...     labels=["Child", "Young Adult", "Adult", "Senior"]
+        ... )
+        >>> print(age_groups)
+        ['Child', 'Child', 'Young Adult', 'Adult', 'Adult', 'Senior', 'Senior', 'Senior']
+        
+        # Income brackets
+        >>> incomes = [25000, 45000, 65000, 85000, 120000]
+        >>> income_brackets = bin_numerical_feature(
+        ...     incomes,
+        ...     bins=[0, 40000, 80000, 150000],
+        ...     labels=["Low", "Medium", "High"]
+        ... )
+        
+        # Equal-width bins
+        >>> scores = [45, 67, 89, 92, 78, 56, 34, 88]
+        >>> score_bins = bin_numerical_feature(scores, bins=3)
+        >>> print(score_bins)
+        [0, 1, 2, 2, 2, 1, 0, 2]
+    
+    Notes:
+        - Useful for creating categorical features
+        - Helps models learn threshold effects
+        - Can reduce noise in continuous data
+        - Choose bins based on domain knowledge
+    """
+    if isinstance(data, np.ndarray):
+        data = data.tolist()
+    
+    if isinstance(bins, int):
+        # Create equal-width bins
+        min_val = min(data)
+        max_val = max(data)
+        bin_width = (max_val - min_val) / bins
+        bin_edges = [min_val + i * bin_width for i in range(bins + 1)]
+        bin_edges[-1] += 0.001  # Ensure max value is included
+    else:
+        bin_edges = bins
+    
+    result = []
+    for value in data:
+        bin_idx = 0
+        for i in range(len(bin_edges) - 1):
+            if bin_edges[i] <= value < bin_edges[i + 1]:
+                bin_idx = i
+                break
+        
+        if labels:
+            result.append(labels[bin_idx])
+        else:
+            result.append(bin_idx)
+    
+    return result
+
+
+def one_hot_encode(
+    data: List[str],
+    categories: Optional[List[str]] = None
+) -> Dict[str, List[int]]:
+    """
+    One-hot encode categorical data.
+    
+    Converts categories into binary columns. Each category becomes
+    a separate binary feature.
+    
+    Args:
+        data: List of categorical values
+        categories: Optional list of all possible categories
+    
+    Returns:
+        dict: Dictionary with category names as keys, binary lists as values
+    
+    Examples:
+        >>> from ilovetools.data import one_hot_encode
+        
+        # Basic encoding
+        >>> colors = ["Red", "Blue", "Green", "Red", "Blue"]
+        >>> encoded = one_hot_encode(colors)
+        >>> print(encoded)
+        {'Red': [1, 0, 0, 1, 0], 'Blue': [0, 1, 0, 0, 1], 'Green': [0, 0, 1, 0, 0]}
+        
+        # With predefined categories
+        >>> sizes = ["S", "M", "L", "M"]
+        >>> encoded = one_hot_encode(sizes, categories=["XS", "S", "M", "L", "XL"])
+        
+        # Real-world: Product categories
+        >>> products = ["Electronics", "Clothing", "Electronics", "Food"]
+        >>> encoded = one_hot_encode(products)
+        # Use in ML: Each category becomes a feature
+    
+    Notes:
+        - Standard encoding for categorical features
+        - Creates sparse features (mostly zeros)
+        - Number of features = number of categories
+        - Use for nominal categories (no order)
+    """
+    if categories is None:
+        categories = sorted(list(set(data)))
+    
+    result = {cat: [] for cat in categories}
+    
+    for value in data:
+        for cat in categories:
+            result[cat].append(1 if value == cat else 0)
+    
+    return result
+
+
+def label_encode(data: List[str]) -> Tuple[List[int], Dict[str, int]]:
+    """
+    Label encode categorical data to integers.
+    
+    Converts categories to integer labels. Useful for ordinal categories
+    or when one-hot encoding creates too many features.
+    
+    Args:
+        data: List of categorical values
+    
+    Returns:
+        tuple: (encoded_data, label_mapping)
+    
+    Examples:
+        >>> from ilovetools.data import label_encode
+        
+        # Basic encoding
+        >>> sizes = ["Small", "Large", "Medium", "Small", "Large"]
+        >>> encoded, mapping = label_encode(sizes)
+        >>> print(encoded)
+        [2, 0, 1, 2, 0]
+        >>> print(mapping)
+        {'Large': 0, 'Medium': 1, 'Small': 2}
+        
+        # Education levels (ordinal)
+        >>> education = ["High School", "Bachelor", "Master", "Bachelor"]
+        >>> encoded, mapping = label_encode(education)
+        
+        # Decode back
+        >>> reverse_mapping = {v: k for k, v in mapping.items()}
+        >>> original = [reverse_mapping[code] for code in encoded]
+    
+    Notes:
+        - More memory efficient than one-hot encoding
+        - Use for ordinal categories (has order)
+        - Model may assume order exists
+        - Returns mapping for decoding
+    """
+    unique_values = sorted(list(set(data)))
+    mapping = {val: idx for idx, val in enumerate(unique_values)}
+    encoded = [mapping[val] for val in data]
+    
+    return encoded, mapping
+
+
+def extract_datetime_features(
+    timestamps: List[str],
+    format: str = "%Y-%m-%d %H:%M:%S"
+) -> Dict[str, List[int]]:
+    """
+    Extract useful features from datetime strings.
+    
+    Converts timestamps into multiple temporal features like hour,
+    day of week, month, etc. Essential for time-series ML.
+    
+    Args:
+        timestamps: List of datetime strings
+        format: Datetime format string. Default: "%Y-%m-%d %H:%M:%S"
+    
+    Returns:
+        dict: Dictionary with feature names and values
+    
+    Examples:
+        >>> from ilovetools.data import extract_datetime_features
+        
+        # Basic usage
+        >>> dates = [
+        ...     "2024-03-15 14:30:00",
+        ...     "2024-03-16 09:15:00",
+        ...     "2024-03-17 18:45:00"
+        ... ]
+        >>> features = extract_datetime_features(dates)
+        >>> print(features.keys())
+        dict_keys(['year', 'month', 'day', 'hour', 'minute', 'day_of_week', 'is_weekend'])
+        
+        # E-commerce: Purchase patterns
+        >>> purchase_times = ["2024-12-25 10:30:00", "2024-12-26 15:45:00"]
+        >>> features = extract_datetime_features(purchase_times)
+        >>> print(features['is_weekend'])
+        [0, 0]
+        >>> print(features['hour'])
+        [10, 15]
+        
+        # Different format
+        >>> dates = ["15/03/2024", "16/03/2024"]
+        >>> features = extract_datetime_features(dates, format="%d/%m/%Y")
+    
+    Notes:
+        - Captures temporal patterns
+        - Essential for time-series forecasting
+        - Helps model learn seasonality
+        - Common features: hour, day, month, is_weekend
+    """
+    result = {
+        'year': [],
+        'month': [],
+        'day': [],
+        'hour': [],
+        'minute': [],
+        'day_of_week': [],  # 0=Monday, 6=Sunday
+        'is_weekend': []
+    }
+    
+    for ts in timestamps:
+        dt = datetime.strptime(ts, format)
+        result['year'].append(dt.year)
+        result['month'].append(dt.month)
+        result['day'].append(dt.day)
+        result['hour'].append(dt.hour)
+        result['minute'].append(dt.minute)
+        result['day_of_week'].append(dt.weekday())
+        result['is_weekend'].append(1 if dt.weekday() >= 5 else 0)
+    
+    return result
+
+
+def handle_missing_values(
+    data: List[Optional[float]],
+    strategy: str = "mean"
+) -> List[float]:
+    """
+    Handle missing values in numerical data.
+    
+    Fills None/NaN values using various strategies. Essential
+    preprocessing step for ML models.
+    
+    Args:
+        data: List with potential None values
+        strategy: Fill strategy - "mean", "median", "mode", "forward", "backward", "zero"
+    
+    Returns:
+        list: Data with missing values filled
+    
+    Examples:
+        >>> from ilovetools.data import handle_missing_values
+        
+        # Mean imputation
+        >>> data = [1.0, 2.0, None, 4.0, 5.0]
+        >>> filled = handle_missing_values(data, strategy="mean")
+        >>> print(filled)
+        [1.0, 2.0, 3.0, 4.0, 5.0]
+        
+        # Median imputation
+        >>> data = [1.0, 2.0, None, 100.0]
+        >>> filled = handle_missing_values(data, strategy="median")
+        
+        # Forward fill
+        >>> data = [1.0, None, None, 4.0]
+        >>> filled = handle_missing_values(data, strategy="forward")
+        >>> print(filled)
+        [1.0, 1.0, 1.0, 4.0]
+        
+        # Zero fill
+        >>> data = [1.0, None, 3.0]
+        >>> filled = handle_missing_values(data, strategy="zero")
+        >>> print(filled)
+        [1.0, 0.0, 3.0]
+    
+    Notes:
+        - Most ML models can't handle missing values
+        - Choose strategy based on data distribution
+        - Mean: Sensitive to outliers
+        - Median: Robust to outliers
+        - Forward/Backward: For time-series data
+    """
+    valid_values = [x for x in data if x is not None]
+    
+    if not valid_values:
+        return [0.0] * len(data)
+    
+    if strategy == "mean":
+        fill_value = sum(valid_values) / len(valid_values)
+    elif strategy == "median":
+        sorted_vals = sorted(valid_values)
+        n = len(sorted_vals)
+        fill_value = sorted_vals[n // 2] if n % 2 else (sorted_vals[n // 2 - 1] + sorted_vals[n // 2]) / 2
+    elif strategy == "mode":
+        fill_value = max(set(valid_values), key=valid_values.count)
+    elif strategy == "zero":
+        fill_value = 0.0
+    else:
+        fill_value = sum(valid_values) / len(valid_values)
+    
+    result = []
+    last_valid = fill_value
+    
+    for value in data:
+        if value is None:
+            if strategy == "forward":
+                result.append(last_valid)
+            else:
+                result.append(fill_value)
+        else:
+            result.append(value)
+            last_valid = value
+    
+    # Backward fill if needed
+    if strategy == "backward":
+        result_reversed = []
+        last_valid = fill_value
+        for value in reversed(result):
+            if value is None:
+                result_reversed.append(last_valid)
+            else:
+                result_reversed.append(value)
+                last_valid = value
+        result = list(reversed(result_reversed))
+    
+    return result
+
+
+def create_interaction_features(
+    feature1: Union[List[float], np.ndarray],
+    feature2: Union[List[float], np.ndarray],
+    operation: str = "multiply"
+) -> List[float]:
+    """
+    Create interaction features between two features.
+    
+    Combines two features to capture their joint effect. Useful when
+    features interact in meaningful ways.
+    
+    Args:
+        feature1: First feature
+        feature2: Second feature
+        operation: "multiply", "add", "subtract", "divide"
+    
+    Returns:
+        list: Interaction feature values
+    
+    Examples:
+        >>> from ilovetools.data import create_interaction_features
+        
+        # Multiply interaction
+        >>> height = [170, 180, 160, 175]
+        >>> weight = [70, 85, 60, 80]
+        >>> bmi_proxy = create_interaction_features(height, weight, "multiply")
+        
+        # Real-world: Price per square foot
+        >>> prices = [300000, 450000, 250000]
+        >>> sqft = [1500, 2000, 1200]
+        >>> price_per_sqft = create_interaction_features(prices, sqft, "divide")
+        >>> print(price_per_sqft)
+        [200.0, 225.0, 208.33]
+        
+        # Add interaction
+        >>> feature1 = [1, 2, 3]
+        >>> feature2 = [4, 5, 6]
+        >>> combined = create_interaction_features(feature1, feature2, "add")
+        >>> print(combined)
+        [5, 7, 9]
+    
+    Notes:
+        - Captures feature interactions
+        - Common in real estate (price * sqft)
+        - Useful in e-commerce (quantity * price)
+        - Can significantly improve model performance
+    """
+    if isinstance(feature1, np.ndarray):
+        feature1 = feature1.tolist()
+    if isinstance(feature2, np.ndarray):
+        feature2 = feature2.tolist()
+    
+    if len(feature1) != len(feature2):
+        raise ValueError("Features must have same length")
+    
+    result = []
+    for v1, v2 in zip(feature1, feature2):
+        if operation == "multiply":
+            result.append(v1 * v2)
+        elif operation == "add":
+            result.append(v1 + v2)
+        elif operation == "subtract":
+            result.append(v1 - v2)
+        elif operation == "divide":
+            result.append(v1 / v2 if v2 != 0 else 0.0)
+        else:
+            result.append(v1 * v2)
+    
+    return result

ilovetools-0.1.3/ilovetools/data/preprocessing.py

@@ -0,0 +1,234 @@
+"""
+Data preprocessing utilities
+"""
+
+import random
+from typing import Tuple, List, Union, Optional
+import numpy as np
+
+__all__ = ['train_test_split', 'normalize_data', 'standardize_data']
+
+
+def train_test_split(
+    X: Union[List, np.ndarray],
+    y: Optional[Union[List, np.ndarray]] = None,
+    test_size: float = 0.2,
+    random_state: Optional[int] = None,
+    shuffle: bool = True,
+    stratify: bool = False
+) -> Union[Tuple[List, List], Tuple[List, List, List, List]]:
+    """
+    Split arrays or lists into random train and test subsets.
+    
+    Perfect for ML workflows - implements the fundamental train-test split
+    pattern without requiring scikit-learn. Supports stratified splitting
+    to maintain class distribution.
+    
+    Args:
+        X: Features array/list to split
+        y: Target array/list to split (optional)
+        test_size: Proportion of dataset for test set (0.0 to 1.0). Default: 0.2
+        random_state: Random seed for reproducibility. Default: None
+        shuffle: Whether to shuffle data before splitting. Default: True
+        stratify: Maintain class distribution in splits (requires y). Default: False
+    
+    Returns:
+        If y is None: (X_train, X_test)
+        If y is provided: (X_train, X_test, y_train, y_test)
+    
+    Examples:
+        >>> from ilovetools.data import train_test_split
+        
+        # Basic split
+        >>> X = [[1, 2], [3, 4], [5, 6], [7, 8], [9, 10]]
+        >>> y = [0, 1, 0, 1, 0]
+        >>> X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)
+        >>> len(X_train), len(X_test)
+        (4, 1)
+        
+        # With random seed for reproducibility
+        >>> X_train, X_test, y_train, y_test = train_test_split(
+        ...     X, y, test_size=0.3, random_state=42
+        ... )
+        
+        # Stratified split (maintains class distribution)
+        >>> X_train, X_test, y_train, y_test = train_test_split(
+        ...     X, y, test_size=0.2, stratify=True, random_state=42
+        ... )
+        
+        # Split features only (no labels)
+        >>> data = list(range(100))
+        >>> train, test = train_test_split(data, test_size=0.2)
+        >>> len(train), len(test)
+        (80, 20)
+        
+        # Real-world example: Email spam detection
+        >>> emails = ["email1", "email2", "email3", "email4", "email5"]
+        >>> labels = [1, 0, 1, 0, 1]  # 1=spam, 0=not spam
+        >>> X_train, X_test, y_train, y_test = train_test_split(
+        ...     emails, labels, test_size=0.2, random_state=42
+        ... )
+        
+        # 70-30 split
+        >>> X_train, X_test, y_train, y_test = train_test_split(
+        ...     X, y, test_size=0.3
+        ... )
+        
+        # 60-20-20 split (train-val-test)
+        >>> X_temp, X_test, y_temp, y_test = train_test_split(
+        ...     X, y, test_size=0.2, random_state=42
+        ... )
+        >>> X_train, X_val, y_train, y_val = train_test_split(
+        ...     X_temp, y_temp, test_size=0.25, random_state=42  # 0.25 * 0.8 = 0.2
+        ... )
+    
+    Notes:
+        - Always split data BEFORE any preprocessing to avoid data leakage
+        - Use random_state for reproducible results
+        - Stratified splitting ensures balanced class distribution
+        - Common splits: 80-20, 70-30, 60-20-20 (train-val-test)
+        - Test data should NEVER be seen during training
+    
+    Raises:
+        ValueError: If test_size is not between 0 and 1
+        ValueError: If stratify=True but y is None
+        ValueError: If X and y have different lengths
+    
+    References:
+        - scikit-learn train_test_split: https://scikit-learn.org/stable/modules/generated/sklearn.model_selection.train_test_split.html
+        - ML best practices: https://developers.google.com/machine-learning/crash-course/training-and-test-sets/splitting-data
+    """
+    
+    # Validation
+    if not 0 < test_size < 1:
+        raise ValueError(f"test_size must be between 0 and 1, got {test_size}")
+    
+    if stratify and y is None:
+        raise ValueError("stratify=True requires y to be provided")
+    
+    # Convert to lists if numpy arrays
+    if isinstance(X, np.ndarray):
+        X = X.tolist()
+    if y is not None and isinstance(y, np.ndarray):
+        y = y.tolist()
+    
+    # Check lengths match
+    if y is not None and len(X) != len(y):
+        raise ValueError(f"X and y must have same length. Got X: {len(X)}, y: {len(y)}")
+    
+    n_samples = len(X)
+    n_test = int(n_samples * test_size)
+    n_train = n_samples - n_test
+    
+    # Set random seed
+    if random_state is not None:
+        random.seed(random_state)
+    
+    # Create indices
+    indices = list(range(n_samples))
+    
+    if stratify and y is not None:
+        # Stratified split - maintain class distribution
+        X_train, X_test = [], []
+        y_train, y_test = [], []
+        
+        # Group indices by class
+        class_indices = {}
+        for idx, label in enumerate(y):
+            if label not in class_indices:
+                class_indices[label] = []
+            class_indices[label].append(idx)
+        
+        # Split each class proportionally
+        for label, class_idx in class_indices.items():
+            if shuffle:
+                random.shuffle(class_idx)
+            
+            n_class_test = max(1, int(len(class_idx) * test_size))
+            
+            test_idx = class_idx[:n_class_test]
+            train_idx = class_idx[n_class_test:]
+            
+            X_test.extend([X[i] for i in test_idx])
+            y_test.extend([y[i] for i in test_idx])
+            X_train.extend([X[i] for i in train_idx])
+            y_train.extend([y[i] for i in train_idx])
+        
+        return X_train, X_test, y_train, y_test
+    
+    else:
+        # Regular split
+        if shuffle:
+            random.shuffle(indices)
+        
+        test_indices = indices[:n_test]
+        train_indices = indices[n_test:]
+        
+        X_train = [X[i] for i in train_indices]
+        X_test = [X[i] for i in test_indices]
+        
+        if y is not None:
+            y_train = [y[i] for i in train_indices]
+            y_test = [y[i] for i in test_indices]
+            return X_train, X_test, y_train, y_test
+        else:
+            return X_train, X_test
+
+
+def normalize_data(data: Union[List[float], np.ndarray]) -> List[float]:
+    """
+    Normalize data to range [0, 1] using min-max scaling.
+    
+    Args:
+        data: List or array of numerical values
+    
+    Returns:
+        list: Normalized values between 0 and 1
+    
+    Example:
+        >>> from ilovetools.data import normalize_data
+        >>> data = [1, 2, 3, 4, 5]
+        >>> normalized = normalize_data(data)
+        >>> print(normalized)
+        [0.0, 0.25, 0.5, 0.75, 1.0]
+    """
+    if isinstance(data, np.ndarray):
+        data = data.tolist()
+    
+    min_val = min(data)
+    max_val = max(data)
+    
+    if max_val == min_val:
+        return [0.0] * len(data)
+    
+    return [(x - min_val) / (max_val - min_val) for x in data]
+
+
+def standardize_data(data: Union[List[float], np.ndarray]) -> List[float]:
+    """
+    Standardize data to have mean=0 and std=1 (Z-score normalization).
+    
+    Args:
+        data: List or array of numerical values
+    
+    Returns:
+        list: Standardized values with mean=0, std=1
+    
+    Example:
+        >>> from ilovetools.data import standardize_data
+        >>> data = [1, 2, 3, 4, 5]
+        >>> standardized = standardize_data(data)
+        >>> print(standardized)
+        [-1.414, -0.707, 0.0, 0.707, 1.414]
+    """
+    if isinstance(data, np.ndarray):
+        data = data.tolist()
+    
+    mean = sum(data) / len(data)
+    variance = sum((x - mean) ** 2 for x in data) / len(data)
+    std = variance ** 0.5
+    
+    if std == 0:
+        return [0.0] * len(data)
+    
+    return [(x - mean) / std for x in data]

{ilovetools-0.1.1 → ilovetools-0.1.3/ilovetools.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ilovetools
-Version: 0.1.1
+Version: 0.1.3
 Summary: A comprehensive Python utility library with modular tools for AI/ML, data processing, and daily programming needs
 Home-page: https://github.com/AliMehdi512/ilovetools
 Author: Ali Mehdi

{ilovetools-0.1.1 → ilovetools-0.1.3}/ilovetools.egg-info/SOURCES.txt

@@ -17,6 +17,8 @@ ilovetools/audio/__init__.py
 ilovetools/automation/__init__.py
 ilovetools/conversion/__init__.py
 ilovetools/data/__init__.py
+ilovetools/data/feature_engineering.py
+ilovetools/data/preprocessing.py
 ilovetools/database/__init__.py
 ilovetools/datetime/__init__.py
 ilovetools/files/__init__.py

{ilovetools-0.1.1 → ilovetools-0.1.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "ilovetools"
-version = "0.1.1"
+version = "0.1.3"
 description = "A comprehensive Python utility library with modular tools for AI/ML, data processing, and daily programming needs"
 readme = "README.md"
 requires-python = ">=3.8"

{ilovetools-0.1.1 → ilovetools-0.1.3}/setup.py

@@ -5,7 +5,7 @@ with open("README.md", "r", encoding="utf-8") as fh:
 
 setup(
     name="ilovetools",
-    version="0.1.1",
+    version="0.1.2",
     author="Ali Mehdi",
     author_email="ali.mehdi.dev579@gmail.com",
     description="A comprehensive Python utility library with modular tools for AI/ML, data processing, and daily programming needs",

ilovetools-0.1.1/ilovetools/ai/embeddings.py

@@ -1,5 +0,0 @@
-"""
-Embedding utilities for text and vector operations
-"""
-
-__all__ = []

ilovetools-0.1.1/ilovetools/data/__init__.py

@@ -1,5 +0,0 @@
-"""
-Data processing and manipulation utilities
-"""
-
-__all__ = []