quicklearnkit 0.0.1__tar.gz → 0.1.0__tar.gz

quicklearnkit-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+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.

quicklearnkit-0.1.0/PKG-INFO

@@ -0,0 +1,35 @@
+Metadata-Version: 2.4
+Name: quicklearnkit
+Version: 0.1.0
+Summary: QuickLearnKit: utilities for learning machine learning concepts
+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
+Dynamic: license-file

quicklearnkit-0.1.0/pyproject.toml

@@ -0,0 +1,23 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "quicklearnkit"
+version = "0.1.0"
+description = "QuickLearnKit: utilities for learning machine learning concepts"
+readme = "README.md"
+license = { file = "LICENSE" }
+authors = [
+    { name = "Hazi Afrid" }
+]
+requires-python = ">=3.8"
+dependencies = [
+    "numpy",
+    "pandas",
+    "scikit-learn",
+    "xgboost"
+]
+
+[tool.setuptools.packages.find]
+where = ["."]

quicklearnkit-0.1.0/quicklearnkit/__init__.py

@@ -0,0 +1,2 @@
+from .quickimports import *
+from .randomizer import Sampler

{quicklearnkit-0.0.1 → quicklearnkit-0.1.0}/quicklearnkit/classifier.py

@@ -1,90 +1,90 @@
-from sklearn.linear_model import LogisticRegression as logisticregression
-from sklearn.neighbors import KNeighborsClassifier as knnclassifier
-from sklearn.tree import DecisionTreeClassifier as decisiontreeclassifier
-from sklearn.ensemble import RandomForestClassifier as randomforestclassifier
-from sklearn.ensemble import GradientBoostingClassifier as gradientboostingclassifier
-from sklearn.ensemble import AdaBoostClassifier as adaboostclassifier
-from xgboost import XGBClassifier as xgboostclassifier
-from sklearn.svm import SVC as supportvectorclassifer
-
-
-class LogisticRegressionmodel:
-    def __init__(self, **kwargs):
-        self.model = logisticregression(**kwargs)
-    
-    def fit(self, X,y):
-        self.model.fit(X,y)
-    
-    def predict(self,X):
-        self.model.predict(X)
-
-
-class KNeighborsClassifiermodel:
-    def __init__(self, **kwargs):
-        self.model = knnclassifier(**kwargs)
-
-    def fit(self, X,y):
-        self.model.fit(X,y)
-    
-    def predict(self,X):
-        self.model.predict(X)
-
-class DecisionTreeClassifiermodel:
-    def __init__(self, **kwargs):
-        self.model = decisiontreeclassifier(**kwargs)
-    
-    def fit(self,X,y):
-        self.model.fit(X,y)
-
-    def predict(self, X):
-        self.model.predict(X)
-
-class RandomForestClassifiermodel:
-    def __init__(self, **kwargs):
-        self.model = randomforestclassifier(**kwargs)
-    
-    def fit(self, X,y):
-        self.model.fit(X,y)
-    
-    def predict(self, X):
-        self.model.predict(X)
-
-class GradientBoostingClassifiermodel:
-    def __init__(self, **kwargs):
-        self.model = gradientboostingclassifier(**kwargs)
-    
-    def fit(self, X,y):
-        self.model.fit(X,y)
-    
-    def predict(self, X):
-        self.model.predict(X)
-
-class AdaBoostClassifiermodel:
-    def __init__(self, **kwargs):
-        self.model = adaboostclassifier(**kwargs)
-    
-    def fit(self, X,y):
-        self.model.fit(X,y)
-    
-    def predict(self, X):
-        self.model.predict(X)
-
-class SVClassifiermodel:
-    def __init__(self, **kwargs):
-        self.model = supportvectorclassifer(**kwargs)
-    
-    def fit(self, X,y):
-        self.model.fit(X,y)
-    
-    def predict(self, X):
-        self.model.predict(X)
-
-class XGBClassifiermodel:
-    def __init__(self, **kwargs):
-        self.model = xgboostclassifier(**kwargs)
-
-    def fit (self, X,y):
-        self.model.fit(X,y)
-
-    def predict(self, X):
+from sklearn.linear_model import LogisticRegression as logisticregression
+from sklearn.neighbors import KNeighborsClassifier as knnclassifier
+from sklearn.tree import DecisionTreeClassifier as decisiontreeclassifier
+from sklearn.ensemble import RandomForestClassifier as randomforestclassifier
+from sklearn.ensemble import GradientBoostingClassifier as gradientboostingclassifier
+from sklearn.ensemble import AdaBoostClassifier as adaboostclassifier
+from xgboost import XGBClassifier as xgboostclassifier
+from sklearn.svm import SVC as supportvectorclassifer
+
+
+class LogisticRegressionmodel:
+    def __init__(self, **kwargs):
+        self.model = logisticregression(**kwargs)
+    
+    def fit(self, X,y):
+        self.model.fit(X,y)
+    
+    def predict(self,X):
+        self.model.predict(X)
+
+
+class KNeighborsClassifiermodel:
+    def __init__(self, **kwargs):
+        self.model = knnclassifier(**kwargs)
+
+    def fit(self, X,y):
+        self.model.fit(X,y)
+    
+    def predict(self,X):
+        self.model.predict(X)
+
+class DecisionTreeClassifiermodel:
+    def __init__(self, **kwargs):
+        self.model = decisiontreeclassifier(**kwargs)
+    
+    def fit(self,X,y):
+        self.model.fit(X,y)
+
+    def predict(self, X):
+        self.model.predict(X)
+
+class RandomForestClassifiermodel:
+    def __init__(self, **kwargs):
+        self.model = randomforestclassifier(**kwargs)
+    
+    def fit(self, X,y):
+        self.model.fit(X,y)
+    
+    def predict(self, X):
+        self.model.predict(X)
+
+class GradientBoostingClassifiermodel:
+    def __init__(self, **kwargs):
+        self.model = gradientboostingclassifier(**kwargs)
+    
+    def fit(self, X,y):
+        self.model.fit(X,y)
+    
+    def predict(self, X):
+        self.model.predict(X)
+
+class AdaBoostClassifiermodel:
+    def __init__(self, **kwargs):
+        self.model = adaboostclassifier(**kwargs)
+    
+    def fit(self, X,y):
+        self.model.fit(X,y)
+    
+    def predict(self, X):
+        self.model.predict(X)
+
+class SVClassifiermodel:
+    def __init__(self, **kwargs):
+        self.model = supportvectorclassifer(**kwargs)
+    
+    def fit(self, X,y):
+        self.model.fit(X,y)
+    
+    def predict(self, X):
+        self.model.predict(X)
+
+class XGBClassifiermodel:
+    def __init__(self, **kwargs):
+        self.model = xgboostclassifier(**kwargs)
+
+    def fit (self, X,y):
+        self.model.fit(X,y)
+
+    def predict(self, X):
         self.model.fit(X)

{quicklearnkit-0.0.1 → quicklearnkit-0.1.0}/quicklearnkit/quickimports.py

@@ -1,21 +1,22 @@
-#from .regression import LinearRegression, KNeighborsRegression, DecisionTreeRegression, RandomForestRegression, AdaBoostRegression, GradientBoostingRegression, XGBRegressor,SVR
-#from .classifier import LogisticRegression, KNeighborsClassifier, DecisionTreeClassifier, RandomForestClassifier, AdaBoostClassifier, GradientBoostingClassifier, XGBClassifier, SVC
-
-#__all__= [
-#    'LinearRegression', ' KNeighborsRegressor', 'DecisionTreeRegressor', 'RandomForestRegressor', 'AdaBoostRegressor', 'GradientBoostingRegressor', 'XGBRegressor', 'SVR',
-#    'LogisticRegression', 'KNeighborsClassifier', 'DecisionTreeClassifier', 'RandomForestClassifier', 'AdaBoostClassifier', 'GradientBoostingClassifier', 'XGBClassifier', 'SVC'
-#]
-
-from .regressor import LinearRegressionmodel, KNNRegressionmodel, DecisionTreeRegressionmodel, RandomForestRegressionmodel, GradientBoostingRegressionmodel, AdaBoostRegressionmodel, XGBoostRegressionmodel, ElasticNetRegressionmodel
-from .classifier import LogisticRegressionmodel, KNeighborsClassifiermodel, DecisionTreeClassifiermodel, RandomForestClassifiermodel, AdaBoostClassifiermodel, GradientBoostingClassifiermodel, XGBClassifiermodel, SVClassifiermodel
-from .utils import create_random
-
-__all__=[
-    'LinearRegressionmodel','LogisticRegressionmodel', 'KNNRegressionmodel','GradientBoostingRegressionmodel',
-    'AdaBoostRegressionmodel', 'XGBoostRegressionmodel', 'ElasticNetRegressionmodel',
-    'DecisionTreeRegressionmodel', 'RandomForestRegressionmodel',
-    'KNeighborsClassifiermodel', 'DecisionTreeClassifiermodel', 'RandomForestClassifiermodel','AdaBoostClassifiermodel', 
-    'GradientBoostingClassifiermodel', 'XGBClassifiermodel', 'SVClassifiermodel',
-    'create_random'
-]
-
+#from .regression import LinearRegression, KNeighborsRegression, DecisionTreeRegression, RandomForestRegression, AdaBoostRegression, GradientBoostingRegression, XGBRegressor,SVR
+#from .classifier import LogisticRegression, KNeighborsClassifier, DecisionTreeClassifier, RandomForestClassifier, AdaBoostClassifier, GradientBoostingClassifier, XGBClassifier, SVC
+
+#__all__= [
+#    'LinearRegression', ' KNeighborsRegressor', 'DecisionTreeRegressor', 'RandomForestRegressor', 'AdaBoostRegressor', 'GradientBoostingRegressor', 'XGBRegressor', 'SVR',
+#    'LogisticRegression', 'KNeighborsClassifier', 'DecisionTreeClassifier', 'RandomForestClassifier', 'AdaBoostClassifier', 'GradientBoostingClassifier', 'XGBClassifier', 'SVC'
+#]
+
+from .regressor import LinearRegressionmodel, KNNRegressionmodel, DecisionTreeRegressionmodel, RandomForestRegressionmodel, GradientBoostingRegressionmodel, AdaBoostRegressionmodel, XGBoostRegressionmodel, ElasticNetRegressionmodel
+from .classifier import LogisticRegressionmodel, KNeighborsClassifiermodel, DecisionTreeClassifiermodel, RandomForestClassifiermodel, AdaBoostClassifiermodel, GradientBoostingClassifiermodel, XGBClassifiermodel, SVClassifiermodel
+from .utils import create_random, ProbabilisticImputer
+from .randomizer import Sampler
+from .split import train_test_split
+__all__=[
+    'LinearRegressionmodel','LogisticRegressionmodel', 'KNNRegressionmodel','GradientBoostingRegressionmodel',
+    'AdaBoostRegressionmodel', 'XGBoostRegressionmodel', 'ElasticNetRegressionmodel',
+    'DecisionTreeRegressionmodel', 'RandomForestRegressionmodel',
+    'KNeighborsClassifiermodel', 'DecisionTreeClassifiermodel', 'RandomForestClassifiermodel','AdaBoostClassifiermodel', 
+    'GradientBoostingClassifiermodel', 'XGBClassifiermodel', 'SVClassifiermodel',
+    'create_random', 'Sampler', 'train_test_split', "ProbabilisticImputer",
+]
+

quicklearnkit-0.1.0/quicklearnkit/randomizer.py

@@ -0,0 +1,175 @@
+import random
+import numpy as np
+import pandas as pd
+from typing import Union, Optional
+
+
+DataType = Union[list, tuple, np.ndarray, pd.DataFrame]
+
+
+class Sampler:
+    """
+    Unified random sampler supporting:
+
+    - Stateful and stateless sampling
+    - Sampling with or without replacement
+    - list, numpy.ndarray, pandas.DataFrame
+    - Row or column sampling for DataFrames
+
+    Parameters
+    ----------
+    data : list, tuple, numpy.ndarray, or pandas.DataFrame
+        Data to sample from.
+    replace : bool, default=False
+        Whether sampling is done with replacement.
+    stateful : bool, default=False
+        If True, sampled elements are removed from future draws.
+    seed : int, optional
+        Random seed for reproducibility.
+    """
+
+    def __init__(
+        self,
+        data: DataType,
+        replace: bool = False,
+        stateful: bool = False,
+        seed: Optional[int] = None
+    ):
+        self.replace = replace
+        self.stateful = stateful
+
+        if seed is not None:
+            random.seed(seed)
+            np.random.seed(seed)
+
+        # Detect data type
+        if isinstance(data, (list, tuple)):
+            self._type = "list"
+            self.data = list(data)
+
+        elif isinstance(data, np.ndarray):
+            self._type = "array"
+            self.data = data
+
+        elif isinstance(data, pd.DataFrame):
+            self._type = "df"
+            self.data = data
+
+        else:
+            raise TypeError(
+                "Unsupported data type. Use list, numpy array, or pandas DataFrame."
+            )
+
+        if self.stateful:
+            self._reset_pool()
+
+    # ---------------- INTERNAL ---------------- #
+
+    def _reset_pool(self):
+        """Initialize or reset internal sampling pool."""
+        if self._type == "list":
+            self.pool = self.data.copy()
+            random.shuffle(self.pool)
+
+        elif self._type == "array":
+            self.pool = self.data.copy()
+            np.random.shuffle(self.pool)
+
+        elif self._type == "df":
+            self.pool = self.data.copy()
+
+    # ---------------- PUBLIC API ---------------- #
+
+    def sample(self, n: int = 1, axis: int = 0):
+        """
+        Sample data.
+
+        Parameters
+        ----------
+        n : int, default=1
+            Number of items to sample.
+        axis : int, default=0
+            Axis to sample from when data is a DataFrame.
+            0 = rows, 1 = columns.
+
+        Returns
+        -------
+        Sampled data (same type as input).
+        """
+
+        if n <= 0:
+            raise ValueError("n must be a positive integer")
+
+        source = self.pool if self.stateful else self.data
+
+        # -------- LIST --------
+        if self._type == "list":
+            if self.stateful:
+                if n > len(self.pool):
+                    raise StopIteration("No items left to sample")
+                out = self.pool[:n]
+                self.pool = self.pool[n:]
+                return out
+
+            if not self.replace and n > len(source):
+                raise ValueError("Cannot sample more elements than population")
+
+            return (
+                random.sample(source, n)
+                if not self.replace
+                else random.choices(source, k=n)
+            )
+
+        # -------- NUMPY ARRAY --------
+        if self._type == "array":
+            if self.stateful:
+                if n > len(self.pool):
+                    raise StopIteration("No items left to sample")
+                out = self.pool[:n]
+                self.pool = self.pool[n:]
+                return out
+
+            return np.random.choice(source, size=n, replace=self.replace)
+
+        # -------- DATAFRAME --------
+        if self._type == "df":
+            if axis not in (0, 1):
+                raise ValueError("axis must be 0 (rows) or 1 (columns)")
+
+            # Row sampling
+            if axis == 0:
+                if self.stateful:
+                    if n > len(self.pool):
+                        raise StopIteration("No rows left to sample")
+                    out = self.pool.iloc[:n]
+                    self.pool = self.pool.iloc[n:]
+                    return out
+
+                return self.data.sample(n=n, replace=self.replace)
+
+            # Column sampling
+            cols = list(source.columns)
+
+            if n > len(cols):
+                raise StopIteration("No columns left to sample")
+
+            chosen = (
+                cols[:n]
+                if self.stateful
+                else random.sample(cols, n)
+                if not self.replace
+                else random.choices(cols, k=n)
+            )
+
+            if self.stateful:
+                self.pool = self.pool.drop(columns=chosen)
+
+            return self.data[chosen]
+
+    def reset(self):
+        """
+        Reset internal state (only for stateful sampler).
+        """
+        if not self.stateful:
+            raise RuntimeError("reset() is only available when stateful=True")
+        self._reset_pool()

{quicklearnkit-0.0.1 → quicklearnkit-0.1.0}/quicklearnkit/regressor.py

@@ -1,92 +1,92 @@
-from sklearn.linear_model import LinearRegression as linearregression
-from sklearn.neighbors import KNeighborsRegressor as knnregressor
-from sklearn.tree import DecisionTreeRegressor as decisiontreeregressor
-from sklearn.ensemble import RandomForestRegressor as randomforestregressor
-from sklearn.ensemble import GradientBoostingRegressor as gradientboostingregressor
-from sklearn.ensemble import AdaBoostRegressor as adaboostregressor
-from xgboost import XGBRegressor as xgboostregressor
-from sklearn.svm import SVR as supportvectorregressor
-from sklearn.linear_model import ElasticNet as elasticnetregressor
-
-
-
-class LinearRegressionmodel:
-    def __init__(self, **kwargs):
-        self.model = linearregression(**kwargs)
-    
-    def fit(self, X,y):
-        self.model.fit(X,y)
-    
-    def predict(self,X):
-        self.model.predict(X)
-
-
-class KNNRegressionmodel:
-    def __init__(self, **kwargs):
-        self.model = knnregressor(**kwargs)
-    
-    def fit(self, X, y):
-        self.model.fit(X,y)
-    
-    def predict(self, X):
-        self.model.predict(X)
-
-class DecisionTreeRegressionmodel:
-    def __init__(self, **kwargs):
-        self.model = decisiontreeregressor(**kwargs)
-    
-    def fit(self,X,y):
-        self.model.fit(X,y)
-    
-    def predict(self, X):
-        self.model.predict(X)
-
-class RandomForestRegressionmodel:
-    def __init__(self, **kwargs):
-        self.model = randomforestregressor(**kwargs)
-
-    def fit(self, X, y):
-        self.model.fit(X,y)
-    
-    def predict(self,X):
-        self.model.predict(X)
-
-class GradientBoostingRegressionmodel:
-    def __init__(self, **kwargs):
-        self.model = randomforestregressor(**kwargs)
-    
-    def fit(self, X, y):
-        self.model.fit(X,y)
-    
-    def predict(self,X):
-        self.model.predict(X)
-    
-class AdaBoostRegressionmodel:
-    def __init__(self, **kwargs):
-        self.model = adaboostregressor(**kwargs)
-    
-    def fit(self, X, y):
-        self.model.fit(X,y)
-    
-    def predict(self,X):
-        self.model.predict(X)
-
-class XGBoostRegressionmodel:
-    def __init__(self, **kwargs):
-        self.model = xgboostregressor(**kwargs)
-    
-    def fit(self, X, y):
-        self.model.fit(X,y)
-    
-    def predict(self,X):
-        self.model.predict(X)
-
-class ElasticNetRegressionmodel:
-    def __init__(self, **kwargs):
-        self.model = elasticnetregressor(**kwargs)
-    
-    def fit(self, X, y):
-        self.model.fit(X,y)
-    
-    def predict(self,X):
+from sklearn.linear_model import LinearRegression as linearregression
+from sklearn.neighbors import KNeighborsRegressor as knnregressor
+from sklearn.tree import DecisionTreeRegressor as decisiontreeregressor
+from sklearn.ensemble import RandomForestRegressor as randomforestregressor
+from sklearn.ensemble import GradientBoostingRegressor as gradientboostingregressor
+from sklearn.ensemble import AdaBoostRegressor as adaboostregressor
+from xgboost import XGBRegressor as xgboostregressor
+from sklearn.svm import SVR as supportvectorregressor
+from sklearn.linear_model import ElasticNet as elasticnetregressor
+
+
+
+class LinearRegressionmodel:
+    def __init__(self, **kwargs):
+        self.model = linearregression(**kwargs)
+    
+    def fit(self, X,y):
+        self.model.fit(X,y)
+    
+    def predict(self,X):
+        self.model.predict(X)
+
+
+class KNNRegressionmodel:
+    def __init__(self, **kwargs):
+        self.model = knnregressor(**kwargs)
+    
+    def fit(self, X, y):
+        self.model.fit(X,y)
+    
+    def predict(self, X):
+        self.model.predict(X)
+
+class DecisionTreeRegressionmodel:
+    def __init__(self, **kwargs):
+        self.model = decisiontreeregressor(**kwargs)
+    
+    def fit(self,X,y):
+        self.model.fit(X,y)
+    
+    def predict(self, X):
+        self.model.predict(X)
+
+class RandomForestRegressionmodel:
+    def __init__(self, **kwargs):
+        self.model = randomforestregressor(**kwargs)
+
+    def fit(self, X, y):
+        self.model.fit(X,y)
+    
+    def predict(self,X):
+        self.model.predict(X)
+
+class GradientBoostingRegressionmodel:
+    def __init__(self, **kwargs):
+        self.model = randomforestregressor(**kwargs)
+    
+    def fit(self, X, y):
+        self.model.fit(X,y)
+    
+    def predict(self,X):
+        self.model.predict(X)
+    
+class AdaBoostRegressionmodel:
+    def __init__(self, **kwargs):
+        self.model = adaboostregressor(**kwargs)
+    
+    def fit(self, X, y):
+        self.model.fit(X,y)
+    
+    def predict(self,X):
+        self.model.predict(X)
+
+class XGBoostRegressionmodel:
+    def __init__(self, **kwargs):
+        self.model = xgboostregressor(**kwargs)
+    
+    def fit(self, X, y):
+        self.model.fit(X,y)
+    
+    def predict(self,X):
+        self.model.predict(X)
+
+class ElasticNetRegressionmodel:
+    def __init__(self, **kwargs):
+        self.model = elasticnetregressor(**kwargs)
+    
+    def fit(self, X, y):
+        self.model.fit(X,y)
+    
+    def predict(self,X):
         self.model.predict(X)

quicklearnkit-0.1.0/quicklearnkit/split.py

@@ -0,0 +1,99 @@
+import numpy as np
+import pandas as pd
+from typing import Optional, Tuple, Union
+
+
+ArrayLike = Union[np.ndarray, pd.DataFrame]
+
+
+def train_test_split(
+    X: ArrayLike,
+    y: Optional[np.ndarray] = None,
+    test_size: float = 0.25,
+    shuffle: bool = True,
+    stratify: Optional[np.ndarray] = None,
+    random_state: Optional[int] = None
+) -> Tuple:
+    """
+    Split data into train and test subsets.
+
+    Parameters
+    ----------
+    X : numpy.ndarray or pandas.DataFrame
+        Feature data to split.
+    y : numpy.ndarray, optional
+        Target labels corresponding to X.
+    test_size : float, default=0.25
+        Proportion of the dataset to include in the test split.
+    shuffle : bool, default=True
+        Whether to shuffle data before splitting.
+    stratify : numpy.ndarray, optional
+        Class labels for stratified split (classification only).
+    random_state : int, optional
+        Seed for reproducibility.
+
+    Returns
+    -------
+    X_train, X_test : same type as X
+        Split feature data.
+    y_train, y_test : numpy.ndarray, optional
+        Split target labels (only if y is provided).
+    """
+
+    if not 0 < test_size < 1:
+        raise ValueError("test_size must be between 0 and 1")
+
+    if random_state is not None:
+        np.random.seed(random_state)
+
+    n_samples = len(X)
+    indices = np.arange(n_samples)
+
+    # ---------- STRATIFIED SPLIT ----------
+    if stratify is not None:
+        if y is None:
+            raise ValueError("y must be provided when using stratify")
+
+        if not shuffle:
+            raise ValueError("Stratified split requires shuffle=True")
+
+        stratify = np.asarray(stratify)
+
+        train_idx = []
+        test_idx = []
+
+        for cls in np.unique(stratify):
+            cls_indices = indices[stratify == cls]
+            np.random.shuffle(cls_indices)
+
+            split = int(len(cls_indices) * (1 - test_size))
+            train_idx.extend(cls_indices[:split])
+            test_idx.extend(cls_indices[split:])
+
+        train_idx = np.array(train_idx)
+        test_idx = np.array(test_idx)
+
+    # ---------- STANDARD SPLIT ----------
+    else:
+        if shuffle:
+            np.random.shuffle(indices)
+
+        split = int(n_samples * (1 - test_size))
+        train_idx, test_idx = indices[:split], indices[split:]
+
+    # ---------- APPLY INDICES ----------
+    if isinstance(X, pd.DataFrame):
+        X_train = X.iloc[train_idx]
+        X_test = X.iloc[test_idx]
+    else:
+        X_train = X[train_idx]
+        X_test = X[test_idx]
+
+    if y is None:
+        return X_train, X_test
+
+    y = np.asarray(y)
+    y_train = y[train_idx]
+    y_test = y[test_idx]
+
+    return X_train, X_test, y_train, y_test

quicklearnkit-0.1.0/quicklearnkit/utils.py

@@ -0,0 +1,196 @@
+import numpy as np
+
+def create_random(mean, std, size, random_state=None):
+    """
+    Generate random data with a specified mean and standard deviation.
+
+    Parameters:
+        mean (float): Desired mean of the data.
+        std (float): Desired standard deviation of the data.
+        size (int): Length of the data to generate.
+        random_state (int, optional): Seed for reproducibility. Defaults to None.
+
+    Returns:
+        dict: A dictionary containing:
+            - "data": Random data with the specified mean and standard deviation.
+            - "mean": Actual mean of the generated data.
+            - "std": Actual standard deviation of the generated data.
+
+    Raises:
+        ValueError: If std is negative or size is not a positive integer.
+    """
+    if std < 0:
+        raise ValueError("Standard deviation must be non-negative.")
+    if size <= 0:
+        raise ValueError("Size must be a positive integer.")
+
+    # Create a random number generator instance
+    rng = np.random.default_rng(random_state)
+    
+    # Generate random normal data
+    x = rng.normal(size=size)
+    x1 = (x - np.mean(x)) / np.std(x)
+    x2 = (x1 * std) + mean
+
+    return {
+        "data": x2,
+        "mean": np.mean(x2),
+        "std": np.std(x2)
+    }
+
+
+import numpy as np
+import pandas as pd
+from typing import Optional, Dict
+
+
+class ProbabilisticImputer:
+    """
+    Probabilistic, group-aware categorical imputer.
+
+    Learns conditional probability distributions during `fit()`
+    and samples missing values during `transform()`.
+
+    Default behavior is stateless (fully reproducible).
+    If stateful=True, RNG state advances across calls for
+    simulation / data augmentation workflows.
+
+    Parameters
+    ----------
+    group_col : str
+        Column name used to group data (e.g. class, category, segment).
+    target_col : str
+        Column name to impute.
+    random_state : int, optional
+        Seed for reproducible randomness.
+    stateful : bool, default=False
+        If True, RNG state advances across multiple transform calls.
+    """
+
+    def __init__(
+        self,
+        group_col: str,
+        target_col: str,
+        random_state: Optional[int] = None,
+        stateful: bool = False
+    ):
+        self.group_col = group_col
+        self.target_col = target_col
+        self.random_state = random_state
+        self.stateful = stateful
+
+        self._fitted = False
+        self._dist_map: Dict = {}
+
+        self._init_rng()
+
+    # ---------------- INTERNAL ---------------- #
+
+    def _init_rng(self):
+        """Initialize or reset the random number generator."""
+        self.rng = np.random.default_rng(self.random_state)
+
+    # ---------------- PUBLIC API ---------------- #
+
+    def fit(self, df: pd.DataFrame):
+        """
+        Learn per-group probability distributions from observed data.
+
+        Parameters
+        ----------
+        df : pandas.DataFrame
+            DataFrame containing group and target columns.
+
+        Returns
+        -------
+        self
+        """
+        if not isinstance(df, pd.DataFrame):
+            raise TypeError("Input must be a pandas DataFrame")
+
+        if self.group_col not in df.columns or self.target_col not in df.columns:
+            raise ValueError("group_col and target_col must exist in DataFrame")
+
+        self._dist_map.clear()
+
+        # Build per-group distributions
+        grouped = df.dropna(subset=[self.target_col]).groupby(self.group_col)
+
+        for group, gdf in grouped:
+            probs = (
+                gdf[self.target_col]
+                .value_counts(normalize=True)
+                .to_dict()
+            )
+            self._dist_map[group] = probs
+
+        # Global fallback distribution
+        self._global_dist = (
+            df[self.target_col]
+            .dropna()
+            .value_counts(normalize=True)
+            .to_dict()
+        )
+
+        self._fitted = True
+        return self
+
+    def transform(self, df: pd.DataFrame) -> pd.DataFrame:
+        """
+        Impute missing values using learned distributions.
+
+        Parameters
+        ----------
+        df : pandas.DataFrame
+            DataFrame to transform.
+
+        Returns
+        -------
+        pandas.DataFrame
+            New DataFrame with missing values imputed.
+        """
+        if not self._fitted:
+            raise RuntimeError("Must call fit() before transform()")
+
+        if not isinstance(df, pd.DataFrame):
+            raise TypeError("Input must be a pandas DataFrame")
+
+        out = df.copy()
+        missing_mask = out[self.target_col].isna()
+
+        for idx in out[missing_mask].index:
+            group = out.at[idx, self.group_col]
+
+            # Get group distribution or fallback to global
+            dist = self._dist_map.get(group, self._global_dist)
+
+            if not dist:
+                continue  # Nothing to sample from
+
+            choices = list(dist.keys())
+            probs = list(dist.values())
+
+            out.at[idx, self.target_col] = self.rng.choice(
+                choices,
+                p=probs
+            )
+
+        # Reset RNG if stateless (default behavior)
+        if not self.stateful:
+            self._init_rng()
+
+        return out
+
+    def fit_transform(self, df: pd.DataFrame) -> pd.DataFrame:
+        """
+        Fit and transform in one step.
+
+        Parameters
+        ----------
+        df : pandas.DataFrame
+
+        Returns
+        -------
+        pandas.DataFrame
+        """
+        return self.fit(df).transform(df)

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

@@ -0,0 +1,35 @@
+Metadata-Version: 2.4
+Name: quicklearnkit
+Version: 0.1.0
+Summary: QuickLearnKit: utilities for learning machine learning concepts
+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
+Dynamic: license-file

{quicklearnkit-0.0.1 → quicklearnkit-0.1.0}/quicklearnkit.egg-info/SOURCES.txt

@@ -1,10 +1,11 @@
-README.md
+LICENSE
 pyproject.toml
-setup.py
 quicklearnkit/__init__.py
 quicklearnkit/classifier.py
 quicklearnkit/quickimports.py
+quicklearnkit/randomizer.py
 quicklearnkit/regressor.py
+quicklearnkit/split.py
 quicklearnkit/utils.py
 quicklearnkit.egg-info/PKG-INFO
 quicklearnkit.egg-info/SOURCES.txt

{quicklearnkit-0.0.1 → quicklearnkit-0.1.0}/quicklearnkit.egg-info/requires.txt

@@ -1,3 +1,4 @@
-scikit-learn
-pandas
 numpy
+pandas
+scikit-learn
+xgboost

{quicklearnkit-0.0.1 → quicklearnkit-0.1.0}/quicklearnkit.egg-info/top_level.txt

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

{quicklearnkit-0.0.1 → quicklearnkit-0.1.0}/setup.cfg

@@ -1,4 +1,4 @@
-[egg_info]
-tag_build = 
-tag_date = 0
-
+[egg_info]
+tag_build = 
+tag_date = 0
+

quicklearnkit-0.0.1/PKG-INFO

@@ -1,26 +0,0 @@
-Metadata-Version: 2.4
-Name: quicklearnkit
-Version: 0.0.1
-Summary: A simplified interface for machine learning algorithms.
-Home-page: https://github.com/yourusername/quicklearn
-Author: hazi
-Author-email: hajiafribaba@gmail.com
-Classifier: Programming Language :: Python :: 3
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Operating System :: OS Independent
-Requires-Python: >=3.6
-Description-Content-Type: text/markdown
-Requires-Dist: scikit-learn
-Requires-Dist: pandas
-Requires-Dist: numpy
-Dynamic: author
-Dynamic: author-email
-Dynamic: classifier
-Dynamic: description
-Dynamic: description-content-type
-Dynamic: home-page
-Dynamic: requires-dist
-Dynamic: requires-python
-Dynamic: summary
-
-This is an upcoming wrapper library for machine learning beginners and all the enthusisasts out there who want to reduce the time taken for projects, this library works on simple principle and it is gonna save lot of time in upcoming future 

quicklearnkit-0.0.1/README.md

@@ -1 +0,0 @@
-This is an upcoming wrapper library for machine learning beginners and all the enthusisasts out there who want to reduce the time taken for projects, this library works on simple principle and it is gonna save lot of time in upcoming future 

quicklearnkit-0.0.1/pyproject.toml

@@ -1,3 +0,0 @@
-[build-system]
-requires = ["setuptools>=42", "wheel"]
-build-backend = "setuptools.build_meta"

quicklearnkit-0.0.1/quicklearnkit/__init__.py

@@ -1,2 +0,0 @@
-from .quickimports import *
-from .utils import create_random

quicklearnkit-0.0.1/quicklearnkit/utils.py

@@ -1,39 +0,0 @@
-import numpy as np
-
-def create_random(mean, std, size, random_state=None):
-    """
-    Generate random data with a specified mean and standard deviation.
-
-    Parameters:
-        mean (float): Desired mean of the data.
-        std (float): Desired standard deviation of the data.
-        size (int): Length of the data to generate.
-        random_state (int, optional): Seed for reproducibility. Defaults to None.
-
-    Returns:
-        dict: A dictionary containing:
-            - "data": Random data with the specified mean and standard deviation.
-            - "mean": Actual mean of the generated data.
-            - "std": Actual standard deviation of the generated data.
-
-    Raises:
-        ValueError: If std is negative or size is not a positive integer.
-    """
-    if std < 0:
-        raise ValueError("Standard deviation must be non-negative.")
-    if size <= 0:
-        raise ValueError("Size must be a positive integer.")
-
-    # Create a random number generator instance
-    rng = np.random.default_rng(random_state)
-    
-    # Generate random normal data
-    x = rng.normal(size=size)
-    x1 = (x - np.mean(x)) / np.std(x)
-    x2 = (x1 * std) + mean
-
-    return {
-        "data": x2,
-        "mean": np.mean(x2),
-        "std": np.std(x2)
-    }

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

@@ -1,26 +0,0 @@
-Metadata-Version: 2.4
-Name: quicklearnkit
-Version: 0.0.1
-Summary: A simplified interface for machine learning algorithms.
-Home-page: https://github.com/yourusername/quicklearn
-Author: hazi
-Author-email: hajiafribaba@gmail.com
-Classifier: Programming Language :: Python :: 3
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Operating System :: OS Independent
-Requires-Python: >=3.6
-Description-Content-Type: text/markdown
-Requires-Dist: scikit-learn
-Requires-Dist: pandas
-Requires-Dist: numpy
-Dynamic: author
-Dynamic: author-email
-Dynamic: classifier
-Dynamic: description
-Dynamic: description-content-type
-Dynamic: home-page
-Dynamic: requires-dist
-Dynamic: requires-python
-Dynamic: summary
-
-This is an upcoming wrapper library for machine learning beginners and all the enthusisasts out there who want to reduce the time taken for projects, this library works on simple principle and it is gonna save lot of time in upcoming future 

quicklearnkit-0.0.1/setup.py

@@ -1,24 +0,0 @@
-from setuptools import setup, find_packages
-
-setup(
-    name="quicklearnkit",  # Package name
-    version="0.0.1",    # Initial version
-    author="hazi", # Your name
-    author_email="hajiafribaba@gmail.com",  # Your email
-    description="A simplified interface for machine learning algorithms.",  # Short description
-    long_description=open("README.md").read(),  # Long description from README
-    long_description_content_type="text/markdown",  # Format of the long description
-    url="https://github.com/yourusername/quicklearn",  # Project URL
-    packages=find_packages(),  # Automatically find all packages
-    install_requires=[  # List your dependencies here
-        "scikit-learn",
-        "pandas",
-        "numpy",
-    ],
-    classifiers=[  # Metadata for PyPI
-        "Programming Language :: Python :: 3",
-        "License :: OSI Approved :: MIT License",
-        "Operating System :: OS Independent",
-    ],
-    python_requires=">=3.6",  # Python version compatibility
-)