itertoolkit 1.5.5__tar.gz → 1.5.9__tar.gz

itertoolkit-1.5.9/IMPORTS.md

@@ -0,0 +1,48 @@
+# Imports Guide
+
+```python
+# Top-level section access
+from bm_preprocessing import DM
+from bm_preprocessing import IR
+from bm_preprocessing import PY
+from bm_preprocessing import Finals
+from bm_preprocessing import KALKI
+
+# Finals exports
+from bm_preprocessing.Finals import kaadhal
+from bm_preprocessing.Finals import raaka
+from bm_preprocessing.Finals import seedan
+from bm_preprocessing.Finals import vikram
+
+# DM exports
+from bm_preprocessing.DM import agg
+from bm_preprocessing.DM import dbscan
+from bm_preprocessing.DM import finals
+from bm_preprocessing.DM import gsp
+from bm_preprocessing.DM import test
+
+# IR exports
+from bm_preprocessing.IR import finals
+from bm_preprocessing.IR import pagerank
+from bm_preprocessing.IR import recommenders_pca
+from bm_preprocessing.IR import test
+
+# PY exports
+from bm_preprocessing.PY import lib_doc
+from bm_preprocessing.PY import python_doc
+
+# KALKI exports
+from bm_preprocessing.KALKI import collaborative_filtering
+from bm_preprocessing.KALKI import content_based_filtering
+from bm_preprocessing.KALKI import pagerank
+from bm_preprocessing.KALKI import pca
+from bm_preprocessing.KALKI import pca_svd
+from bm_preprocessing.KALKI import svd
+
+# Importer-layer access
+from bm_preprocessing.importer.DM import agg, dbscan, finals, gsp, test
+from bm_preprocessing.importer.IR import finals, pagerank, recommenders_pca, test
+from bm_preprocessing.importer.PY import lib_doc, python_doc
+from bm_preprocessing.importer.Finals import kaadhal, raaka, seedan, vikram
+from bm_preprocessing.importer.KALKI import collaborative_filtering, content_based_filtering, pagerank, pca, pca_svd, svd
+```

{itertoolkit-1.5.5 → itertoolkit-1.5.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: itertoolkit
-Version: 1.5.5
+Version: 1.5.9
 Summary: An itertools-inspired toolkit for cached iterator and data-structure processing
 Requires-Python: >=3.11
 Requires-Dist: gsppy>=5.3.0

{itertoolkit-1.5.5 → itertoolkit-1.5.9}/bm-eval-metrics.pyproject.toml

@@ -1,10 +1,11 @@
 [project]
 name = "bm-eval-metrics"
-version = "1.5.4"
+version = "1.5.8"
 description = "Python package providing easy-to-use evaluation metrics and utilities for Machine Learning"
 readme = "EVAL_README.md"
 requires-python = ">=3.11"
 dependencies = [
+    "groq>=1.1.2",
     "gsppy>=5.3.0",
     "matplotlib>=3.10.8",
     "networkx>=3.6.1",

{itertoolkit-1.5.5 → itertoolkit-1.5.9}/bm_preprocessing/importer/IR/__init__.py

@@ -2,5 +2,6 @@ from .finals import finals
 from .pagerank import pagerank
 from .recommenders_pca import recommenders_pca
 from .test import test
+from .pagerank_mat import pagerank_mat
 
-__all__ = ["finals", "test", "pagerank", "recommenders_pca"]
+__all__ = ["finals", "test", "pagerank", "recommenders_pca", "pagerank_mat"]

itertoolkit-1.5.9/bm_preprocessing/importer/IR/pagerank_mat.py

@@ -0,0 +1,6 @@
+from pathlib import Path
+
+from .._module_printer import SourceCodeModule
+
+_source_file = Path(__file__).parents[2] / "src" / "IR" / "pagerank_mat.py"
+pagerank_mat = SourceCodeModule("bm_preprocessing.IR.pagerank_mat", _source_file)

{itertoolkit-1.5.5 → itertoolkit-1.5.9}/bm_preprocessing/importer/KALKI/__init__.py

@@ -4,6 +4,7 @@ from .pagerank import pagerank
 from .pca import pca
 from .pca_svd import pca_svd
 from .svd import svd
+from .pagerank_mat import pagerank_mat
 
 __all__ = [
     "collaborative_filtering",
@@ -12,4 +13,5 @@ __all__ = [
     "pca",
     "pca_svd",
     "svd",
+    "pagerank_mat",
 ]

itertoolkit-1.5.9/bm_preprocessing/importer/KALKI/pagerank_mat.py

@@ -0,0 +1,6 @@
+from pathlib import Path
+
+from .._module_printer import SourceCodeModule
+
+_source_file = Path(__file__).parents[2] / "src" / "KALKI" / "pagerank_mat.py"
+pagerank_mat = SourceCodeModule("bm_preprocessing.KALKI.pagerank_mat", _source_file)

itertoolkit-1.5.9/bm_preprocessing/importer/PY/__init__.py

@@ -0,0 +1,5 @@
+from .lib_doc import lib_doc
+from .python_doc import python_doc
+from .vis_doc import vis_doc
+
+__all__ = ["lib_doc", "python_doc", "vis_doc"]

itertoolkit-1.5.9/bm_preprocessing/importer/PY/vis_doc.py

@@ -0,0 +1,6 @@
+from pathlib import Path
+
+from .._module_printer import SourceCodeModule
+
+_source_file = Path(__file__).parents[2] / "src" / "PY" / "vis_doc.py"
+vis_doc = SourceCodeModule("bm_preprocessing.PY.vis_doc", _source_file)

itertoolkit-1.5.9/bm_preprocessing/src/IR/pagerank_mat.py

@@ -0,0 +1,114 @@
+import matplotlib.pyplot as plt
+import networkx as nx
+import numpy as np
+import pandas as pd
+
+# ===== INPUT =====
+pages = ["A", "B", "C", "D"]
+A = np.array(
+    [
+        [0, 1, 1, 0],  # A -> B,C
+        [0, 0, 1, 0],  # B -> C
+        [1, 0, 0, 0],  # C -> A
+        [0, 0, 1, 0],  # D -> C
+    ],
+    dtype=float,
+)
+
+d = 0.85
+max_iter = 20
+tol = 1e-8
+n = len(pages)
+
+# ===== STEP 1: TRANSITION MATRIX (COLUMN STOCHASTIC) =====
+S = np.zeros_like(A)
+
+for j in range(n):
+    out_degree = A[j].sum()
+    if out_degree > 0:
+        S[j] = A[j] / out_degree
+    else:
+        S[j] = np.ones(n) / n  # dangling node
+
+S = S.T  # convert to column-stochastic
+
+print("Transition Matrix S:")
+print(pd.DataFrame(S, index=pages, columns=pages))
+
+# ===== STEP 2: GOOGLE MATRIX =====
+M = d * S + (1 - d) / n * np.ones((n, n))
+
+print("\nGoogle Matrix M:")
+print(pd.DataFrame(M, index=pages, columns=pages))
+
+# ===== STEP 3: INITIAL RANK =====
+r = np.ones(n) / n
+history = [r.copy()]
+
+print("\nInitial PageRank:")
+print(pd.DataFrame({"Page": pages, "PR": r}))
+
+# ===== STEP 4: ITERATIONS =====
+for it in range(1, max_iter + 1):
+    r_new = M @ r
+    history.append(r_new.copy())
+
+    print(f"\nIteration {it}")
+    print(pd.DataFrame({"Page": pages, "PR": r_new.round(6)}))
+
+    diff = np.linalg.norm(r_new - r, 1)
+    r = r_new
+
+    if diff < tol:
+        break
+
+# ===== FINAL RESULT =====
+final_df = pd.DataFrame({"Page": pages, "Final PR": r})
+final_df = final_df.sort_values("Final PR", ascending=False)
+
+print("\nFinal PageRank:")
+print(final_df.round(6))
+
+# ===== GRAPH VISUALIZATION (NODE SIZE ∝ PageRank) =====
+G = nx.DiGraph()
+for i, src in enumerate(pages):
+    for j, dst in enumerate(pages):
+        if A[i, j] == 1:
+            G.add_edge(src, dst)
+
+plt.figure(figsize=(6, 4))
+pos = nx.spring_layout(G, seed=42)
+
+# --- Min-Max scaling for node sizes ---
+pr_dict = {pages[i]: r[i] for i in range(n)}
+pr_values = np.array([pr_dict[p] for p in G.nodes()])
+
+min_size, max_size = 500, 5000
+sizes = min_size + (pr_values - pr_values.min()) / (pr_values.max() - pr_values.min()) * (max_size - min_size)
+
+nx.draw(G, pos, with_labels=True, node_size=sizes, arrows=True)
+plt.title("Graph Visualization (node size ∝ PageRank)")
+plt.show()
+
+# ===== VISUALIZATION 2: CONVERGENCE =====
+history_arr = np.array(history)
+
+plt.figure()
+for i, p in enumerate(pages):
+    plt.plot(history_arr[:, i], label=p)
+
+plt.xlabel("Iteration")
+plt.ylabel("PageRank")
+plt.title("PageRank Convergence")
+plt.legend()
+plt.grid()
+plt.show()
+
+# ===== VISUALIZATION 3: FINAL SCORES =====
+plt.figure()
+plt.bar(final_df["Page"], final_df["Final PR"])
+plt.xlabel("Page")
+plt.ylabel("PageRank Score")
+plt.title("Final PageRank Ranking")
+plt.grid()
+plt.show()

{itertoolkit-1.5.5 → itertoolkit-1.5.9}/bm_preprocessing/src/KALKI/collaborative_filtering.py

@@ -224,7 +224,7 @@ for i in range(df_iu.shape[0]):
         if i == ti and j == tu:
             ax.add_patch(
                 plt.Rectangle(
-                    (j - 0.5, i - 0.5), 1, 1, fill=True, color="#4fc3f7", zorder=2
+                    (j - 0.5, i - 0.5), 1, 1, fill=True, color="lightblue", zorder=2
                 )
             )
             ax.text(

{itertoolkit-1.5.5 → itertoolkit-1.5.9}/bm_preprocessing/src/KALKI/content_based_filtering.py

@@ -369,12 +369,12 @@ def set_tick_labels(ax, df):
 ax = axes[0, 0]
 ti = list(df_iu.index).index(target_item)
 tu = list(df_iu.columns).index(target_user)
-im = ax.imshow(df_iu.values.astype(float), cmap="YlGn", aspect="auto", vmin=1, vmax=5)
+im = ax.imshow(df_iu.values.astype(float), cmap="viridis", aspect="auto", vmin=1, vmax=5)
 for i in range(df_iu.shape[0]):
     for j in range(df_iu.shape[1]):
         val = df_iu.iloc[i, j]
         if i == ti and j == tu:
-            ax.add_patch(plt.Rectangle((j-.5, i-.5), 1, 1, fill=True, color="#4fc3f7", zorder=2))
+            ax.add_patch(plt.Rectangle((j-.5, i-.5), 1, 1, fill=True, color="lightblue", zorder=2))
             ax.text(j, i, "?", ha="center", va="center", fontsize=9, fontweight="bold", color="navy", zorder=3)
         elif pd.notna(val):
             ax.text(j, i, int(val), ha="center", va="center", fontsize=8)

{itertoolkit-1.5.5 → itertoolkit-1.5.9}/bm_preprocessing/src/KALKI/pagerank.py

@@ -104,8 +104,8 @@ for it in range(1, max_iter + 1):
 
         if terms:
             # Standard formula shown in full symbolic form
-            print(f"  PR({p}) = (1-d)/N + d × ( {' + '.join(terms)} )")
-            print(f"         = {base:.4f} + {d} × ( {' + '.join(nums)} )")
+            print(f"  PR({p}) = (1-d)/N + d x ( {' + '.join(terms)} )")
+            print(f"         = {base:.4f} + {d} x ( {' + '.join(nums)} )")
             # Google formula (symbolic) — uncomment if using Formula B above
             # print(f"  [Google] PR({p}) = (1-d) + d × ( {' + '.join(terms)} )")
             # print(f"         = {1-d:.4f} + {d} × ( {' + '.join(nums)} )")
@@ -132,7 +132,7 @@ for it in range(1, max_iter + 1):
     print(iter_df.to_string(index=False))
 
     if diff < tol:
-        print(f"\n  ✓ Converged at iteration {it}  (Σ|ΔPR| = {diff:.2e} < tol={tol})")
+        print(f"\n Converged at iteration {it}  (Σ|ΔPR| = {diff:.2e} < tol={tol})")
         break
 
 # ===== CONVERGENCE TABLE =====

itertoolkit-1.5.9/bm_preprocessing/src/KALKI/pagerank_mat.py

@@ -0,0 +1,164 @@
+import matplotlib.pyplot as plt
+import networkx as nx
+import numpy as np
+import pandas as pd
+from matplotlib.gridspec import GridSpec
+
+# ===== INPUT =====
+pages = ["A", "B", "C", "D"]
+A = np.array(
+    [
+        [0, 1, 1, 0],  # A -> B,C
+        [0, 0, 1, 0],  # B -> C
+        [1, 0, 0, 0],  # C -> A
+        [0, 0, 1, 0],  # D -> C
+    ],
+    dtype=float,
+)
+
+d = 0.85
+max_iter = 20
+tol = 1e-8
+n = len(pages)
+
+# ===== STEP 1: TRANSITION MATRIX =====
+S = np.zeros_like(A)
+
+for j in range(n):
+    out_degree = A[j].sum()
+    if out_degree > 0:
+        S[j] = A[j] / out_degree
+    else:
+        S[j] = np.ones(n) / n  # dangling node
+
+S = S.T  # column-stochastic
+
+# ===== STEP 2: GOOGLE MATRIX =====
+M = d * S + (1 - d) / n * np.ones((n, n))
+
+# ===== STEP 3: INITIAL RANK =====
+r = np.ones(n) / n
+history = [r.copy()]
+
+# ===== STEP 4: ITERATIONS =====
+for _ in range(max_iter):
+    r_new = M @ r
+    history.append(r_new.copy())
+
+    diff = np.linalg.norm(r_new - r, 1)
+    r = r_new
+
+    if diff < tol:
+        print(f"Converged after {_+1} iterations with diff={diff:.2e}")
+        break
+
+# ===== FINAL RESULT =====
+final_df = pd.DataFrame({"Page": pages, "Final PR": r})
+final_df = final_df.sort_values("Final PR", ascending=False)
+
+print("\nFinal PageRank:")
+print(final_df.round(6))
+
+# ===== TABULATE ITERATIONS =====
+history_arr = np.array(history)
+
+iter_cols = [f"Iter_{i}" for i in range(history_arr.shape[0])]
+iter_df = pd.DataFrame(history_arr.T, index=pages, columns=iter_cols)
+
+print("\nPageRank Iterations Table:")
+print(iter_df.round(6).to_string())
+
+# ===== CONVERT FOR VISUALIZATION =====
+pr = {pages[i]: r[i] for i in range(n)}
+
+history_dict = []
+for vec in history:
+    history_dict.append({pages[i]: vec[i] for i in range(n)})
+
+# ===== GRAPH =====
+G = nx.DiGraph()
+for i, src in enumerate(pages):
+    for j, dst in enumerate(pages):
+        if A[i, j] == 1:
+            G.add_edge(src, dst)
+
+# ===== VISUALIZATION =====
+fig = plt.figure(figsize=(16, 10))
+gs = GridSpec(2, 3, figure=fig, hspace=0.45, wspace=0.35)
+
+ax_graph = fig.add_subplot(gs[:, :2])
+ax_bar = fig.add_subplot(gs[0, 2])
+ax_conv = fig.add_subplot(gs[1, 2])
+
+# ── GRAPH ─────────────────────────────
+pos = nx.spring_layout(G, seed=42, k=2.2)
+
+pr_vals = np.array([pr[p] for p in G.nodes()])
+den = (pr_vals.max() - pr_vals.min()) + 1e-9  # avoid zero division
+pr_norm = (pr_vals - pr_vals.min()) / den
+node_sizes = pr_norm * 3500 + 900
+
+node_colors = [plt.cm.tab10(i / len(pages)) for i in range(len(G.nodes()))]
+
+nx.draw_networkx_edges(
+    G, pos, ax=ax_graph,
+    arrows=True, arrowsize=22,
+    connectionstyle="arc3,rad=0.12",
+    width=1.8,
+)
+
+nx.draw_networkx_nodes(
+    G, pos, ax=ax_graph,
+    node_size=node_sizes,
+    node_color=node_colors,
+)
+
+labels = {p: f"{p}\n{pr[p]:.4f}" for p in G.nodes()}
+nx.draw_networkx_labels(
+    G, pos, labels=labels, ax=ax_graph,
+    font_size=10, font_weight="bold",
+)
+
+ax_graph.set_title("PageRank Graph (node size ∝ PR)", fontweight="bold")
+ax_graph.axis("off")
+
+# ── BAR CHART ─────────────────────────
+sorted_pages = final_df["Page"].tolist()
+sorted_prs = final_df["Final PR"].tolist()
+
+bars = ax_bar.barh(sorted_pages, sorted_prs)
+
+for bar, val in zip(bars, sorted_prs):
+    ax_bar.text(
+        bar.get_width() + 0.003,
+        bar.get_y() + bar.get_height() / 2,
+        f"{val:.4f}",
+        va="center",
+        fontsize=9,
+    )
+
+ax_bar.set_title("Final PR Ranking", fontweight="bold")
+ax_bar.set_xlim(0, max(sorted_prs) * 1.25)
+ax_bar.invert_yaxis()
+
+# ── CONVERGENCE ───────────────────────
+for p in pages:
+    vals = [history_dict[i][p] for i in range(len(history_dict))]
+    ax_conv.plot(
+        range(len(vals)),
+        vals,
+        marker="o",
+        linewidth=1.8,
+        label=p,
+    )
+
+ax_conv.set_title("Convergence", fontweight="bold")
+ax_conv.set_xlabel("Iteration")
+ax_conv.set_ylabel("PageRank")
+ax_conv.legend()
+ax_conv.grid(True, alpha=0.3)
+
+# ===== FINAL LAYOUT =====
+fig.suptitle("PageRank Algorithm", fontsize=16, fontweight="bold")
+plt.tight_layout()
+plt.show()

itertoolkit-1.5.9/bm_preprocessing/src/PY/vis_doc.py

@@ -0,0 +1,247 @@
+# =========================================================
+# VISUALIZATION CHEAT SHEET (Matplotlib, Seaborn, Plotly, NetworkX)
+# =========================================================
+
+import numpy as np
+import pandas as pd
+
+import matplotlib.pyplot as plt
+import seaborn as sns
+import plotly.express as px
+import networkx as nx
+
+# =========================================================
+# SAMPLE DATA
+# =========================================================
+np.random.seed(42)
+
+x = np.arange(1, 11)
+y = np.random.randint(10, 100, size=10)
+
+df = pd.DataFrame({
+    "x": x,
+    "y": y,
+    "category": ["A", "B"] * 5
+})
+
+# =========================================================
+# MATPLOTLIB
+# =========================================================
+
+# ---- BAR CHART ----
+plt.figure()
+plt.bar(x, y)
+plt.title("Bar Chart")
+plt.xlabel("X")
+plt.ylabel("Y")
+plt.show()
+
+# ---- PIE CHART ----
+plt.figure()
+plt.pie(y, labels=x, autopct="%1.1f%%")
+plt.title("Pie Chart")
+plt.show()
+
+# ---- HISTOGRAM ----
+plt.figure()
+plt.hist(y, bins=5)
+plt.title("Histogram")
+plt.show()
+
+# ---- LINE CHART ----
+plt.figure()
+plt.plot(x, y, marker='o')
+plt.title("Line Chart")
+plt.show()
+
+# ---- BOX PLOT ----
+plt.figure()
+plt.boxplot(y)
+plt.title("Box Plot")
+plt.show()
+
+# ---- HEATMAP (imshow) ----
+data = np.random.rand(5, 5)
+plt.figure()
+plt.imshow(data, cmap='viridis')
+plt.colorbar()
+plt.title("Heatmap (imshow)")
+plt.show()
+
+
+# =========================================================
+# 2SEABORN
+# =========================================================
+
+# ---- BAR ----
+sns.barplot(x="x", y="y", data=df)
+plt.title("Seaborn Bar")
+plt.show()
+
+# ---- PIE (not native, use matplotlib) ----
+
+# ---- HISTOGRAM ----
+sns.histplot(df["y"], bins=5, kde=True)
+plt.title("Seaborn Histogram")
+plt.show()
+
+# ---- LINE ----
+sns.lineplot(x="x", y="y", data=df)
+plt.title("Seaborn Line")
+plt.show()
+
+# ---- BOX ----
+sns.boxplot(y="y", data=df)
+plt.title("Seaborn Box")
+plt.show()
+
+# ---- HEATMAP ----
+sns.heatmap(data, annot=True, cmap="coolwarm")
+plt.title("Seaborn Heatmap")
+plt.show()
+
+
+# =========================================================
+# PLOTLY (INTERACTIVE)
+# =========================================================
+
+# ---- BAR ----
+fig = px.bar(df, x="x", y="y", title="Plotly Bar")
+fig.show()
+
+# ---- PIE ----
+fig = px.pie(df, values="y", names="x", title="Plotly Pie")
+fig.show()
+
+# ---- HISTOGRAM ----
+fig = px.histogram(df, x="y", nbins=5, title="Plotly Histogram")
+fig.show()
+
+# ---- LINE ----
+fig = px.line(df, x="x", y="y", title="Plotly Line")
+fig.show()
+
+# ---- BOX ----
+fig = px.box(df, y="y", title="Plotly Box")
+fig.show()
+
+# ---- HEATMAP ----
+fig = px.imshow(data, title="Plotly Heatmap")
+fig.show()
+
+
+# =========================================================
+#  NETWORKX (GRAPH VISUALIZATION)
+# =========================================================
+
+G = nx.DiGraph()
+edges = [("A", "B"), ("A", "C"), ("B", "C"), ("C", "A")]
+G.add_edges_from(edges)
+
+plt.figure()
+pos = nx.spring_layout(G)
+nx.draw(G, pos, with_labels=True, node_size=1000, arrows=True)
+plt.title("Network Graph")
+plt.show()
+
+
+# =========================================================
+# MATPLOTLIB NUANCES / CONFIGURATION
+# =========================================================
+
+# ---- MULTIPLE PLOTS (SUBPLOTS) ----
+fig, axs = plt.subplots(2, 2, figsize=(8, 6))
+
+axs[0, 0].plot(x, y)
+axs[0, 0].set_title("Line")
+
+axs[0, 1].bar(x, y)
+axs[0, 1].set_title("Bar")
+
+axs[1, 0].hist(y)
+axs[1, 0].set_title("Histogram")
+
+axs[1, 1].boxplot(y)
+axs[1, 1].set_title("Box")
+
+plt.tight_layout()
+plt.show()
+
+
+# ---- MULTIPLE LINES ----
+plt.figure()
+plt.plot(x, y, label="Line1")
+plt.plot(x, y[::-1], label="Line2")
+plt.legend()
+plt.title("Multiple Lines")
+plt.show()
+
+
+# ---- AXES CONFIG ----
+plt.figure()
+plt.plot(x, y)
+plt.xlim(0, 12)
+plt.ylim(0, 120)
+plt.xticks(rotation=45)
+plt.grid(True)
+plt.title("Axis Config")
+plt.show()
+
+
+# ---- STYLE ----
+plt.style.use("ggplot")
+
+
+# =========================================================
+# 🎛️ PARAMETERS CHEAT SHEET
+# =========================================================
+
+"""
+MATPLOTLIB:
+-----------
+plt.plot(x, y, color='blue', linestyle='--', marker='o')
+plt.bar(x, y, width=0.5)
+plt.hist(data, bins=10)
+plt.imshow(data, cmap='viridis')
+
+COMMON PARAMS:
+color, cmap, alpha, linewidth, linestyle, marker, label
+
+
+SEABORN:
+--------
+sns.barplot(x=, y=, data=, palette=)
+sns.histplot(data, bins=, kde=True)
+sns.heatmap(data, annot=True, cmap=)
+
+COMMON PARAMS:
+palette, hue, style, size, linewidth
+
+
+PLOTLY:
+-------
+px.bar(df, x=, y=, color=)
+px.line(df, x=, y=)
+px.imshow(data)
+
+COMMON PARAMS:
+title, color, labels, template
+
+
+NETWORKX:
+---------
+nx.draw(G, pos, node_size=, node_color=, with_labels=True)
+
+LAYOUTS:
+spring_layout, circular_layout, shell_layout
+
+
+GENERAL:
+--------
+figsize=(w, h)
+title()
+xlabel(), ylabel()
+legend()
+grid(True)
+tight_layout()
+"""

itertoolkit-1.5.9/bm_preprocessing/vsk.py

@@ -0,0 +1,66 @@
+from __future__ import annotations
+from groq import Groq
+
+# ─── HYPERPARAMETERS ──────────────────────────────────────────────────────────
+API_KEY    = "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"
+MODEL_NAME = "openai/gpt-oss-120b"
+TEMPERATURE = 0.2
+
+SYSTEM_PROMPT = """
+You are an expert Python engineer and code reviewer.
+
+When given a query or task, you MUST respond with:
+1. Production-ready Python code that is:
+   - Fully error-proof (all exceptions handled gracefully)
+   - Bug-free and logically correct
+   - Edge-case covered (empty input, None, type mismatches, boundary values, etc.)
+   - Clean, readable, and PEP-8 compliant
+   - Well-structured with clear variable names and docstrings
+
+2. A short "Changes / Config" section listing:
+   - Any hyperparameters or constants the user should adjust
+   - File paths, API keys, or environment variables needed
+   - Optional improvements or flags
+
+3. A brief explanation of what the code does and why key decisions were made.
+
+Always wrap code in proper Python markdown code blocks.
+Never leave placeholders like `pass` or `# TODO` unless explicitly asked.
+""".strip()
+# ─────────────────────────────────────────────────────────────────────────────
+
+
+def parrot(query: str) -> str:
+    """
+    Send a query to Groq and stream the model response to the terminal,
+    then return the full response text.
+
+    Args:
+        query: A non-empty string prompt/question.
+
+    Returns:
+        The model's response as a stripped string.
+
+    Raises:
+        ValueError: If query is not a non-empty string.
+        groq.APIError: On API-level failures.
+    """
+    if not isinstance(query, str) or not query.strip():
+        raise ValueError("query must be a non-empty string")
+
+    client = Groq(api_key=API_KEY)
+
+    response = client.chat.completions.create(
+        model=MODEL_NAME,
+        messages=[
+            {"role": "system", "content": SYSTEM_PROMPT},
+            {"role": "user",   "content": query.strip()},
+        ],
+        temperature=TEMPERATURE,
+    )
+
+    content = response.choices[0].message.content
+    result  = content.strip() if content else ""
+
+    print(result)
+    return result

{itertoolkit-1.5.5 → itertoolkit-1.5.9}/itertoolkit.pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "itertoolkit"
-version = "1.5.4"
+version = "1.5.8"
 description = "An itertools-inspired toolkit for cached iterator and data-structure processing"
 readme = "ITER_README.md"
 requires-python = ">=3.11"

{itertoolkit-1.5.5 → itertoolkit-1.5.9}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "itertoolkit"
-version = "1.5.5"
+version = "1.5.9"
 description = "An itertools-inspired toolkit for cached iterator and data-structure processing"
 readme = "ITER_README.md"
 requires-python = ">=3.11"

itertoolkit-1.5.5/IMPORTS.md

@@ -1,156 +0,0 @@
-# Imports Guide
-
-Below are the same import patterns grouped package-wise.
-
-## 1) bm_preprocessing
-
-```python
-# Top-level section access
-from bm_preprocessing import DM
-from bm_preprocessing import IR
-from bm_preprocessing import PY
-from bm_preprocessing import Finals
-from bm_preprocessing import KALKI
-
-# Finals exports
-from bm_preprocessing.Finals import kaadhal
-from bm_preprocessing.Finals import raaka
-from bm_preprocessing.Finals import seedan
-from bm_preprocessing.Finals import vikram
-
-# DM exports
-from bm_preprocessing.DM import agg
-from bm_preprocessing.DM import dbscan
-from bm_preprocessing.DM import finals
-from bm_preprocessing.DM import gsp
-from bm_preprocessing.DM import test
-
-# IR exports
-from bm_preprocessing.IR import finals
-from bm_preprocessing.IR import pagerank
-from bm_preprocessing.IR import recommenders_pca
-from bm_preprocessing.IR import test
-
-# PY exports
-from bm_preprocessing.PY import lib_doc
-from bm_preprocessing.PY import python_doc
-
-# KALKI exports
-from bm_preprocessing.KALKI import collaborative_filtering
-from bm_preprocessing.KALKI import content_based_filtering
-from bm_preprocessing.KALKI import pagerank
-from bm_preprocessing.KALKI import pca
-from bm_preprocessing.KALKI import pca_svd
-from bm_preprocessing.KALKI import svd
-
-# Importer-layer access
-from bm_preprocessing.importer.DM import agg, dbscan, finals, gsp, test
-from bm_preprocessing.importer.IR import finals, pagerank, recommenders_pca, test
-from bm_preprocessing.importer.PY import lib_doc, python_doc
-from bm_preprocessing.importer.Finals import kaadhal, raaka, seedan, vikram
-from bm_preprocessing.importer.KALKI import collaborative_filtering, content_based_filtering, pagerank, pca, pca_svd, svd
-```
-
-## 2) bm_eval_metrics
-
-```python
-# Top-level section access
-from bm_eval_metrics import DM
-from bm_eval_metrics import IR
-from bm_eval_metrics import PY
-from bm_eval_metrics import Finals
-from bm_eval_metrics import KALKI
-
-# Finals exports
-from bm_eval_metrics.Finals import kaadhal
-from bm_eval_metrics.Finals import raaka
-from bm_eval_metrics.Finals import seedan
-from bm_eval_metrics.Finals import vikram
-
-# DM exports
-from bm_eval_metrics.DM import agg
-from bm_eval_metrics.DM import dbscan
-from bm_eval_metrics.DM import finals
-from bm_eval_metrics.DM import gsp
-from bm_eval_metrics.DM import test
-
-# IR exports
-from bm_eval_metrics.IR import finals
-from bm_eval_metrics.IR import pagerank
-from bm_eval_metrics.IR import recommenders_pca
-from bm_eval_metrics.IR import test
-
-# PY exports
-from bm_eval_metrics.PY import lib_doc
-from bm_eval_metrics.PY import python_doc
-
-# KALKI exports
-from bm_eval_metrics.KALKI import collaborative_filtering
-from bm_eval_metrics.KALKI import content_based_filtering
-from bm_eval_metrics.KALKI import pagerank
-from bm_eval_metrics.KALKI import pca
-from bm_eval_metrics.KALKI import pca_svd
-from bm_eval_metrics.KALKI import svd
-
-# Importer-layer access
-from bm_eval_metrics.importer.DM import agg, dbscan, finals, gsp, test
-from bm_eval_metrics.importer.IR import finals, pagerank, recommenders_pca, test
-from bm_eval_metrics.importer.PY import lib_doc, python_doc
-from bm_eval_metrics.importer.Finals import kaadhal, raaka, seedan, vikram
-from bm_eval_metrics.importer.KALKI import collaborative_filtering, content_based_filtering, pagerank, pca, pca_svd, svd
-```
-
-## 3) itertoolkit
-
-```python
-# Top-level section access
-from itertoolkit import DM
-from itertoolkit import IR
-from itertoolkit import PY
-from itertoolkit import Finals
-from itertoolkit import KALKI
-
-# Finals exports
-from itertoolkit.Finals import kaadhal
-from itertoolkit.Finals import raaka
-from itertoolkit.Finals import seedan
-from itertoolkit.Finals import vikram
-
-# DM exports
-from itertoolkit.DM import agg
-from itertoolkit.DM import dbscan
-from itertoolkit.DM import finals
-from itertoolkit.DM import gsp
-from itertoolkit.DM import test
-
-# IR exports
-from itertoolkit.IR import finals
-from itertoolkit.IR import pagerank
-from itertoolkit.IR import recommenders_pca
-from itertoolkit.IR import test
-
-# PY exports
-from itertoolkit.PY import lib_doc
-from itertoolkit.PY import python_doc
-
-# KALKI exports
-from itertoolkit.KALKI import collaborative_filtering
-from itertoolkit.KALKI import content_based_filtering
-from itertoolkit.KALKI import pagerank
-from itertoolkit.KALKI import pca
-from itertoolkit.KALKI import pca_svd
-from itertoolkit.KALKI import svd
-
-# Importer-layer access
-from itertoolkit.importer.DM import agg, dbscan, finals, gsp, test
-from itertoolkit.importer.IR import finals, pagerank, recommenders_pca, test
-from itertoolkit.importer.PY import lib_doc, python_doc
-from itertoolkit.importer.Finals import kaadhal, raaka, seedan, vikram
-from itertoolkit.importer.KALKI import collaborative_filtering, content_based_filtering, pagerank, pca, pca_svd, svd
-```
-
-Example:
-
-```python
-from bm_preprocessing.Finals import raaka
-```

itertoolkit-1.5.5/bm_preprocessing/importer/PY/__init__.py

@@ -1,4 +0,0 @@
-from .lib_doc import lib_doc
-from .python_doc import python_doc
-
-__all__ = ["lib_doc", "python_doc"]