quicklearnkit 0.3.2__tar.gz → 0.4.1__tar.gz

quicklearnkit-0.4.1/PKG-INFO

@@ -0,0 +1,88 @@
+Metadata-Version: 2.4
+Name: quicklearnkit
+Version: 0.4.1
+Summary: Learning-first machine learning utilities library for simplified imports, sampling, splitting, and probabilistic preprocessing.
+Author: Hazi Afrid
+License: MIT License
+        
+        Copyright (c) 2025 Masterhazi
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+        
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy
+Requires-Dist: pandas
+Requires-Dist: scikit-learn
+Requires-Dist: xgboost
+Requires-Dist: seaborn
+Requires-Dist: matplotlib
+Dynamic: license-file
+
+
+# QuickLearnKit
+
+[![PyPI version](https://img.shields.io/pypi/v/quicklearnkit.svg)](https://pypi.org/project/quicklearnkit/)
+[![Python versions](https://img.shields.io/pypi/pyversions/quicklearnkit.svg)](https://pypi.org/project/quicklearnkit/)
+[![Documentation Status](https://readthedocs.org/projects/quicklearnkit/badge/?version=latest)](https://quicklearnkit.readthedocs.io/en/latest/)
+[![License](https://img.shields.io/pypi/l/quicklearnkit.svg)](LICENSE)
+
+QuickLearnKit is a **learning-first machine learning utilities library** designed to simplify common ML workflows while preserving full control for advanced users.
+
+It provides:
+
+- Simplified model imports  
+- Sampling and dataset utilities  
+- Train–test splitting  
+- Probabilistic, group-aware imputation  
+- Teaching-friendly visualization wrappers  
+- Notebook → Script pipeline compilation  
+
+---
+
+## Installation
+
+```bash
+pip install quicklearnkit
+````
+
+---
+
+## Documentation
+
+Full documentation is available at:
+
+👉 [https://quicklearnkit.readthedocs.io/en/latest/](https://quicklearnkit.readthedocs.io/en/latest/)
+
+---
+
+## Philosophy
+
+> Remove mechanical friction so students can focus on concepts, not syntax.
+
+QuickLearnKit bridges:
+
+Learning → Experimentation → Structured building
+
+---
+
+## License
+
+MIT License

{quicklearnkit-0.3.2 → quicklearnkit-0.4.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "quicklearnkit"
-version = "0.3.2"
+version = "0.4.1"
 description = "Learning-first machine learning utilities library for simplified imports, sampling, splitting, and probabilistic preprocessing."
 readme = "readme.md"
 license = { file = "LICENSE" }

quicklearnkit-0.4.1/quicklearnkit/pipeline.py

@@ -0,0 +1,255 @@
+import inspect
+from typing import Callable, List, Dict, Optional
+
+
+class Pipeline:
+    def __init__(self):
+        self._committed: List[Dict] = []
+        self._compiled: bool = False
+        self._imports = set()
+
+
+    def commit(
+        self,
+        func: Callable = None,
+        inputs: Optional[List[str]] = None,
+        outputs: Optional[List[str]] = None,
+        stage: Optional[str] = None,
+        mode: Optional[str] = None,
+    ):
+        
+        # Semi-auto commit mode
+        
+        if mode == "functions":
+            import inspect
+
+            caller_globals = inspect.currentframe().f_back.f_globals
+            new_functions = []
+
+            for name, obj in caller_globals.items():
+
+                if not inspect.isfunction(obj):
+                    continue
+
+                if not hasattr(obj, "__code__"):
+                    continue
+
+                # Must belong to caller's module
+                if obj.__module__ != caller_globals.get("__name__"):
+                    continue
+
+                # Skip private
+                if name.startswith("_"):
+                    continue
+
+                # Ensure top-level only
+                if obj.__qualname__ != obj.__name__:
+                    continue
+
+                # Skip already committed
+                if any(entry["func"] == obj for entry in self._committed):
+                    continue
+
+                new_functions.append(obj)
+
+            if not new_functions:
+                print("[QuickLearn] ⚠ No new top-level functions found.")
+                return
+
+            for fn in new_functions:
+                self._committed.append({
+                    "func": fn,
+                    "inputs": [],
+                    "outputs": [],
+                    "stage": stage or "General"
+                })
+                print(f"[QuickLearn] ✅ Auto-committed: {fn.__name__}")
+
+            return
+
+        if self._compiled:
+            raise RuntimeError("Pipeline already compiled. Reset before committing again.")
+
+        if not callable(func):
+            raise TypeError("commit() expects a callable function.")
+        
+        # Guard: func must be provided in manual mode
+        if func is None:
+            raise ValueError("commit() requires a function unless mode='functions' is used.")
+
+        # Guard: block lambdas
+        if func.__name__ == "<lambda>":
+            raise ValueError("Cannot commit lambda functions.")
+
+        # Guard: only allow top-level functions
+        if func.__qualname__ != func.__name__:
+            raise ValueError("Only top-level functions can be committed.")
+
+        # Guard: must be user-defined Python function (not builtin)
+        if not hasattr(func, "__code__"):
+            raise ValueError("Only user-defined Python functions can be committed.")
+
+        
+        for entry in self._committed:
+            if entry["func"] == func:
+                # Update metadata instead of skipping
+                if inputs is not None:
+                    entry["inputs"] = inputs
+                if outputs is not None:
+                    entry["outputs"] = outputs
+                if stage is not None:
+                    entry["stage"] = stage
+
+                print(f"[QuickLearn] 🔄 Updated metadata for: {func.__name__}")
+                return
+
+        self._committed.append({
+            "func": func,
+            "inputs": inputs or [],
+            "outputs": outputs or [],
+            "stage": stage or "General"
+        })
+
+        print(f"[QuickLearn] ✅ Committed: {func.__name__}")
+
+    def summary(self):
+        if not self._committed:
+            print("[QuickLearn] No committed functions.")
+            return
+
+        print("\n[QuickLearn] 📦 Pipeline Summary\n")
+
+        for i, entry in enumerate(self._committed, start=1):
+            print(f"{i}. {entry['func'].__name__}")
+            print(f"   Stage: {entry['stage']}")
+            print(f"   Inputs: {entry['inputs']}")
+            print(f"   Outputs: {entry['outputs']}\n")
+    
+    def add_import(self, imports):
+        before = len(self._imports)
+        if isinstance(imports, str):
+            lines = imports.strip().split("\n")
+        elif isinstance(imports, list):
+            lines = imports
+        else:
+            raise TypeError("add_import() expects a string or list of strings.")
+        for line in lines:
+            cleaned = line.strip()
+            if not cleaned:
+                continue
+
+            if not (cleaned.startswith("import ") or cleaned.startswith("from ")):
+                raise ValueError(f"Invalid import statement: {cleaned}")
+
+            self._imports.add(cleaned)
+        after = len(self._imports)
+        print(f"[QuickLearn] 📦 Registered {after - before} new import(s).")
+
+
+    def _validate_dependencies(self, strict: bool = False):
+        print("[QuickLearn] 🔍 Validating dependencies...")
+
+        available_outputs = set()
+        warnings = []
+
+        for entry in self._committed:
+            func_name = entry["func"].__name__
+            inputs = entry["inputs"]
+            outputs = entry["outputs"]
+
+            # Check for missing inputs
+            missing = [inp for inp in inputs if inp not in available_outputs]
+
+            if missing:
+                message = (
+                    f"[QuickLearn Warning] '{func_name}' expects input(s) {missing} "
+                    f"which were not produced by previous steps."
+                )
+                warnings.append(message)
+
+            # Check for duplicate outputs
+            duplicates = [out for out in outputs if out in available_outputs]
+            if duplicates:
+                message = (
+                    f"[QuickLearn Warning] '{func_name}' produces duplicate output(s) {duplicates}."
+                )
+                warnings.append(message)
+
+            available_outputs.update(outputs)
+
+        if warnings:
+            if strict:
+                raise RuntimeError("\n".join(warnings))
+            else:
+                for w in warnings:
+                    print(w)
+                print(f"[QuickLearn] ⚠ {len(warnings)} warning(s) detected.")
+        else:
+            print("[QuickLearn] ✅ No dependency issues detected.")
+
+
+
+    def compile(self, filename: str, validate: bool | str = True, group_comments: bool = True):
+
+        if self._compiled:
+            raise RuntimeError("Pipeline already compiled.")
+
+        if not self._committed:
+            raise RuntimeError("No committed functions found. Nothing to compile.")
+
+        print(f"[QuickLearn] 🚀 Compiling {len(self._committed)} committed functions...")
+
+        if validate:
+            if validate == "strict":
+                self._validate_dependencies(strict=True)
+            else:
+                self._validate_dependencies(strict=False)
+
+
+        with open(filename, "w") as f:
+
+            # Warn if no imports registered
+            if not self._imports:
+                print("[QuickLearn Warning] No imports registered. Compiled file may fail if dependencies are missing.")
+
+            # Write registered imports
+            for imp in sorted(self._imports):
+                f.write(imp + "\n")
+
+            if self._imports:
+                f.write("\n\n")
+
+            current_stage = None
+
+            for entry in self._committed:
+
+                if group_comments and entry["stage"] != current_stage:
+                    current_stage = entry["stage"]
+                    f.write("# ==============================\n")
+                    f.write(f"# {current_stage}\n")
+                    f.write("# ==============================\n\n")
+
+                try:
+                    source = inspect.getsource(entry["func"])
+                except OSError:
+                    raise RuntimeError(
+                        f"Could not retrieve source for function '{entry['func'].__name__}'. "
+                        "Ensure it is defined in a proper Python file or notebook cell."
+                    )
+
+                f.write(source)
+                f.write("\n\n")
+
+            f.write("if __name__ == '__main__':\n")
+            f.write("    print('Pipeline ready.')\n")
+
+        self._compiled = True
+        print("[QuickLearn] ✅ Compilation successful.")
+        print(f"[QuickLearn] 📄 Pipeline written to '{filename}'")
+
+
+    def reset(self):
+        self._committed.clear()
+        self._compiled = False
+        self._imports.clear()
+        print("[QuickLearn] 🔄 Pipeline reset.")

{quicklearnkit-0.3.2 → quicklearnkit-0.4.1}/quicklearnkit/quickimports.py

@@ -11,6 +11,7 @@ from .classifier import LogisticRegressionmodel, KNeighborsClassifiermodel, Deci
 from .utils import create_random, ProbabilisticImputer
 from .randomizer import Sampler
 from .split import train_test_split
+from .pipeline import Pipeline
 from .plotting import (
     bar_plot,
     line_plot,
@@ -26,6 +27,6 @@ __all__=[
     'KNeighborsClassifiermodel', 'DecisionTreeClassifiermodel', 'RandomForestClassifiermodel','AdaBoostClassifiermodel', 
     'GradientBoostingClassifiermodel', 'XGBClassifiermodel', 'SVClassifiermodel',
     'create_random', 'Sampler', 'train_test_split', "ProbabilisticImputer","bar_plot", "line_plot", "scatter_plot", "count_plot", "box_plot",
-    "hist_plot",
+    "hist_plot", "Pipeline",
 ]
 

quicklearnkit-0.4.1/quicklearnkit.egg-info/PKG-INFO

@@ -0,0 +1,88 @@
+Metadata-Version: 2.4
+Name: quicklearnkit
+Version: 0.4.1
+Summary: Learning-first machine learning utilities library for simplified imports, sampling, splitting, and probabilistic preprocessing.
+Author: Hazi Afrid
+License: MIT License
+        
+        Copyright (c) 2025 Masterhazi
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+        
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy
+Requires-Dist: pandas
+Requires-Dist: scikit-learn
+Requires-Dist: xgboost
+Requires-Dist: seaborn
+Requires-Dist: matplotlib
+Dynamic: license-file
+
+
+# QuickLearnKit
+
+[![PyPI version](https://img.shields.io/pypi/v/quicklearnkit.svg)](https://pypi.org/project/quicklearnkit/)
+[![Python versions](https://img.shields.io/pypi/pyversions/quicklearnkit.svg)](https://pypi.org/project/quicklearnkit/)
+[![Documentation Status](https://readthedocs.org/projects/quicklearnkit/badge/?version=latest)](https://quicklearnkit.readthedocs.io/en/latest/)
+[![License](https://img.shields.io/pypi/l/quicklearnkit.svg)](LICENSE)
+
+QuickLearnKit is a **learning-first machine learning utilities library** designed to simplify common ML workflows while preserving full control for advanced users.
+
+It provides:
+
+- Simplified model imports  
+- Sampling and dataset utilities  
+- Train–test splitting  
+- Probabilistic, group-aware imputation  
+- Teaching-friendly visualization wrappers  
+- Notebook → Script pipeline compilation  
+
+---
+
+## Installation
+
+```bash
+pip install quicklearnkit
+````
+
+---
+
+## Documentation
+
+Full documentation is available at:
+
+👉 [https://quicklearnkit.readthedocs.io/en/latest/](https://quicklearnkit.readthedocs.io/en/latest/)
+
+---
+
+## Philosophy
+
+> Remove mechanical friction so students can focus on concepts, not syntax.
+
+QuickLearnKit bridges:
+
+Learning → Experimentation → Structured building
+
+---
+
+## License
+
+MIT License

{quicklearnkit-0.3.2 → quicklearnkit-0.4.1}/quicklearnkit.egg-info/SOURCES.txt

@@ -3,6 +3,7 @@ pyproject.toml
 readme.md
 quicklearnkit/__init__.py
 quicklearnkit/classifier.py
+quicklearnkit/pipeline.py
 quicklearnkit/plotting.py
 quicklearnkit/quickimports.py
 quicklearnkit/randomizer.py

{quicklearnkit-0.3.2 → quicklearnkit-0.4.1}/quicklearnkit.egg-info/top_level.txt

@@ -1,2 +1,3 @@
 dist
+docs
 quicklearnkit

quicklearnkit-0.4.1/readme.md

@@ -0,0 +1,50 @@
+
+# QuickLearnKit
+
+[![PyPI version](https://img.shields.io/pypi/v/quicklearnkit.svg)](https://pypi.org/project/quicklearnkit/)
+[![Python versions](https://img.shields.io/pypi/pyversions/quicklearnkit.svg)](https://pypi.org/project/quicklearnkit/)
+[![Documentation Status](https://readthedocs.org/projects/quicklearnkit/badge/?version=latest)](https://quicklearnkit.readthedocs.io/en/latest/)
+[![License](https://img.shields.io/pypi/l/quicklearnkit.svg)](LICENSE)
+
+QuickLearnKit is a **learning-first machine learning utilities library** designed to simplify common ML workflows while preserving full control for advanced users.
+
+It provides:
+
+- Simplified model imports  
+- Sampling and dataset utilities  
+- Train–test splitting  
+- Probabilistic, group-aware imputation  
+- Teaching-friendly visualization wrappers  
+- Notebook → Script pipeline compilation  
+
+---
+
+## Installation
+
+```bash
+pip install quicklearnkit
+````
+
+---
+
+## Documentation
+
+Full documentation is available at:
+
+👉 [https://quicklearnkit.readthedocs.io/en/latest/](https://quicklearnkit.readthedocs.io/en/latest/)
+
+---
+
+## Philosophy
+
+> Remove mechanical friction so students can focus on concepts, not syntax.
+
+QuickLearnKit bridges:
+
+Learning → Experimentation → Structured building
+
+---
+
+## License
+
+MIT License