KL-Py 0.0.3__tar.gz → 0.0.5__tar.gz

{kl_py-0.0.3/src/KL_Py.egg-info → kl_py-0.0.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: KL_Py
-Version: 0.0.3
+Version: 0.0.5
 Summary: A Python simplification module
 Author-email: Abbaskhurram255 <abbaskhurram255@gmail.com>
 Classifier: Programming Language :: Python :: 3

{kl_py-0.0.3 → kl_py-0.0.5}/pyproject.toml

@@ -12,13 +12,14 @@ requires = [
 	"PySimpleGUI",
 	"FreeSimpleGUI",
 	"pyinstaller",
-	"auto-py-to-exe"
+	"auto-py-to-exe",
+	"joblib"
 ]
 build-backend = "setuptools.build_meta"
 
 [project]
 name = "KL_Py"
-version = "0.0.3"
+version = "0.0.5"
 authors = [
   { name="Abbaskhurram255", email="abbaskhurram255@gmail.com" },
 ]

{kl_py-0.0.3 → kl_py-0.0.5}/src/KL_Py/KL_Py.py

@@ -1491,13 +1491,19 @@ def auto_dec(start: int = 0):
 	return AutoField(start, increment=False)
 typename = TypeT = typeT = TypeVar("T")
 def is_active_process(process: str) -> bool:
-	if os.name != "nt" or not isinstance(process, str):
+	if os.name != "nt":
 		return False
-	process = process.strip("\"'").strip()
+	if not isinstance(process, str):
+		return False
+	process = process\
+		.strip("\"'")\
+		.strip()
 	if not process:
 		return False
-	if not process.lower().endswith(".exe"):
-		process_pattern = f"{process}.exe"
+	if not process\
+		.lower()\
+		.endswith(".exe"):
+				process_pattern = f"{process}.exe"
 	else:
 		process_pattern = process
 	try:
@@ -1509,12 +1515,13 @@ def is_active_process(process: str) -> bool:
 			text=True,
 			check=False
 		)
-		if process_pattern.lower() not in result.stdout.lower():
-			return False
+		if process_pattern.lower()\
+			not in result.stdout.lower():
+				return False
 		return True
 	except Exception:
 		return False
-is_running_process = is_running_app = is_active_process
+is_running_process = is_running_app = is_app_running = is_active_process
 def run_process(
 	command: str | list[str] | tuple[str, ...],
 	new_window: bool = False,
@@ -4188,6 +4195,76 @@ def asset(to_filename: str) -> str:
 	except Exception as e:
 		return ""
 define_asset = to_asset = get_asset = new_asset = load_asset = naya_asset = asset
+def get_app_data_dir(
+	app_name: str | None = None,
+	volatile: bool = False
+) -> str:
+		home: Path = Path.home()
+		base_dir: Path
+		if sys.platform == "win32":
+			base_dir = Path(
+				os.environ.get(
+					"LOCALAPPDATA",
+					home / "AppData" / "Local"
+				)
+			)
+			if volatile:
+				base_dir = base_dir / "Temp"
+		elif sys.platform == "darwin":
+			if volatile:
+				base_dir = home / "Library" / "Caches"
+			else:
+				base_dir = home / "Library" / "Application Support"
+		else:
+			if volatile:
+				base_dir = Path(
+					os.environ.get(
+						"XDG_CACHE_HOME",
+						home / ".cache"
+					)
+				)
+			else:
+				base_dir = Path(
+					os.environ.get(
+						"XDG_DATA_HOME",
+						home / ".local" / "share"
+					)
+				)
+		if not isinstance(app_name, str)\
+			or not app_name.strip():
+				return str(base_dir)
+		try:
+			app_dir: Path = base_dir / app_name.strip()
+			app_dir\
+				.mkdir(
+					parents=True,
+					exist_ok=True
+				)
+			return str(app_dir)
+		except OSError:
+			return str(base_dir)
+make_appdata_dir = make_app_data_dir = make_local_data_dir = make_cache_dir = get_appdata_dir = get_local_data_dir = get_cache_dir = get_app_data_dir
+def to_cache_asset(
+	app_name: str | None = None,
+	filename: str | None = None,
+	volatile: bool = False
+) -> str:
+		base: str = get_app_data_dir(
+			app_name=app_name,
+			volatile=volatile
+		)
+		if not isinstance(filename, str)\
+			or not filename.strip():
+				return base
+		result_path = Path(base) / filename.strip()
+		result_path\
+			.parent\
+			.mkdir(
+				parents=True,
+				exist_ok=True
+			)
+		return str(result_path)
+naya_cache_asset = new_cache_asset = cache_asset = to_cache_dir = to_cache_asset
 ## belongs at the bottom of KL_Py.py
 ## a helper function for def= operator
 def get_initial_of(x: Any) -> Any:
@@ -4200,8 +4277,8 @@ def get_initial_of(x: Any) -> Any:
 		case "int":
 			out = 0 
 		case "flt" | "float" | "dbl" | "double" | "Number" | "nr":
-													  # a number is both a float, and int
-													  # lets just assume its a float
+			# a number is both a float, and int
+			# lets just assume its a float
 			out = 0.0
 		case "bool" | "haal":
 			out = False
@@ -4397,4 +4474,5 @@ if __name__ == "__main__":
 	print(Date("2026-07-22 12.01 am").day_nr())
 	print(Date("2026-07-22 12.01 am").time_and_day())
 	print(Date("2002-07-22 12.01 am").yr(2004).d(21).d(), nahi_format_nums=Han)
-	print(Date.day_today())
+	print(Date.day_today())
+	

{kl_py-0.0.3 → kl_py-0.0.5}/src/KL_Py/__init__.py

@@ -3,6 +3,7 @@ from ._custom_turtle import *
 from ._custom_sqlite import *
 from ._custom_pandas import *
 from ._klang_builtins import *
+from .automl import *
 from KL_Py import FreeSimpleGUI
 from KL_Py import dnd
 from KL_Py import drag_and_drop
@@ -14,4 +15,5 @@ from KL_Py import plt
 from KL_Py import psgui
 from KL_Py import px
 from KL_Py import pysgdnd
-from KL_Py import sk
+from KL_Py import sk
+import KL_Py

kl_py-0.0.5/src/KL_Py/automl.py

@@ -0,0 +1,214 @@
+import pandas as pd
+import numpy as np
+import joblib
+from sklearn.model_selection import train_test_split, RepeatedKFold, cross_val_score
+from sklearn.pipeline import Pipeline
+from sklearn.compose import ColumnTransformer
+from sklearn.impute import SimpleImputer
+from sklearn.preprocessing import OneHotEncoder
+from sklearn.ensemble import HistGradientBoostingRegressor, HistGradientBoostingClassifier
+from sklearn.metrics import mean_absolute_error, accuracy_score, r2_score
+from sklearn.inspection import permutation_importance
+import matplotlib.pyplot as plt
+import time
+
+def auto_ml_train(
+    df: pd.DataFrame,
+    target_col: str,
+    problem_type: str = 'auto', # 'regression', 'classification', or 'auto'
+    test_size: float = 0.2,
+    save_path: str = 'model.pkl',
+    verbose: bool = True
+):
+    """
+    Trains a pipeline that handles missing values, categoricals, and auto-tunes HGB.
+    Works on 50 rows or 500k rows. Returns trained pipeline + metrics.
+
+    Usage:
+        model, metrics = auto_ml_train(df, target_col='price')
+        preds = model.predict(new_df)
+    """
+    if not isinstance(df, pd.DataFrame):
+    	try:
+    		df = pd.DataFrame(df)
+    	except Exception:
+    		return
+    start_time = time.time()
+    X = df.drop(target_col, axis=1)
+    y = df[target_col]
+    n_samples = X.shape[0]
+    # 1. Auto-detect problem type
+    if problem_type == 'auto':
+        if y.nunique() <= 20 and y.dtype in ['object', 'bool'] or y.nunique() == 2:
+            problem_type = 'classification'
+        else:
+            problem_type = 'regression'
+    # 2. Auto-detect column types
+    numeric_cols = X.select_dtypes(include=['int64', 'float64']).columns.tolist()
+    categorical_cols = X.select_dtypes(include=['object', 'category', 'bool']).columns.tolist()
+    if verbose:
+        print(f"Problem: {problem_type} | Rows: {n_samples}")
+        print(f"Numeric: {len(numeric_cols)} | Categorical: {len(categorical_cols)}")
+    # 3. Preprocessing
+    numeric_transformer = Pipeline(steps=[
+        ('imputer', SimpleImputer(strategy='median'))
+    ])
+    categorical_transformer = Pipeline(steps=[
+        ('imputer', SimpleImputer(strategy='most_frequent')),
+        ('onehot', OneHotEncoder(handle_unknown='ignore', sparse_output=False))
+    ])
+    preprocessor = ColumnTransformer(
+        transformers=[
+            ('num', numeric_transformer, numeric_cols),
+            ('cat', categorical_transformer, categorical_cols)
+        ],
+        remainder='drop'
+    )
+    # 4. Auto-tune HGB based on data size - FIXED FOR SPEED
+    if problem_type == 'regression':
+        Model = HistGradientBoostingRegressor
+        scoring = 'neg_mean_absolute_error'
+        metric_fn = mean_absolute_error
+        metric_name = 'MAE'
+    else:
+        Model = HistGradientBoostingClassifier
+        scoring = 'accuracy'
+        metric_fn = accuracy_score
+        metric_name = 'Accuracy'
+
+    if n_samples < 500: # Small data mode
+        model_params = dict(
+            max_depth=3, max_leaf_nodes=15, min_samples_leaf=20,
+            learning_rate=0.01, max_iter=100, l2_regularization=1.0,
+            max_features=0.8, early_stopping=True, validation_fraction=0.2,
+            n_iter_no_change=5, random_state=432
+        )
+    elif n_samples < 5000: # Medium data
+        model_params = dict(
+            max_depth=5, max_leaf_nodes=31, learning_rate=0.05,
+            max_iter=200, early_stopping=True, validation_fraction=0.1,
+            n_iter_no_change=10, random_state=432
+        )
+    else: # Big data - NO EARLY STOPPING to avoid hanging
+        model_params = dict(
+            learning_rate=0.1,
+            max_iter=100,
+            early_stopping=False,
+            random_state=432
+        )
+    # 5. Full pipeline
+    pipe = Pipeline(steps=[
+        ('preprocessor', preprocessor),
+        ('model', Model(**model_params))
+    ])
+    # 6. Train/test split
+    X_train, X_test, y_train, y_test = train_test_split(
+        X, y, test_size=test_size, random_state=432
+    )
+    # 7. Fit
+    if verbose: print("Training...")
+    pipe.fit(X_train, y_train)
+    # 8. Test metrics
+    preds = pipe.predict(X_test)
+    test_score = metric_fn(y_test, preds)
+    # 9. Cross-val for honest score - fewer repeats on big data
+    n_repeats = 3 if n_samples < 10000 else 1
+    cv = RepeatedKFold(n_splits=5, n_repeats=n_repeats, random_state=432)
+    cv_scores = cross_val_score(pipe, X, y, cv=cv, scoring=scoring, n_jobs=-1)
+    cv_mean = -cv_scores.mean() if problem_type == 'regression' else cv_scores.mean()
+    cv_std = cv_scores.std()
+    metrics: dict[str, ] = {
+        f'test_{metric_name}': test_score,
+        f'cv_{metric_name}_mean': cv_mean,
+        f'cv_{metric_name}_std': cv_std,
+        'n_samples': n_samples,
+        'problem_type': problem_type,
+        'train_time_sec': round(time.time() - start_time, 2)
+    }
+    if problem_type == 'regression':
+        metrics['test_R2'] = r2_score(y_test, preds)
+    if verbose:
+        print(f"\nTest {metric_name}: {test_score:.4f}")
+        if problem_type == 'regression':
+            print(f"Test R2: {metrics['test_R2']:.4f}")
+        print(f"CV {metric_name}: {cv_mean:.4f} +/- {cv_std:.4f}")
+        print(f"Train time: {metrics['train_time_sec']} sec")
+    # 10. Save
+    joblib.dump(pipe, save_path)
+    if verbose: print(f"\nModel saved to {save_path}")
+    return pipe, metrics
+auto_train = auto_ml_train
+def auto_ml_predict(model_path: str, df_new: pd.DataFrame):
+    if not isinstance(df_new, pd.DataFrame):
+    	try:
+    		df_new = pd.DataFrame(df_new)
+    	except Exception:
+    		return
+    pipe = joblib.load(model_path)
+    return pipe.predict(df_new)
+auto_predict = auto_ml_predict
+def get_feature_importance(
+    model_path: str,
+    df_sample: pd.DataFrame,
+    target_col: str,
+    top_n: int = 10,
+    plot: bool = True
+):
+    """
+    Loads a saved pipeline and returns permutation importance.
+
+    Usage:
+        top_features = get_feature_importance('model.pkl', df.sample(300), 'MedHouseVal')
+    """
+    if not isinstance(df_sample, pd.DataFrame):
+    	try:
+    		df_sample = pd.DataFrame(df_sample)
+    	except Exception:
+    		return
+    pipe = joblib.load(model_path)
+    X = df_sample.drop(target_col, axis=1)
+    y = df_sample[target_col]
+    # Get feature names after preprocessing
+    preprocessor = pipe.named_steps['preprocessor']
+    num_cols = preprocessor.transformers_[0][2]
+    # Check if we have categorical columns
+    cat_cols_list = preprocessor.transformers_[1][2]
+    if len(cat_cols_list) > 0:
+        cat_transformer = preprocessor.transformers_[1][1]
+        cat_cols = cat_transformer.named_steps['onehot'].get_feature_names_out(cat_cols_list)
+        feature_names = list(num_cols) + list(cat_cols)
+    else:
+        feature_names = list(num_cols)
+    n_repeats = 5 if X.shape[0] < 5000 else 2
+    r = permutation_importance(
+        pipe, X, y, n_repeats=n_repeats, random_state=432, n_jobs=-1
+    )
+    importances = pd.Series(r.importances_mean, index=feature_names)
+    importances = importances.sort_values(ascending=False).head(top_n)
+    if plot:
+        plt.figure(figsize=(8, 6))
+        importances.plot(kind='barh')
+        plt.title(f'Top {top_n} Feature Importances')
+        plt.xlabel('Mean decrease in score')
+        plt.gca().invert_yaxis()
+        plt.tight_layout()
+        plt.show()
+    return importances.round(4)
+feature_importance = get_feature_importance
+def explain_model_simple(model_path, df_sample, target_col, business_metric="price"):
+    importances = get_feature_importance(model_path, df_sample, target_col, top_n=3, plot=False)
+    total = importances.sum()
+    top1, top2, top3 = importances.index[0], importances.index[1], importances.index[2]
+    pct1, pct2, pct3 = importances.iloc / total * 100
+
+    explanation = f"""
+    What drives your {business_metric}:
+    1. {top1}: Drives {pct1.iloc[0]:.0f}% of the decision
+    2. {top2}: Drives {pct2.iloc[1]:.0f}% of the decision  
+    3. {top3}: Drives {pct3.iloc[2]:.0f}% of the decision
+    
+    Everything else combined is less important than {top3}.
+    """
+    return explanation
+#Usage:
+#print(explain_model_simple('model.pkl', df, 'MedHouseVal', 'house price'))

{kl_py-0.0.3 → kl_py-0.0.5/src/KL_Py.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: KL_Py
-Version: 0.0.3
+Version: 0.0.5
 Summary: A Python simplification module
 Author-email: Abbaskhurram255 <abbaskhurram255@gmail.com>
 Classifier: Programming Language :: Python :: 3

{kl_py-0.0.3 → kl_py-0.0.5}/src/KL_Py.egg-info/SOURCES.txt

@@ -9,6 +9,7 @@ src/KL_Py/_custom_turtle.py
 src/KL_Py/_error_classes.py
 src/KL_Py/_klang_builtins.py
 src/KL_Py/_translate.py
+src/KL_Py/automl.py
 src/KL_Py/when.py
 src/KL_Py.egg-info/PKG-INFO
 src/KL_Py.egg-info/SOURCES.txt