ilovetools 0.1.1__tar.gz → 0.1.2__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ilovetools
-Version: 0.1.1
+Version: 0.1.2
 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.2}/ilovetools/__init__.py

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

{ilovetools-0.1.1 → ilovetools-0.1.2}/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.2/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.2/ilovetools/data/__init__.py

@@ -0,0 +1,11 @@
+"""
+Data processing and manipulation utilities
+"""
+
+from .preprocessing import train_test_split, normalize_data, standardize_data
+
+__all__ = [
+    'train_test_split',
+    'normalize_data',
+    'standardize_data',
+]

ilovetools-0.1.2/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.2/ilovetools.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ilovetools
-Version: 0.1.1
+Version: 0.1.2
 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.2}/ilovetools.egg-info/SOURCES.txt

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

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

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "ilovetools"
-version = "0.1.1"
+version = "0.1.2"
 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.2}/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__ = []