itertoolkit 1.5.0__py3-none-any.whl

bm_preprocessing/src/PY/lib_doc.py

@@ -0,0 +1,295 @@
+import numpy as np
+import pandas as pd
+
+# ===========================================================
+# 📂 FILE READING & INITIAL INSPECTION
+# ===========================================================
+
+# Load data (CSV, Excel, JSON)
+df = pd.read_csv("data.csv")  # Load CSV
+df = pd.read_excel("data.xlsx")  # Load Excel
+df = pd.read_json("data.json")  # Load JSON
+
+# Quick Inspection
+print(df.head())
+print(df.info())
+print(df.describe())  # Basic stats & info
+print(df.shape)  # (rows, columns)
+print(df.columns.tolist())  # List all column names
+print(df.dtypes)  # Data types of each column
+print(df.isnull().sum())  # Count NaNs per column
+print(df.nunique())  # Unique values per column
+print(df.value_counts("col"))  # Frequency of each value
+
+# ===========================================================
+# 🔍 SELECTION & MANIPULATION
+# ===========================================================
+
+# Selecting rows and columns
+cols = df[["col1", "col2"]]  # Select multiple columns
+rows = df.iloc[0:10]  # Select first 10 rows by index
+filtered = df[df["age"] > 25]  # Select rows based on condition
+cell = df.loc[0, "col1"]  # Select specific cell (label-based)
+cell = df.iloc[0, 0]  # Select specific cell (index-based)
+filtered = df.query("age > 25 and city == 'NYC'")  # Query-based filtering
+sampled = df.sample(n=5, random_state=42)  # Random sample of rows
+
+# Sorting
+sorted_df = df.sort_values("col", ascending=False)  # Sort by column descending
+sorted_df = df.sort_values(
+    ["col1", "col2"], ascending=[True, False]
+)  # Multi-column sort
+
+# Stacking & Merging
+df1 = pd.DataFrame({"id": [1, 2], "val": ["A", "B"]})
+df2 = pd.DataFrame({"id": [2, 3], "val": ["C", "D"]})
+df_stacked = pd.concat([df1, df2], axis=0)  # Stack vertically (rows)
+df_wide = pd.concat([df1, df2], axis=1)  # Stack horizontally (columns)
+df_merged = pd.merge(
+    df1, df2, on="id", how="inner"
+)  # SQL-like join (inner/left/right/outer)
+
+# ===========================================================
+# 🛠️ DATA CLEANING & PROCESSING
+# ===========================================================
+
+# Handling Missing Values
+df["col"].fillna(df["col"].mean(), inplace=True)  # Impute by mean (one-liner)
+df["col"].fillna(df["col"].median(), inplace=True)  # Impute by median
+df["col"].fillna(df["col"].mode()[0], inplace=True)  # Impute by mode (categorical)
+df.dropna(axis=0, inplace=True)  # Drop rows with any NaN values
+df.dropna(
+    subset=["col1", "col2"], inplace=True
+)  # Drop rows with NaN in specific columns
+df.ffill(inplace=True)  # Forward fill NaN values
+df.bfill(inplace=True)  # Backward fill NaN values
+
+# Transformations
+df["new_col"] = df["col"].apply(lambda x: x**2)  # Apply custom function
+grouped = df.groupby("category")["sales"].sum()  # Groupby & aggregate
+grouped = df.groupby("cat").agg(
+    {"sales": "sum", "qty": "mean"}
+)  # Multiple aggregations
+df["cat_code"] = df["category"].astype("category").cat.codes  # Quick label encoding
+df["col"] = df["col"].str.lower()  # String lowercase
+df["col"] = df["col"].str.replace("old", "new")  # String replace
+df["col"] = df["col"].str.strip()  # Strip whitespace
+df["binned"] = pd.cut(df["age"], bins=[0, 18, 35, 60, 100])  # Binning/discretization
+df = pd.get_dummies(df, columns=["city"], drop_first=True)  # One-hot encode columns
+df.rename(columns={"old_name": "new_name"}, inplace=True)  # Rename columns
+df.drop(columns=["col1", "col2"], inplace=True)  # Drop columns
+df.drop_duplicates(inplace=True)  # Remove duplicate rows
+
+# Type Conversions
+df["col"] = df["col"].astype(int)  # Convert column type
+df["date"] = pd.to_datetime(df["date_str"])  # Parse dates
+
+# ===========================================================
+# 🔢 NUMPY ESSENTIALS
+# ===========================================================
+
+arr = np.array([1, 2, 3])  # Create array
+reshaped = arr.reshape(1, -1)  # Reshape for sklearn (2D)
+mean_val = np.mean(arr)
+std_val = np.std(arr)  # Basic stats
+mask = arr[arr > 2]  # Boolean indexing/filtering
+zeros = np.zeros((3, 3))
+ones = np.ones((3, 3))  # Zero/One matrices
+eye = np.eye(3)  # Identity matrix
+rand = np.random.rand(3, 3)  # Random matrix [0,1)
+dot = np.dot(arr, arr)  # Dot product
+norm = np.linalg.norm(arr)  # Vector norm (L2)
+log = np.log2(arr)  # Log base 2 (entropy)
+unique, counts = np.unique(arr, return_counts=True)  # Unique values & counts
+
+# ===========================================================
+# 🤖 SCIKIT-LEARN PREPROCESSING
+# ===========================================================
+
+from sklearn.impute import SimpleImputer
+from sklearn.model_selection import train_test_split
+from sklearn.preprocessing import (
+    LabelEncoder,
+    MinMaxScaler,
+    OneHotEncoder,
+    StandardScaler,
+)
+
+# Splitting Data
+X = df.drop("target", axis=1)
+y = df["target"]
+X_train, X_test, y_train, y_test = train_test_split(
+    X, y, test_size=0.2, random_state=42
+)
+
+# Imputing (Standard approach)
+imputed = SimpleImputer(strategy="mean").fit_transform(
+    df[["num_col"]]
+)  # Impute missing with mean
+imputed = SimpleImputer(strategy="most_frequent").fit_transform(
+    df[["cat"]]
+)  # Impute categorical
+
+# Scaling & Encoding
+scaled = StandardScaler().fit_transform(
+    df[["age", "salary"]]
+)  # Standardize (mean=0, std=1)
+scaled = MinMaxScaler().fit_transform(df[["age", "salary"]])  # Normalize to [0, 1]
+encoded = OneHotEncoder().fit_transform(df[["gender"]]).toarray()  # One-hot encode
+le = LabelEncoder().fit_transform(df["target"])  # Encode target labels
+
+# Pipeline (all-in-one)
+from sklearn.compose import ColumnTransformer
+from sklearn.pipeline import Pipeline
+
+processor = ColumnTransformer(
+    [("num", StandardScaler(), ["age"]), ("cat", OneHotEncoder(), ["city"])]
+)
+
+# ===========================================================
+# ⛏️ DATA MINING (DM) ESSENTIALS
+# ===========================================================
+
+from sklearn.cluster import KMeans
+from sklearn.ensemble import (
+    AdaBoostClassifier,
+    BaggingClassifier,
+    RandomForestClassifier,
+)
+from sklearn.metrics import (
+    accuracy_score,
+    auc,
+    classification_report,
+    confusion_matrix,
+    f1_score,
+    precision_recall_curve,
+    precision_score,
+    recall_score,
+    roc_curve,
+)
+from sklearn.preprocessing import label_binarize
+from sklearn.tree import DecisionTreeClassifier
+
+# --- Decision Trees ---
+dt = DecisionTreeClassifier(random_state=42).fit(
+    X_train, y_train
+)  # Train decision tree
+y_pred = dt.predict(X_test)  # Predict
+print(accuracy_score(y_test, y_pred))  # Accuracy
+
+# --- Ensemble Methods ---
+bag = BaggingClassifier(n_estimators=10, random_state=42).fit(
+    X_train, y_train
+)  # Bagging
+ada = AdaBoostClassifier(n_estimators=50, random_state=42).fit(
+    X_train, y_train
+)  # AdaBoost
+rf = RandomForestClassifier(n_estimators=100, random_state=42).fit(
+    X_train, y_train
+)  # Random Forest
+
+# --- Clustering ---
+kmeans = KMeans(n_clusters=3, random_state=42).fit(X)  # K-Means clustering
+labels = kmeans.labels_  # Cluster labels
+centers = kmeans.cluster_centers_  # Cluster centroids
+
+# --- Classification Metrics ---
+print(accuracy_score(y_test, y_pred))  # Accuracy = (TP+TN)/(TP+TN+FP+FN)
+print(precision_score(y_test, y_pred, average="weighted"))  # Precision = TP/(TP+FP)
+print(recall_score(y_test, y_pred, average="weighted"))  # Recall = TP/(TP+FN)
+print(f1_score(y_test, y_pred, average="weighted"))  # F1 = 2*(P*R)/(P+R)
+print(confusion_matrix(y_test, y_pred))  # Confusion matrix
+print(classification_report(y_test, y_pred))  # Full report
+
+# --- ROC & AUC ---
+y_bin = label_binarize(y_test, classes=[0, 1, 2])  # Binarize for multiclass ROC
+y_proba = rf.predict_proba(X_test)
+fpr, tpr, _ = roc_curve(y_bin[:, 0], y_proba[:, 0])  # ROC curve (per class)
+roc_auc = auc(fpr, tpr)  # AUC score
+
+# --- Apriori / Association Rules (manual) ---
+from itertools import combinations
+
+support = lambda itemset, txns: sum(1 for t in txns if itemset.issubset(t)) / len(txns)
+transactions = [
+    ["milk", "bread"],
+    ["milk", "diaper", "beer", "bread"],
+    ["milk", "bread"],
+]
+items = set(item for t in transactions for item in t)
+freq_items = {frozenset([i]) for t in transactions for i in t}  # C1 candidates
+pairs = [
+    frozenset(c) for c in combinations(sorted(items), 2)
+]  # Generate candidate pairs
+
+# --- Entropy & Information Gain (ID3) ---
+entropy = lambda probs: -sum(p * np.log2(p) for p in probs if p > 0)  # Shannon entropy
+info_gain = lambda parent_ent, children: parent_ent - sum(
+    w * entropy(c) for w, c in children
+)
+gini = lambda probs: 1 - sum(p**2 for p in probs)  # Gini impurity
+
+# ===========================================================
+# 🔎 INFORMATION RETRIEVAL (IR) ESSENTIALS
+# ===========================================================
+
+import math
+from collections import Counter
+
+# --- Term Frequency (TF) ---
+# TF(t, d) = count(t in d) / total_terms_in_d
+tf = lambda term, doc: doc.count(term) / len(doc)  # Term frequency
+
+# --- Inverse Document Frequency (IDF) ---
+# IDF(t) = log(N / df(t))  where N = total docs, df(t) = docs containing t
+idf = lambda term, docs: math.log(len(docs) / sum(1 for d in docs if term in d))
+
+# --- TF-IDF ---
+# TF-IDF(t, d) = TF(t, d) * IDF(t)
+tfidf = lambda term, doc, docs: tf(term, doc) * idf(term, docs)  # TF-IDF score
+
+# --- BM25 ---
+# BM25(t, d) = IDF(t) * (TF * (k1 + 1)) / (TF + k1 * (1 - b + b * |d| / avgdl))
+k1 = 1.5
+b = 0.75  # BM25 parameters
+docs = [["term1", "term2"], ["term2", "term3"], ["term1", "term3", "term4"]]
+avgdl = np.mean([len(d) for d in docs])  # Average document length
+
+# --- Boolean Retrieval ---
+# AND: set(doc1_terms) & set(doc2_terms)
+# OR:  set(doc1_terms) | set(doc2_terms)
+# NOT: set(all_terms) - set(doc_terms)
+bool_and = lambda q_terms, doc: all(t in doc for t in q_terms)  # Boolean AND query
+bool_or = lambda q_terms, doc: any(t in doc for t in q_terms)  # Boolean OR query
+
+# --- Cosine Similarity ---
+# cos(A, B) = (A · B) / (||A|| * ||B||)
+cosine_sim = lambda a, b: np.dot(a, b) / (np.linalg.norm(a) * np.linalg.norm(b))
+
+# --- Jaccard Similarity ---
+# J(A, B) = |A ∩ B| / |A ∪ B|
+jaccard = lambda a, b: len(a & b) / len(a | b)  # Jaccard similarity (sets)
+
+# --- Tokenization & Text Processing ---
+tokens = "hello world foo bar".lower().split()  # Basic tokenization
+vocab = set(tokens)  # Vocabulary
+bow = Counter(tokens)  # Bag of words
+from sklearn.feature_extraction.text import TfidfVectorizer
+
+tfidf_matrix = TfidfVectorizer().fit_transform(
+    ["doc1 text", "doc2 text"]
+)  # TF-IDF vectorizer
+
+# --- Inverted Index ---
+inv_index = {}  # Build inverted index
+for doc_id, doc in enumerate(docs):
+    for term in doc:
+        inv_index.setdefault(term, set()).add(doc_id)
+
+# --- Precision & Recall (IR) ---
+# Precision@k = relevant_in_top_k / k
+# Recall@k    = relevant_in_top_k / total_relevant
+precision_at_k = lambda retrieved, relevant, k: len(set(retrieved[:k]) & relevant) / k
+recall_at_k = lambda retrieved, relevant, k: len(set(retrieved[:k]) & relevant) / len(
+    relevant
+)

bm_preprocessing/src/PY/python_doc.py

@@ -0,0 +1,177 @@
+"""
+=============================================================================
+PYTHON BASICS CHEAT SHEET
+=============================================================================
+A quick reference guide for core Python concepts, data structures, and features.
+"""
+
+# =============================================================================
+# 1. LISTS (Mutable, Ordered)
+# =============================================================================
+my_list = [1, 2, 3, "a", "b"]
+
+# Operations
+my_list.append(4)  # Add to end: [1, 2, 3, 'a', 'b', 4]
+my_list.insert(0, 0)  # Insert at index: [0, 1, 2, 3, 'a', 'b', 4]
+my_list.extend([5, 6])  # Append multiple: [0, 1, 2, 3, 'a', 'b', 4, 5, 6]
+my_list.pop()  # Remove & return last item (6)
+my_list.pop(1)  # Remove & return item at index 1 (1)
+my_list.remove("a")  # Remove first occurrence of 'a'
+my_list.reverse()  # Reverse in place
+# my_list.sort()            # Sort in place (requires same types)
+# sorted(my_list)           # Return new sorted list
+my_list.clear()  # Empty the list
+count = my_list.count(2)  # Count occurrences
+idx = my_list.index(3)  # Find index of first occurrence
+
+# Slicing: list[start:stop:step]
+# my_list[1:4] (index 1 to 3), my_list[::-1] (reverse)
+
+# =============================================================================
+# 2. SETS (Mutable, Unordered, Unique Elements)
+# =============================================================================
+my_set = {1, 2, 3}
+empty_set = set()  # Note: {} creates an empty dict, not a set
+
+# Operations
+my_set.add(4)  # Add element
+my_set.update([5, 6])  # Add multiple elements
+my_set.remove(6)  # Remove element (raises KeyError if not found)
+my_set.discard(10)  # Remove element (safe, no error if not found)
+my_set.pop()  # Remove & return arbitrary element
+my_set.clear()  # Empty the set
+
+set_a, set_b = {1, 2}, {2, 3}
+union = set_a | set_b  # {1, 2, 3} (or set_a.union(set_b))
+intersection = set_a & set_b  # {2} (or set_a.intersection(set_b))
+diff = set_a - set_b  # {1} (or set_a.difference(set_b))
+sym_diff = set_a ^ set_b  # {1, 3} (or set_a.symmetric_difference(set_b))
+
+# =============================================================================
+# 3. TUPLES (Immutable, Ordered)
+# =============================================================================
+my_tuple = (1, 2, 3, 2)
+single_tuple = (1,)  # Comma needed for single-element tuple
+
+# Operations (Very limited since immutable)
+count = my_tuple.count(2)  # Count occurrences (2)
+idx = my_tuple.index(3)  # Find index of first occurrence (2)
+# Tuples support unpacking: a, b, c, d = my_tuple
+
+# =============================================================================
+# 4. DICTIONARIES (Mutable, Key-Value Pairs, Unordered before Python 3.7)
+# =============================================================================
+my_dict = {"name": "Alice", "age": 25}
+
+# Operations
+my_dict["city"] = "NYC"  # Add or update key
+val = my_dict.get("age")  # Safe get (returns None if not found, instead of KeyError)
+val = my_dict.get("x", 0)  # Safe get with default value
+keys = my_dict.keys()  # dict_keys(['name', 'age', 'city'])
+values = my_dict.values()  # dict_values(['Alice', 25, 'NYC'])
+items = my_dict.items()  # dict_items([('name', 'Alice'), ...])
+
+# Removal
+popped_val = my_dict.pop("age")  # Remove key 'age' and return value
+popped_item = my_dict.popitem()  # Remove & return last key-value pair as tuple
+# del my_dict['name']                   # Delete key
+my_dict.clear()  # Empty dict
+my_dict.update({"a": 1, "b": 2})  # Merge / Update with another dict
+
+# =============================================================================
+# 5. LIST / DICT / SET COMPREHENSIONS
+# =============================================================================
+# List Comprehension: [expression for item in iterable if condition]
+squares = [x**2 for x in range(10) if x % 2 == 0]  # [0, 4, 16, 36, 64]
+
+# Dict Comprehension: {key_expr: val_expr for item in iterable if condition}
+sq_dict = {x: x**2 for x in range(5)}  # {0: 0, 1: 1, 2: 4, 3: 9, 4: 16}
+
+# Set Comprehension: {expression for item in iterable if condition}
+sq_set = {x**2 for x in [-1, 1, 2]}  # {1, 4}
+
+# Generator Expression: (expression for item in iterable if condition)
+gen = (x**2 for x in range(10))  # Lazy evaluation
+
+# =============================================================================
+# 6. LAMBDA FUNCTIONS, MAP, FILTER, REDUCE
+# =============================================================================
+# lambda arguments: expression
+add = lambda x, y: x + y
+print(add(2, 3))  # 5
+
+nums = [1, 2, 3, 4]
+# map: apply function to all items
+mapped = list(map(lambda x: x * 2, nums))  # [2, 4, 6, 8]
+
+# filter: keep items where function returns True
+filtered = list(filter(lambda x: x % 2 == 0, nums))  # [2, 4]
+
+# reduce (requires functools): cumulative application
+from functools import reduce
+
+product = reduce(lambda x, y: x * y, nums)  # 24
+
+# Sort with lambda key
+words = ["apple", "banana", "cherry"]
+words.sort(key=lambda w: len(w))  # Sort by length
+
+
+# =============================================================================
+# 7. CLASSES AND OBJECTS (OOP)
+# =============================================================================
+class Animal:
+    """Base class for animals."""
+
+    species_count = 0  # Class attribute
+
+    def __init__(self, name):
+        self.name = name  # Instance attribute
+        Animal.species_count += 1
+
+    def speak(self):
+        """Instance method"""
+        return "Some sound"
+
+    @classmethod
+    def get_count(cls):
+        """Class method: takes class as first arg"""
+        return cls.species_count
+
+    @staticmethod
+    def is_alive():
+        """Static method: no implicit self or cls args"""
+        return True
+
+
+# Inheritance
+class Dog(Animal):
+    def __init__(self, name, breed):
+        super().__init__(name)  # Call parent constructor
+        self.breed = breed
+
+    def speak(self):  # Method Overriding
+        return "Woof!"
+
+
+dog = Dog("Buddy", "Golden Retriever")
+print(dog.speak())  # "Woof!"
+print(Animal.get_count())  # 1
+
+# =============================================================================
+# 8. FILE HANDLING
+# =============================================================================
+# Using 'with' is a best practice, as it automatically closes the file
+# Modes: 'r' (read), 'w' (write, truncates), 'a' (append), 'r+' (read & write), 'b' (binary)
+
+# Write to file
+with open("example.txt", "w", encoding="utf-8") as file:
+    file.write("Hello World\nLine 2")
+
+# Read from file
+with open("example.txt", "r", encoding="utf-8") as file:
+    content = file.read()  # Read entire file
+    # file.seek(0)              # Reset cursor to start
+    # lines = file.readlines()  # Read lines into a list
+    # for line in file:         # Iterate line by line (memory efficient)
+    #     print(line.strip())

bm_preprocessing/src/__init__.py

@@ -0,0 +1 @@
+"""Raw source snippets shipped with the package."""

itertoolkit-1.5.0.dist-info/METADATA

@@ -0,0 +1,120 @@
+Metadata-Version: 2.4
+Name: itertoolkit
+Version: 1.5.0
+Summary: An itertools-inspired toolkit for cached iterator and data-structure processing
+Requires-Python: >=3.11
+Requires-Dist: gsppy>=5.3.0
+Requires-Dist: matplotlib>=3.10.8
+Requires-Dist: networkx>=3.6.1
+Requires-Dist: numpy>=2.4.4
+Requires-Dist: pandas>=3.0.2
+Requires-Dist: plotly>=6.6.0
+Requires-Dist: scikit-learn>=1.8.0
+Requires-Dist: scipy>=1.17.1
+Requires-Dist: seaborn>=0.13.2
+Description-Content-Type: text/markdown
+
+# itertoolkit
+
+Functions creating iterators and cached data pipelines for efficient looping.
+
+`itertoolkit` is an `itertools`-inspired wrapper focused on practical data processing. It keeps the lazy, composable style of iterator algebra, then adds cache-aware helpers so repeated list and data-structure transformations run faster.
+
+The goal is simple:
+
+- Keep memory usage low with lazy iterators.
+- Speed up repeated workloads with caching.
+- Make iterator pipelines readable and reusable.
+
+## Installation
+
+```bash
+pip install itertoolkit
+```
+
+## Quick Start
+
+```python
+from itertools import count, islice
+
+# Install name: itertoolkit
+# Current import path in this repo remains bm_preprocessing
+from bm_preprocessing import IR, DM
+
+# Example: base itertools stream
+stream = (x * x for x in count(1))
+print(list(islice(stream, 5)))  # [1, 4, 9, 16, 25]
+
+# Example: cached computation workflow (concept)
+# result = itertoolkit.cached_map(expensive_fn, dataset, cache_key="v1")
+```
+
+## Why It Is Faster
+
+`itertoolkit` performance comes from combining:
+
+- Lazy iteration, so intermediate materialization is avoided.
+- Cache-first wrappers, so repeated transformations are reused.
+- Composable pipelines, so complex loops stay compact and optimized.
+
+In repeated analytics or feature-building jobs, the first pass computes and stores results, and later passes can fetch from cache instead of recomputing every step.
+
+## Core Iterator Families
+
+### General iterators
+
+| Iterator concept | Input | Output shape | Typical use |
+| --- | --- | --- | --- |
+| Running reduction | iterable, func | incremental totals | rolling stats |
+| Batching | iterable, n | tuples of size n | chunk processing |
+| Chaining | multiple iterables | one continuous stream | merging sources |
+| Selection | data + selectors | filtered stream | mask-based filtering |
+| Windowing | iterable | adjacent pairs/windows | transition analysis |
+| Truncation | predicate/slice | bounded output | safe handling of infinite streams |
+
+### Combinatoric iterators
+
+| Iterator concept | Output |
+| --- | --- |
+| Cartesian products | all pairings across inputs |
+| Permutations | order-sensitive tuples |
+| Combinations | order-insensitive unique tuples |
+| Combinations with replacement | tuples allowing repeated values |
+
+## Pipeline Pattern
+
+Use this pattern when processing large lists, tables, graphs, or text records:
+
+1. Start from one or more iterables.
+2. Chain filtering, mapping, grouping, and batching.
+3. Add cache boundaries around expensive stages.
+4. Materialize only where needed (`list`, `tuple`, `DataFrame`, model input).
+
+```python
+from itertools import chain
+
+sources = [[1, 2, 3], [4, 5], [6]]
+pipeline = (x * 10 for x in chain.from_iterable(sources) if x % 2 == 0)
+print(list(pipeline))  # [20, 40, 60]
+```
+
+## Caching Strategy
+
+Recommended caching behavior for data-heavy workloads:
+
+- Key by transformation signature and input fingerprint.
+- Keep deterministic steps cacheable.
+- Invalidate cache on function/version changes.
+- Persist long-running results between sessions.
+
+This makes repeated preprocessing and feature extraction significantly cheaper.
+
+## Compatibility Note
+
+Package distribution name is `itertoolkit`.
+
+Current code in this repository still exposes the import path `bm_preprocessing` for compatibility with existing users. If needed, a follow-up release can add a top-level `itertoolkit` import alias as well.
+
+## License
+
+MIT

itertoolkit-1.5.0.dist-info/RECORD

@@ -0,0 +1,45 @@
+bm_preprocessing/__init__.py,sha256=780DeJ5tt1xkg572jEcYXd1z8Jj7QteRv9tfRcwqamo,353
+bm_preprocessing/importer/__init__.py,sha256=3144LTa5i9lr6vJZRdvDyqNmRPRM7FWMOj0aOS5NHM8,186
+bm_preprocessing/importer/_module_printer.py,sha256=rWR9jyfr7ACt5qVeZ4uRHfaZLOb4oKzSIP319rzp4Po,649
+bm_preprocessing/importer/DM/__init__.py,sha256=NytK_IN5e7Lxdfh_T1tjLQ0JFrcLoupjdGOJpU5FwWw,180
+bm_preprocessing/importer/DM/agg.py,sha256=QE1GMhYzSDQ9fs1Ymjy80Bwfsfv7mOlm9tWcgCDljx4,211
+bm_preprocessing/importer/DM/dbscan.py,sha256=P-pnTG7PX2E4Z6yCBVgYhodVSTrrYvWNbJEFHW8744M,220
+bm_preprocessing/importer/DM/finals.py,sha256=ldHMMjmRaG8ToFoc0ALzpLQ2nqaqIe-gjIg7_Odrw7g,220
+bm_preprocessing/importer/DM/gsp.py,sha256=tSb0uOc_eistbdpgeykdjLQoOCZrhaT9rVHrFrpsoWs,211
+bm_preprocessing/importer/DM/test.py,sha256=tS-NUS0fIxmEyc7B_YhLh6duT8k87x0wCfq0O1oG1VM,214
+bm_preprocessing/importer/Finals/__init__.py,sha256=chN1hYPGdRM1GX4q54APyDgOSBWNKcSXaexnxnVYdUA,195
+bm_preprocessing/importer/Finals/kaadhal.py,sha256=7gaY85G_sRr3XlbLmbPMUHUjz2S0vkBHfTkF-xjruiE,231
+bm_preprocessing/importer/Finals/raaka.py,sha256=OdmLlgq4u-OpvdZe8ruRlD0g4jxpg8USqIdN2YJ_6lo,225
+bm_preprocessing/importer/Finals/seedan.py,sha256=fEXKRMA_rnDyM3iN5Ka76pv9SaDfeVht_tHK-oHOS2U,228
+bm_preprocessing/importer/Finals/vikram.py,sha256=cijp6K4snmdD_o4vbUceWvN-w7Z1qDmQkOWa1PzHBlM,228
+bm_preprocessing/importer/IR/__init__.py,sha256=ibuzqcqquie8vom3Yj_J4pnjlosUvEwVW2tyFz5d8wo,196
+bm_preprocessing/importer/IR/finals.py,sha256=aTI2-mVhDBInWYjNMdpPbwId_bK9jrXMTML22F2RzNk,220
+bm_preprocessing/importer/IR/pagerank.py,sha256=XH8NxjKm1lczJ0PrQV1QZujogNn5gMJN6pUlth9itxw,226
+bm_preprocessing/importer/IR/recommenders_pca.py,sha256=5Ui3ZK6iVXEAVDlC72LgPKjB0uyW1OSl7F0kz4QYfek,258
+bm_preprocessing/importer/IR/test.py,sha256=RlRBb6usbeKuWUtrs6QKiahK5FZ4p4A7Y-Qoy4eQjMU,214
+bm_preprocessing/importer/PY/__init__.py,sha256=0Dsh94cSFgb1N4We7zwYzQDR3YHC-Y7pcDvHR-9FKAs,105
+bm_preprocessing/importer/PY/lib_doc.py,sha256=z3H3JO5GSVrDJZy8PEzSGlM_tq_dH5E-4sCjzbPHvzg,223
+bm_preprocessing/importer/PY/python_doc.py,sha256=5HCNqn4Y3jEYTt97koY34LAKODQX7HcB93aApbQL54w,232
+bm_preprocessing/src/__init__.py,sha256=Y4g952oNndkD4fX7aRnbrOVTObZOyhfM7yYewiZaR-U,53
+bm_preprocessing/src/DM/__init__.py,sha256=tGoE9Z5I3cdOxyosBmA5fp6Keh2sO2o0hbhf3SGeBEM,36
+bm_preprocessing/src/DM/agg.py,sha256=IptAnnInn37qkADRGLWL41XqMz99kksIwBPAPVCLeaA,6816
+bm_preprocessing/src/DM/dbscan.py,sha256=j06WbIN-nws9D5BKnEQW_oUl5QZPqPpZdOzKWqhXz5A,6337
+bm_preprocessing/src/DM/finals.py,sha256=gIj5e37rvfvsotomjWSTBFd8gX6ax9XA7loadMuyu0g,337
+bm_preprocessing/src/DM/gsp.py,sha256=EYjEe245MMExdyQQxPrsVnkr_g9-sTOGyAoBZVAyXVs,10944
+bm_preprocessing/src/DM/test.py,sha256=sgNQvC72u767xjqeBHsJxHvAaULv0s7d8frLr7vacvg,342
+bm_preprocessing/src/Finals/__init__.py,sha256=SQpE3o4m6Dkcrm8bv-Qaf29wo7a-sDIOwsB-nN-sPHo,31
+bm_preprocessing/src/Finals/kaadhal.py,sha256=XsnzDLcnK6zrGFwDoFYhIsVb2jfLlfYuX-c7Dh_sJX0,38558
+bm_preprocessing/src/Finals/raaka.py,sha256=PzgfzO_FigPZ9J-PTgWO2KcReOKQFjQtJxIGsQC5bZk,40431
+bm_preprocessing/src/Finals/seedan.py,sha256=6g7wDwpsBv0BavLsR-U4AmjlDRrcelTZaWGlAP7_Yo8,31711
+bm_preprocessing/src/Finals/vikram.py,sha256=GbqoPpa4dg4Q9gGDZF4leUfGzrVwMbId1f73-ooU7cI,12841
+bm_preprocessing/src/IR/__init__.py,sha256=ngrkbmeRSLuVoNAztpNYt6WxYhftH0PSNP72sb7TbaE,27
+bm_preprocessing/src/IR/finals.py,sha256=XvPbcxUo5ib-KkhClTKHgAcNYX3w9KSgMrgdCXStVCQ,217
+bm_preprocessing/src/IR/pagerank.py,sha256=UdRvgkezmYrgG_RK_h3kC9-qnZDcoE7tAw_VYqkuRvo,2989
+bm_preprocessing/src/IR/recommenders_pca.py,sha256=pBz5HDwtyGavITDkvBVJtGgHcyl1sGgmcvkCOt9VNuw,14181
+bm_preprocessing/src/IR/test.py,sha256=tdS9WKDBl7-zMu-ETnVSYgAUkqR-nSnB7Sb7AlnJNO4,222
+bm_preprocessing/src/PY/__init__.py,sha256=v-U6e8H9-BNFcb24QEDYMPKiTaFT_q_NB7WGBFpA_jc,39
+bm_preprocessing/src/PY/lib_doc.py,sha256=7zPuq5Ez_NPmtaeBRkKq2vA9mU6Tgf4bFuDqgZ9TnjI,11302
+bm_preprocessing/src/PY/python_doc.py,sha256=iPKngoIgDRtrXxao5WVlx1ZaLmQIs5cf3x39aHLG34o,7088
+itertoolkit-1.5.0.dist-info/METADATA,sha256=gJLZSTVSGPE8mwJ_2ayQM2_VMJe4zArD_go8KbbUALA,3918
+itertoolkit-1.5.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+itertoolkit-1.5.0.dist-info/RECORD,,

itertoolkit-1.5.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.29.0
+Root-Is-Purelib: true
+Tag: py3-none-any