skl-core 1.0.0__tar.gz

skl_core-1.0.0/PKG-INFO

@@ -0,0 +1,92 @@
+Metadata-Version: 2.4
+Name: skl-core
+Version: 1.0.0
+Summary: Standard Knowledge & Algorithm Library: search, CSP, game theory, heuristics, and utilities.
+Author: SKL Developers
+License-Expression: MIT
+Keywords: algorithms,search,bfs,dfs,astar,minimax,csp,backtracking,puzzle,utilities
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+
+# SKL (Standard Knowledge & Algorithm Library)
+
+A lightweight Python library providing clean, minimal implementations of standard computer science algorithms, search heuristics, constraint satisfaction problems, and data utilities.
+
+---
+
+## 📦 Installation
+
+```bash
+pip install skl
+```
+
+---
+
+## 🚀 CLI Usage
+
+Access algorithms and code snippets directly from the terminal:
+
+```bash
+# Interactive menu
+skl
+
+# Print & copy 4-Queens solver
+skl 4queen
+
+# Print & copy 8-Puzzle solver
+skl 8puzzle
+
+# Print & copy Inventory management
+skl lib
+
+# Graph traversal (BFS & DFS)
+skl bfs
+
+# Pathfinding (A* search)
+skl astar
+
+# Dump all algorithm scripts to the current directory
+skl saveall
+```
+
+---
+
+## ⚡ Direct Code Execution & Clipboard
+
+- **Automatic Clipboard Copy**: Every query automatically copies the compact code directly to your system clipboard (press `Ctrl + V` to paste into any editor).
+- **Run on Demand**:
+  ```bash
+  skl 4queen --run
+  skl 8puzzle --run
+  skl astar --run
+  ```
+
+---
+
+## 🐍 Python Import API
+
+```python
+import skl
+
+# Execute algorithm
+skl.run("4queen")
+skl.run("8puzzle")
+
+# Retrieve raw code string
+snippet = skl.code("lib")
+print(snippet)
+
+# Copy to clipboard
+skl.copy("astar")
+
+# Save all files locally
+skl.save_all("./scripts")
+```
+
+---
+
+## 📄 License
+MIT

skl_core-1.0.0/README.md

@@ -0,0 +1,79 @@
+# SKL (Standard Knowledge & Algorithm Library)
+
+A lightweight Python library providing clean, minimal implementations of standard computer science algorithms, search heuristics, constraint satisfaction problems, and data utilities.
+
+---
+
+## 📦 Installation
+
+```bash
+pip install skl
+```
+
+---
+
+## 🚀 CLI Usage
+
+Access algorithms and code snippets directly from the terminal:
+
+```bash
+# Interactive menu
+skl
+
+# Print & copy 4-Queens solver
+skl 4queen
+
+# Print & copy 8-Puzzle solver
+skl 8puzzle
+
+# Print & copy Inventory management
+skl lib
+
+# Graph traversal (BFS & DFS)
+skl bfs
+
+# Pathfinding (A* search)
+skl astar
+
+# Dump all algorithm scripts to the current directory
+skl saveall
+```
+
+---
+
+## ⚡ Direct Code Execution & Clipboard
+
+- **Automatic Clipboard Copy**: Every query automatically copies the compact code directly to your system clipboard (press `Ctrl + V` to paste into any editor).
+- **Run on Demand**:
+  ```bash
+  skl 4queen --run
+  skl 8puzzle --run
+  skl astar --run
+  ```
+
+---
+
+## 🐍 Python Import API
+
+```python
+import skl
+
+# Execute algorithm
+skl.run("4queen")
+skl.run("8puzzle")
+
+# Retrieve raw code string
+snippet = skl.code("lib")
+print(snippet)
+
+# Copy to clipboard
+skl.copy("astar")
+
+# Save all files locally
+skl.save_all("./scripts")
+```
+
+---
+
+## 📄 License
+MIT

skl_core-1.0.0/pyproject.toml

@@ -0,0 +1,38 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "skl-core"
+version = "1.0.0"
+description = "Standard Knowledge & Algorithm Library: search, CSP, game theory, heuristics, and utilities."
+readme = "README.md"
+requires-python = ">=3.7"
+license = "MIT"
+authors = [
+    { name = "SKL Developers" }
+]
+keywords = [
+    "algorithms",
+    "search",
+    "bfs",
+    "dfs",
+    "astar",
+    "minimax",
+    "csp",
+    "backtracking",
+    "puzzle",
+    "utilities"
+]
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Operating System :: OS Independent",
+    "Topic :: Software Development :: Libraries :: Python Modules"
+]
+
+[project.scripts]
+skl = "skl.cli:main"
+sk-lib = "skl.cli:main"
+
+[tool.setuptools.packages.find]
+where = ["src"]

skl_core-1.0.0/setup.cfg

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

skl_core-1.0.0/src/skl/__init__.py

@@ -0,0 +1,62 @@
+"""SKL - Standard Knowledge & Algorithm Library
+"""
+
+from .registry import MODULES
+from .cli import find_module, copy_to_clipboard, save_all_files
+
+__version__ = "1.0.0"
+
+def get(query):
+    return find_module(query)
+
+def code(query) -> str:
+    mod = find_module(query)
+    if not mod:
+        raise ValueError(f"Module '{query}' not found.")
+    return mod["code"]
+
+def show(query):
+    mod = find_module(query)
+    if not mod:
+        print(f"[!] Module '{query}' not found.")
+        return
+    print("=" * 60)
+    print(f"Program {mod['id']:02d}: {mod['title']}")
+    print("=" * 60)
+    print(f"Description:\n  {mod['desc']}\n")
+    print("CODE:")
+    print("-" * 40)
+    print(mod["code"])
+    print("-" * 40)
+    print("EXPECTED OUTPUT:")
+    print(mod["output"])
+    print("=" * 60)
+
+def run(query):
+    mod = find_module(query)
+    if not mod:
+        print(f"[!] Module '{query}' not found.")
+        return
+    print(f"[Executing {mod['id']:02d}: {mod['title']}...]")
+    exec(mod["code"], {"__name__": "__main__"})
+
+def copy(query) -> bool:
+    mod = find_module(query)
+    if not mod:
+        print(f"[!] Module '{query}' not found.")
+        return False
+    return copy_to_clipboard(mod["code"])
+
+def save_all(target_dir="."):
+    save_all_files(target_dir)
+
+__all__ = [
+    "MODULES",
+    "get",
+    "code",
+    "show",
+    "run",
+    "copy",
+    "save_all",
+    "__version__"
+]

skl_core-1.0.0/src/skl/__main__.py

@@ -0,0 +1,4 @@
+from .cli import main
+
+if __name__ == "__main__":
+    main()

skl_core-1.0.0/src/skl/cli.py

@@ -0,0 +1,173 @@
+import sys
+import subprocess
+import os
+from .registry import MODULES
+
+def copy_to_clipboard(text: str) -> bool:
+    try:
+        if sys.platform == "win32":
+            proc = subprocess.Popen(["clip"], stdin=subprocess.PIPE, shell=True)
+            proc.communicate(text.encode("utf-8"))
+            return True
+        elif sys.platform == "darwin":
+            proc = subprocess.Popen(["pbcopy"], stdin=subprocess.PIPE)
+            proc.communicate(text.encode("utf-8"))
+            return True
+        else:
+            proc = subprocess.Popen(["xclip", "-selection", "clipboard"], stdin=subprocess.PIPE)
+            proc.communicate(text.encode("utf-8"))
+            return True
+    except Exception:
+        return False
+
+def find_module(query):
+    query_str = str(query).strip().lower()
+    if query_str.isdigit():
+        mid = int(query_str)
+        if mid in MODULES:
+            return MODULES[mid]
+    
+    aliases = {
+        "setup": 1, "install": 1, "env": 1,
+        "bfs": 2, "dfs": 2, "graph": 2,
+        "astar": 3, "a*": 3, "path": 3,
+        "csp": 4, "map": 4, "coloring": 4,
+        "rules": 5, "expert": 5, "diag": 5, "medical": 5,
+        "minimax": 6, "ttt": 6, "tic": 6, "game": 6,
+        "preprocess": 7, "pandas": 7, "data": 7, "clean": 7,
+        "nlp": 8, "token": 8, "nltk": 8, "words": 8,
+        "bayes": 9, "naive": 9, "spam": 9, "classify": 9,
+        "regression": 10, "linear": 10, "ols": 10, "fit": 10,
+        "4queen": 11, "4queens": 11, "queen": 11, "queens": 11,
+        "8puzzle": 12, "puzzle": 12, "eight": 12, "tiles": 12,
+        "lib": 13, "library": 13, "inventory": 13, "catalog": 13
+    }
+    
+    clean_q = query_str.replace("-", "").replace("_", "").replace(" ", "")
+    if clean_q in aliases:
+        return MODULES[aliases[clean_q]]
+
+    for mod in MODULES.values():
+        if clean_q in mod["key"] or clean_q in mod["title"].lower().replace(" ", ""):
+            return mod
+            
+    return None
+
+def save_all_files(target_dir="."):
+    os.makedirs(target_dir, exist_ok=True)
+    for mid, data in MODULES.items():
+        fname = f"p{mid:02d}_{data['key']}.py"
+        path = os.path.join(target_dir, fname)
+        with open(path, "w", encoding="utf-8") as f:
+            f.write(f"# Module {mid:02d}: {data['title']}\n\n")
+            f.write(data["code"] + "\n")
+    print(f"\n[+] Saved all {len(MODULES)} program files in '{os.path.abspath(target_dir)}'.")
+
+def display_menu():
+    print("=" * 60)
+    print("                 SKL Toolkit (v1.0.0)                 ")
+    print("=" * 60)
+    for mid, data in MODULES.items():
+        print(f"  {mid:2d}. {data['title']}")
+    print("-" * 60)
+    print("  A. Save all programs as .py files in current directory")
+    print("  Q. Quit")
+    print("=" * 60)
+
+def main():
+    args = sys.argv[1:]
+    
+    if not args:
+        while True:
+            display_menu()
+            choice = input("\nEnter selection (1-13), 'A' to save all, or 'Q' to quit: ").strip().lower()
+            if choice == "q":
+                break
+            elif choice == "a":
+                save_all_files()
+                break
+            
+            mod = find_module(choice)
+            if not mod:
+                print("[!] Invalid selection.")
+                continue
+                
+            print("\n" + "=" * 60)
+            print(f"Program {mod['id']:02d}: {mod['title']}")
+            print("=" * 60)
+            print(f"Description:\n  {mod['desc']}\n")
+            print("CODE:")
+            print("-" * 40)
+            print(mod["code"])
+            print("-" * 40)
+            print("EXPECTED OUTPUT:")
+            print(mod["output"])
+            print("=" * 60)
+            
+            if copy_to_clipboard(mod["code"]):
+                print("[*] Code copied to clipboard! (Ctrl + V to paste)")
+                
+            sub = input("\nExecute this program now? (y/n) [n]: ").strip().lower()
+            if sub == "y":
+                print("\n[Executing...]")
+                print("-" * 40)
+                try:
+                    exec(mod["code"], {"__name__": "__main__"})
+                except Exception as e:
+                    print(f"Notice: {e}")
+                print("-" * 40)
+            input("\nPress Enter to return to menu...")
+        return
+
+    if args[0] in ["--save-all", "-sa", "saveall", "dump"]:
+        save_all_files()
+        return
+
+    mod = find_module(args[0])
+    if not mod:
+        print(f"[!] Unknown target '{args[0]}'.")
+        print("Usage: skl [1-13 | 4queen | 8puzzle | lib | saveall]")
+        return
+
+    if "--code" in args or "-c" in args:
+        print(mod["code"])
+        return
+
+    if "--save" in args or "-s" in args:
+        fname = f"p{mod['id']:02d}_{mod['key']}.py"
+        with open(fname, "w", encoding="utf-8") as f:
+            f.write(mod["code"] + "\n")
+        print(f"[+] Saved to {fname}")
+        return
+
+    if "--copy" in args:
+        if copy_to_clipboard(mod["code"]):
+            print(f"[+] Code copied to clipboard!")
+        else:
+            print("[!] Clipboard copy failed.")
+        return
+
+    if "--run" in args or "-r" in args:
+        print(f"[Executing {mod['id']:02d}: {mod['title']}...]")
+        try:
+            exec(mod["code"], {"__name__": "__main__"})
+        except Exception as e:
+            print(f"Error: {e}")
+        return
+
+    print("=" * 60)
+    print(f"Program {mod['id']:02d}: {mod['title']}")
+    print("=" * 60)
+    print(f"Description:\n  {mod['desc']}\n")
+    print("CODE:")
+    print("-" * 40)
+    print(mod["code"])
+    print("-" * 40)
+    print("EXPECTED OUTPUT:")
+    print(mod["output"])
+    print("=" * 60)
+    if copy_to_clipboard(mod["code"]):
+        print("[*] Code copied to clipboard! (Ctrl + V to paste)")
+
+if __name__ == "__main__":
+    main()

skl_core-1.0.0/src/skl/modules/__init__.py

@@ -0,0 +1,14 @@
+# SKL Modules Package
+from . import p01_setup
+from . import p02_bfs_dfs
+from . import p03_astar
+from . import p04_csp
+from . import p05_rules
+from . import p06_minimax
+from . import p07_preprocess
+from . import p08_nlp
+from . import p09_bayes
+from . import p10_regression
+from . import p11_4queens
+from . import p12_8puzzle
+from . import p13_inventory

skl_core-1.0.0/src/skl/modules/p01_setup.py

@@ -0,0 +1,6 @@
+# Program 01: Environment Verification & Core Libraries
+
+import numpy, pandas, matplotlib, sklearn, nltk, tensorflow
+print("All libraries loaded successfully!")
+print("NumPy version:", numpy.__version__)
+print("Pandas version:", pandas.__version__)

skl_core-1.0.0/src/skl/modules/p02_bfs_dfs.py

@@ -0,0 +1,23 @@
+# Program 02: Graph Traversal (BFS & DFS)
+
+graph = {'A': ['B', 'C'], 'B': ['D', 'E'], 'C': ['F'], 'D': [], 'E': ['F'], 'F': []}
+
+def bfs(s):
+    q, v = [s], set()
+    for u in q:
+        if u not in v:
+            print(u, end=' ')
+            v.add(u)
+            q += graph[u]
+
+def dfs(u, v=None):
+    if v is None: v = set()
+    if u not in v:
+        print(u, end=' ')
+        v.add(u)
+        for n in graph[u]: dfs(n, v)
+
+print("BFS Traversal:")
+bfs('A')
+print("\nDFS Traversal:")
+dfs('A')

skl_core-1.0.0/src/skl/modules/p03_astar.py

@@ -0,0 +1,21 @@
+# Program 03: A* Pathfinding Algorithm
+
+import heapq
+
+graph = {'A': [('B', 1), ('C', 3)], 'B': [('D', 3), ('E', 1)], 'C': [('F', 2)],
+         'D': [('G', 2)], 'E': [('G', 4)], 'F': [('G', 1)], 'G': []}
+h = {'A': 6, 'B': 4, 'C': 4, 'D': 2, 'E': 3, 'F': 1, 'G': 0}
+
+def a_star(start, goal):
+    q, visited = [(h[start], 0, start, [start])], set()
+    while q:
+        f, g, u, path = heapq.heappop(q)
+        if u == goal: return path, g
+        if u not in visited:
+            visited.add(u)
+            for n, cost in graph[u]:
+                heapq.heappush(q, (g + cost + h[n], g + cost, n, path + [n]))
+
+path, cost = a_star('A', 'G')
+print("Shortest Path:", path)
+print("Total Cost:", cost)

skl_core-1.0.0/src/skl/modules/p04_csp.py

@@ -0,0 +1,22 @@
+# Program 04: Constraint Satisfaction Problem (Map Coloring)
+
+colors = ['Red', 'Green', 'Blue']
+regions = ['A', 'B', 'C', 'D']
+neighbors = {'A': ['B', 'C'], 'B': ['A', 'C', 'D'], 'C': ['A', 'B', 'D'], 'D': ['B', 'C']}
+assignment = {}
+
+def solve(i=0):
+    if i == len(regions): return True
+    r = regions[i]
+    for c in colors:
+        if all(assignment.get(n) != c for n in neighbors[r]):
+            assignment[r] = c
+            if solve(i + 1): return True
+            del assignment[r]
+    return False
+
+if solve():
+    print("Solution:")
+    for r, c in assignment.items(): print(r, "=", c)
+else:
+    print("No solution exists")

skl_core-1.0.0/src/skl/modules/p05_rules.py

@@ -0,0 +1,11 @@
+# Program 05: Production Rule Inference System
+
+print("DIAGNOSTIC EXPERT SYSTEM\n" + "-" * 24)
+ask = lambda s: input(f"Presence of {s}? (yes/no): ").strip().lower() == "yes"
+fever, cough, cold, headache = ask("fever"), ask("cough"), ask("cold"), ask("headache")
+
+if fever and cough: print("Diagnosis: Flu")
+elif fever and headache: print("Diagnosis: Viral Fever")
+elif cold and cough: print("Diagnosis: Common Cold")
+elif headache: print("Diagnosis: Headache")
+else: print("Diagnosis: Inconclusive / Undetermined")

skl_core-1.0.0/src/skl/modules/p06_minimax.py

@@ -0,0 +1,22 @@
+# Program 06: Minimax Decision Strategy
+
+wins = [(0,1,2),(3,4,5),(6,7,8),(0,3,6),(1,4,7),(2,5,8),(0,4,8),(2,4,6)]
+
+def check_winner(b):
+    for x, y, z in wins:
+        if b[x] != ' ' and b[x] == b[y] == b[z]: return 1 if b[x] == 'X' else -1
+    return 0 if ' ' not in b else None
+
+def minimax(b, is_max):
+    w = check_winner(b)
+    if w is not None: return w
+    scores = [minimax(b[:i] + ('X' if is_max else 'O') + b[i+1:], not is_max)
+              for i, c in enumerate(b) if c == ' ']
+    return max(scores) if is_max else min(scores)
+
+def best_move(b):
+    return max((i for i, c in enumerate(b) if c == ' '),
+               key=lambda i: minimax(b[:i] + 'X' + b[i+1:], False))
+
+board = ['O','X','O','X','X',' ',' ',' ','O']
+print("Best move for X is position:", best_move(board) + 1)

skl_core-1.0.0/src/skl/modules/p07_preprocess.py

@@ -0,0 +1,14 @@
+# Program 07: Tabular Data Preprocessing & Cleaning
+
+import pandas as pd
+
+data = {'Name': ['Arun','Bala','Cathy','David','Eva'], 'Age': [20,21,None,22,20], 'Marks': [85,90,78,None,88]}
+df = pd.DataFrame(data)
+print("Original Data:\n", df)
+print("\nMissing Values:\n", df.isnull().sum())
+df['Age'] = df['Age'].fillna(df['Age'].mean())
+df['Marks'] = df['Marks'].fillna(df['Marks'].mean())
+df = df.drop_duplicates()
+print("\nAfter Preprocessing:\n", df)
+df.to_csv("cleaned_data.csv", index=False)
+print("\nCleaned dataset saved successfully.")

skl_core-1.0.0/src/skl/modules/p08_nlp.py

@@ -0,0 +1,13 @@
+# Program 08: Text Tokenization & Lexical Analysis
+
+import nltk
+from nltk.tokenize import word_tokenize
+from collections import Counter
+
+nltk.download('punkt', quiet=True)
+text = "Artificial intelligence is powerful. Artificial intelligence is useful."
+words = [w for w in word_tokenize(text.lower()) if w.isalpha()]
+print("Tokens:\n", words)
+print("\nWord Frequency:")
+for word, count in Counter(words).items():
+    print(word, ":", count)

skl_core-1.0.0/src/skl/modules/p09_bayes.py

@@ -0,0 +1,17 @@
+# Program 09: Multinomial Naive Bayes Classifier
+
+from sklearn.feature_extraction.text import CountVectorizer
+from sklearn.naive_bayes import MultinomialNB
+
+messages = ["win money now", "free lottery ticket", "claim your prize",
+            "meeting at 10 am", "project meeting tomorrow", "submit the assignment"]
+labels = ["Spam", "Spam", "Spam", "Not Spam", "Not Spam", "Not Spam"]
+
+vectorizer = CountVectorizer()
+X = vectorizer.fit_transform(messages)
+model = MultinomialNB().fit(X, labels)
+
+test_msg = ["free money prize"]
+pred = model.predict(vectorizer.transform(test_msg))
+print("Message:", test_msg[0])
+print("Prediction:", pred[0])

skl_core-1.0.0/src/skl/modules/p10_regression.py

@@ -0,0 +1,11 @@
+# Program 10: Ordinary Least Squares Linear Regression
+
+from sklearn.linear_model import LinearRegression
+
+hours = [[1], [2], [3], [4], [5]]
+marks = [20, 35, 50, 65, 80]
+model = LinearRegression().fit(hours, marks)
+
+study_hours = [[6]]
+print("Input Feature:", study_hours[0][0])
+print("Predicted Output:", model.predict(study_hours)[0])

skl_core-1.0.0/src/skl/modules/p11_4queens.py

@@ -0,0 +1,22 @@
+# Program 11: 4-Queens Backtracking Constraint Solver
+
+board = [-1] * 4
+
+def is_safe(r, c):
+    return all(board[i] != c and abs(board[i] - c) != r - i for i in range(r))
+
+def solve(r=0):
+    if r == 4:
+        print("4-Queens Solution:")
+        for i in range(4):
+            print('. ' * board[i] + 'Q ' + '. ' * (3 - board[i]))
+        print("Column Positions:", board)
+        return True
+    for c in range(4):
+        if is_safe(r, c):
+            board[r] = c
+            if solve(r + 1): return True
+            board[r] = -1
+    return False
+
+solve()

skl_core-1.0.0/src/skl/modules/p12_8puzzle.py

@@ -0,0 +1,27 @@
+# Program 12: 8-Puzzle Sliding Tile State Solver
+
+from collections import deque
+
+adj = {0:[1,3], 1:[0,2,4], 2:[1,5], 3:[0,4,6], 4:[1,3,5,7], 5:[2,4,8], 6:[3,7], 7:[4,6,8], 8:[5,7]}
+
+def solve_8_puzzle(start, goal=(1, 2, 3, 4, 5, 6, 7, 8, 0)):
+    q, visited = deque([(start, [start])]), {start}
+    while q:
+        s, path = q.popleft()
+        if s == goal: return path
+        z = s.index(0)
+        for n in adj[z]:
+            nxt = list(s)
+            nxt[z], nxt[n] = nxt[n], nxt[z]
+            t = tuple(nxt)
+            if t not in visited:
+                visited.add(t)
+                q.append((t, path + [t]))
+
+start = (1, 2, 3, 0, 4, 6, 7, 5, 8)
+path = solve_8_puzzle(start)
+print(f"8-Puzzle Solved in {len(path) - 1} moves:\n")
+for step, p in enumerate(path):
+    print(f"Step {step}:")
+    for i in range(0, 9, 3): print(p[i:i+3])
+    print()

skl_core-1.0.0/src/skl/modules/p13_inventory.py

@@ -0,0 +1,27 @@
+# Program 13: Catalog & Inventory Management System
+
+class Library:
+    def __init__(self, books):
+        self.books = books
+
+    def show(self):
+        print("Available items:", self.books)
+
+    def borrow(self, b):
+        if b in self.books:
+            self.books.remove(b)
+            print(f"Issued: {b}")
+        else:
+            print(f"{b} is not available")
+
+    def return_book(self, b):
+        self.books.append(b)
+        print(f"Returned: {b}")
+
+lib = Library(["Concepts", "Basics", "Data Mining", "Machine Learning"])
+print("CATALOG & INVENTORY SYSTEM\n" + "-" * 26)
+lib.show()
+lib.borrow("Concepts")
+lib.borrow("Concepts")
+lib.return_book("Concepts")
+lib.show()

skl_core-1.0.0/src/skl/registry.py

@@ -0,0 +1,448 @@
+# Standard Knowledge & Algorithm Library (SKL) Registry
+
+MODULES = {
+    1: {
+        "id": 1,
+        "key": "setup",
+        "title": "Environment Verification & Core Libraries",
+        "desc": "Verification and imports for essential data science and computation packages.",
+        "steps": [
+            "Import required modules (numpy, pandas, matplotlib, sklearn, nltk, tensorflow).",
+            "Print system status and versions."
+        ],
+        "code": """import numpy, pandas, matplotlib, sklearn, nltk, tensorflow
+print("All libraries loaded successfully!")
+print("NumPy version:", numpy.__version__)
+print("Pandas version:", pandas.__version__)""",
+        "output": """All libraries loaded successfully!
+NumPy version: 2.4.3
+Pandas version: 3.0.2"""
+    },
+    2: {
+        "id": 2,
+        "key": "bfs_dfs",
+        "title": "Graph Traversal (BFS & DFS)",
+        "desc": "Implementation of Breadth-First Search and Depth-First Search on a graph.",
+        "steps": [
+            "Define graph representation via adjacency list dictionary.",
+            "Traverse level-by-level using queue for BFS.",
+            "Traverse branch-by-branch recursively for DFS."
+        ],
+        "code": """graph = {'A': ['B', 'C'], 'B': ['D', 'E'], 'C': ['F'], 'D': [], 'E': ['F'], 'F': []}
+
+def bfs(s):
+    q, v = [s], set()
+    for u in q:
+        if u not in v:
+            print(u, end=' ')
+            v.add(u)
+            q += graph[u]
+
+def dfs(u, v=None):
+    if v is None: v = set()
+    if u not in v:
+        print(u, end=' ')
+        v.add(u)
+        for n in graph[u]: dfs(n, v)
+
+print("BFS Traversal:")
+bfs('A')
+print("\\nDFS Traversal:")
+dfs('A')""",
+        "output": """BFS Traversal:
+A B C D E F 
+DFS Traversal:
+A B D E F C"""
+    },
+    3: {
+        "id": 3,
+        "key": "astar",
+        "title": "A* Pathfinding Algorithm",
+        "desc": "Heuristic search algorithm computing the shortest path using f(n) = g(n) + h(n).",
+        "steps": [
+            "Define weighted graph and heuristic estimates h(n).",
+            "Maintain priority queue ordered by f(n) = cost + h(n).",
+            "Expand lowest f(n) node until goal is reached."
+        ],
+        "code": """import heapq
+
+graph = {'A': [('B', 1), ('C', 3)], 'B': [('D', 3), ('E', 1)], 'C': [('F', 2)],
+         'D': [('G', 2)], 'E': [('G', 4)], 'F': [('G', 1)], 'G': []}
+h = {'A': 6, 'B': 4, 'C': 4, 'D': 2, 'E': 3, 'F': 1, 'G': 0}
+
+def a_star(start, goal):
+    q, visited = [(h[start], 0, start, [start])], set()
+    while q:
+        f, g, u, path = heapq.heappop(q)
+        if u == goal: return path, g
+        if u not in visited:
+            visited.add(u)
+            for n, cost in graph[u]:
+                heapq.heappush(q, (g + cost + h[n], g + cost, n, path + [n]))
+
+path, cost = a_star('A', 'G')
+print("Shortest Path:", path)
+print("Total Cost:", cost)""",
+        "output": """Shortest Path: ['A', 'B', 'D', 'G']
+Total Cost: 6"""
+    },
+    4: {
+        "id": 4,
+        "key": "csp",
+        "title": "Constraint Satisfaction Problem (Map Coloring)",
+        "desc": "Backtracking algorithm ensuring no adjacent nodes share the same label.",
+        "steps": [
+            "Define discrete domain labels and adjacency constraints.",
+            "Assign labels sequentially to unassigned variables.",
+            "Backtrack on constraint violations."
+        ],
+        "code": """colors = ['Red', 'Green', 'Blue']
+regions = ['A', 'B', 'C', 'D']
+neighbors = {'A': ['B', 'C'], 'B': ['A', 'C', 'D'], 'C': ['A', 'B', 'D'], 'D': ['B', 'C']}
+assignment = {}
+
+def solve(i=0):
+    if i == len(regions): return True
+    r = regions[i]
+    for c in colors:
+        if all(assignment.get(n) != c for n in neighbors[r]):
+            assignment[r] = c
+            if solve(i + 1): return True
+            del assignment[r]
+    return False
+
+if solve():
+    print("Solution:")
+    for r, c in assignment.items(): print(r, "=", c)
+else:
+    print("No solution exists")""",
+        "output": """Solution:
+A = Red
+B = Green
+C = Blue
+D = Red"""
+    },
+    5: {
+        "id": 5,
+        "key": "rules",
+        "title": "Production Rule Inference System",
+        "desc": "Forward-chaining rule-based diagnostic engine.",
+        "steps": [
+            "Collect Boolean predicate inputs.",
+            "Evaluate conditional antecedent rules.",
+            "Derive consequent conclusion."
+        ],
+        "code": """print("DIAGNOSTIC EXPERT SYSTEM\\n" + "-" * 24)
+ask = lambda s: input(f"Presence of {s}? (yes/no): ").strip().lower() == "yes"
+fever, cough, cold, headache = ask("fever"), ask("cough"), ask("cold"), ask("headache")
+
+if fever and cough: print("Diagnosis: Flu")
+elif fever and headache: print("Diagnosis: Viral Fever")
+elif cold and cough: print("Diagnosis: Common Cold")
+elif headache: print("Diagnosis: Headache")
+else: print("Diagnosis: Inconclusive / Undetermined")""",
+        "output": """DIAGNOSTIC EXPERT SYSTEM
+------------------------
+Presence of fever? (yes/no): yes
+Presence of cough? (yes/no): no
+Presence of cold? (yes/no): yes
+Presence of headache? (yes/no): yes
+Diagnosis: Viral Fever"""
+    },
+    6: {
+        "id": 6,
+        "key": "minimax",
+        "title": "Minimax Decision Strategy",
+        "desc": "Zero-sum game search algorithm finding optimal moves.",
+        "steps": [
+            "Represent board state as a sequence.",
+            "Recursively maximize utility for agent and minimize for opponent.",
+            "Select action yielding highest minimax score."
+        ],
+        "code": """wins = [(0,1,2),(3,4,5),(6,7,8),(0,3,6),(1,4,7),(2,5,8),(0,4,8),(2,4,6)]
+
+def check_winner(b):
+    for x, y, z in wins:
+        if b[x] != ' ' and b[x] == b[y] == b[z]: return 1 if b[x] == 'X' else -1
+    return 0 if ' ' not in b else None
+
+def minimax(b, is_max):
+    w = check_winner(b)
+    if w is not None: return w
+    scores = [minimax(b[:i] + ('X' if is_max else 'O') + b[i+1:], not is_max)
+              for i, c in enumerate(b) if c == ' ']
+    return max(scores) if is_max else min(scores)
+
+def best_move(b):
+    return max((i for i, c in enumerate(b) if c == ' '),
+               key=lambda i: minimax(b[:i] + 'X' + b[i+1:], False))
+
+board = ['O','X','O','X','X',' ',' ',' ','O']
+print("Best move for X is position:", best_move(board) + 1)""",
+        "output": """Best move for X is position: 6"""
+    },
+    7: {
+        "id": 7,
+        "key": "preprocess",
+        "title": "Tabular Data Preprocessing & Cleaning",
+        "desc": "Handling missing observations, column mean imputation, and record deduplication.",
+        "steps": [
+            "Construct tabular structure with missing indicators.",
+            "Impute null values using central tendencies.",
+            "Eliminate redundant rows and export clean records."
+        ],
+        "code": """import pandas as pd
+
+data = {'Name': ['Arun','Bala','Cathy','David','Eva'], 'Age': [20,21,None,22,20], 'Marks': [85,90,78,None,88]}
+df = pd.DataFrame(data)
+print("Original Data:\\n", df)
+print("\\nMissing Values:\\n", df.isnull().sum())
+df['Age'] = df['Age'].fillna(df['Age'].mean())
+df['Marks'] = df['Marks'].fillna(df['Marks'].mean())
+df = df.drop_duplicates()
+print("\\nAfter Preprocessing:\\n", df)
+df.to_csv("cleaned_data.csv", index=False)
+print("\\nCleaned dataset saved successfully.")""",
+        "output": """Original Data:
+     Name   Age  Marks
+0   Arun  20.0   85.0
+1   Bala  21.0   90.0
+2  Cathy   NaN   78.0
+3  David  22.0    NaN
+4    Eva  20.0   88.0
+
+Missing Values:
+Name     0
+Age      1
+Marks    1
+dtype: int64
+
+After Preprocessing:
+     Name    Age  Marks
+0   Arun  20.00  85.00
+1   Bala  21.00  90.00
+2  Cathy  20.75  78.00
+3  David  22.00  85.25
+4    Eva  20.00  88.00
+
+Cleaned dataset saved successfully."""
+    },
+    8: {
+        "id": 8,
+        "key": "nlp",
+        "title": "Text Tokenization & Lexical Analysis",
+        "desc": "Tokenizing textual content, cleansing punctuation, and computing lexical frequencies.",
+        "steps": [
+            "Load tokenizer models.",
+            "Normalize text casing and segment words.",
+            "Filter alphabetic terms and tally occurrences."
+        ],
+        "code": """import nltk
+from nltk.tokenize import word_tokenize
+from collections import Counter
+
+nltk.download('punkt', quiet=True)
+text = "Artificial intelligence is powerful. Artificial intelligence is useful."
+words = [w for w in word_tokenize(text.lower()) if w.isalpha()]
+print("Tokens:\\n", words)
+print("\\nWord Frequency:")
+for word, count in Counter(words).items():
+    print(word, ":", count)""",
+        "output": """Tokens:
+['artificial', 'intelligence', 'is', 'powerful', 'artificial', 'intelligence', 'is', 'useful']
+
+Word Frequency:
+artificial : 2
+intelligence : 2
+is : 2
+powerful : 1
+useful : 1"""
+    },
+    9: {
+        "id": 9,
+        "key": "bayes",
+        "title": "Multinomial Naive Bayes Classifier",
+        "desc": "Probabilistic text classification using Bag-of-Words and Bayes theorem.",
+        "steps": [
+            "Vectorize raw text corpora into count feature matrices.",
+            "Fit Multinomial Naive Bayes conditional distributions.",
+            "Perform inference on unseen text samples."
+        ],
+        "code": """from sklearn.feature_extraction.text import CountVectorizer
+from sklearn.naive_bayes import MultinomialNB
+
+messages = ["win money now", "free lottery ticket", "claim your prize",
+            "meeting at 10 am", "project meeting tomorrow", "submit the assignment"]
+labels = ["Spam", "Spam", "Spam", "Not Spam", "Not Spam", "Not Spam"]
+
+vectorizer = CountVectorizer()
+X = vectorizer.fit_transform(messages)
+model = MultinomialNB().fit(X, labels)
+
+test_msg = ["free money prize"]
+pred = model.predict(vectorizer.transform(test_msg))
+print("Message:", test_msg[0])
+print("Prediction:", pred[0])""",
+        "output": """Message: free money prize
+Prediction: Spam"""
+    },
+    10: {
+        "id": 10,
+        "key": "regression",
+        "title": "Ordinary Least Squares Linear Regression",
+        "desc": "Fitting a linear relationship between input features and target values.",
+        "steps": [
+            "Prepare feature-target training arrays.",
+            "Fit ordinary least squares parameter weights.",
+            "Predict target response for candidate query point."
+        ],
+        "code": """from sklearn.linear_model import LinearRegression
+
+hours = [[1], [2], [3], [4], [5]]
+marks = [20, 35, 50, 65, 80]
+model = LinearRegression().fit(hours, marks)
+
+study_hours = [[6]]
+print("Input Feature:", study_hours[0][0])
+print("Predicted Output:", model.predict(study_hours)[0])""",
+        "output": """Input Feature: 6
+Predicted Output: 95.0"""
+    },
+    11: {
+        "id": 11,
+        "key": "4queens",
+        "title": "4-Queens Backtracking Constraint Solver",
+        "desc": "Constraint satisfaction placement of 4 non-attacking queens on a 4x4 matrix.",
+        "steps": [
+            "Allocate board array tracking column placement per row index.",
+            "Verify row, column, and diagonal non-conflict safety.",
+            "Backtrack recursively upon encountering dead ends."
+        ],
+        "code": """board = [-1] * 4
+
+def is_safe(r, c):
+    return all(board[i] != c and abs(board[i] - c) != r - i for i in range(r))
+
+def solve(r=0):
+    if r == 4:
+        print("4-Queens Solution:")
+        for i in range(4):
+            print('. ' * board[i] + 'Q ' + '. ' * (3 - board[i]))
+        print("Column Positions:", board)
+        return True
+    for c in range(4):
+        if is_safe(r, c):
+            board[r] = c
+            if solve(r + 1): return True
+            board[r] = -1
+    return False
+
+solve()""",
+        "output": """4-Queens Solution:
+. Q . . 
+. . . Q 
+Q . . . 
+. . Q . 
+Column Positions: [1, 3, 0, 2]"""
+    },
+    12: {
+        "id": 12,
+        "key": "8puzzle",
+        "title": "8-Puzzle Sliding Tile State Solver",
+        "desc": "Breadth-first state graph traversal locating minimum tile transitions.",
+        "steps": [
+            "Model board as a 9-tuple with 0 representing the blank.",
+            "Generate reachable configurations using adjacency swaps.",
+            "Identify minimum transition sequence to target configuration."
+        ],
+        "code": """from collections import deque
+
+adj = {0:[1,3], 1:[0,2,4], 2:[1,5], 3:[0,4,6], 4:[1,3,5,7], 5:[2,4,8], 6:[3,7], 7:[4,6,8], 8:[5,7]}
+
+def solve_8_puzzle(start, goal=(1, 2, 3, 4, 5, 6, 7, 8, 0)):
+    q, visited = deque([(start, [start])]), {start}
+    while q:
+        s, path = q.popleft()
+        if s == goal: return path
+        z = s.index(0)
+        for n in adj[z]:
+            nxt = list(s)
+            nxt[z], nxt[n] = nxt[n], nxt[z]
+            t = tuple(nxt)
+            if t not in visited:
+                visited.add(t)
+                q.append((t, path + [t]))
+
+start = (1, 2, 3, 0, 4, 6, 7, 5, 8)
+path = solve_8_puzzle(start)
+print(f"8-Puzzle Solved in {len(path) - 1} moves:\\n")
+for step, p in enumerate(path):
+    print(f"Step {step}:")
+    for i in range(0, 9, 3): print(p[i:i+3])
+    print()""",
+        "output": """8-Puzzle Solved in 3 moves:
+
+Step 0:
+(1, 2, 3)
+(0, 4, 6)
+(7, 5, 8)
+
+Step 1:
+(1, 2, 3)
+(4, 0, 6)
+(7, 5, 8)
+
+Step 2:
+(1, 2, 3)
+(4, 5, 6)
+(7, 0, 8)
+
+Step 3:
+(1, 2, 3)
+(4, 5, 6)
+(7, 8, 0)"""
+    },
+    13: {
+        "id": 13,
+        "key": "inventory",
+        "title": "Catalog & Inventory Management System",
+        "desc": "Object-oriented state management for item checkout, check-in, and catalog listing.",
+        "steps": [
+            "Encapsulate collection records in a managed object class.",
+            "Implement issue/checkout with condition checks and removals.",
+            "Implement return operations with list restoration."
+        ],
+        "code": """class Library:
+    def __init__(self, books):
+        self.books = books
+
+    def show(self):
+        print("Available items:", self.books)
+
+    def borrow(self, b):
+        if b in self.books:
+            self.books.remove(b)
+            print(f"Issued: {b}")
+        else:
+            print(f"{b} is not available")
+
+    def return_book(self, b):
+        self.books.append(b)
+        print(f"Returned: {b}")
+
+lib = Library(["Concepts", "Basics", "Data Mining", "Machine Learning"])
+print("CATALOG & INVENTORY SYSTEM\\n" + "-" * 26)
+lib.show()
+lib.borrow("Concepts")
+lib.borrow("Concepts")
+lib.return_book("Concepts")
+lib.show()""",
+        "output": """CATALOG & INVENTORY SYSTEM
+--------------------------
+Available items: ['Concepts', 'Basics', 'Data Mining', 'Machine Learning']
+Issued: Concepts
+Concepts is not available
+Returned: Concepts
+Available items: ['Basics', 'Data Mining', 'Machine Learning', 'Concepts']"""
+    }
+}

skl_core-1.0.0/src/skl_core.egg-info/PKG-INFO

@@ -0,0 +1,92 @@
+Metadata-Version: 2.4
+Name: skl-core
+Version: 1.0.0
+Summary: Standard Knowledge & Algorithm Library: search, CSP, game theory, heuristics, and utilities.
+Author: SKL Developers
+License-Expression: MIT
+Keywords: algorithms,search,bfs,dfs,astar,minimax,csp,backtracking,puzzle,utilities
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+
+# SKL (Standard Knowledge & Algorithm Library)
+
+A lightweight Python library providing clean, minimal implementations of standard computer science algorithms, search heuristics, constraint satisfaction problems, and data utilities.
+
+---
+
+## 📦 Installation
+
+```bash
+pip install skl
+```
+
+---
+
+## 🚀 CLI Usage
+
+Access algorithms and code snippets directly from the terminal:
+
+```bash
+# Interactive menu
+skl
+
+# Print & copy 4-Queens solver
+skl 4queen
+
+# Print & copy 8-Puzzle solver
+skl 8puzzle
+
+# Print & copy Inventory management
+skl lib
+
+# Graph traversal (BFS & DFS)
+skl bfs
+
+# Pathfinding (A* search)
+skl astar
+
+# Dump all algorithm scripts to the current directory
+skl saveall
+```
+
+---
+
+## ⚡ Direct Code Execution & Clipboard
+
+- **Automatic Clipboard Copy**: Every query automatically copies the compact code directly to your system clipboard (press `Ctrl + V` to paste into any editor).
+- **Run on Demand**:
+  ```bash
+  skl 4queen --run
+  skl 8puzzle --run
+  skl astar --run
+  ```
+
+---
+
+## 🐍 Python Import API
+
+```python
+import skl
+
+# Execute algorithm
+skl.run("4queen")
+skl.run("8puzzle")
+
+# Retrieve raw code string
+snippet = skl.code("lib")
+print(snippet)
+
+# Copy to clipboard
+skl.copy("astar")
+
+# Save all files locally
+skl.save_all("./scripts")
+```
+
+---
+
+## 📄 License
+MIT

skl_core-1.0.0/src/skl_core.egg-info/SOURCES.txt

@@ -0,0 +1,25 @@
+README.md
+pyproject.toml
+src/skl/__init__.py
+src/skl/__main__.py
+src/skl/cli.py
+src/skl/registry.py
+src/skl/modules/__init__.py
+src/skl/modules/p01_setup.py
+src/skl/modules/p02_bfs_dfs.py
+src/skl/modules/p03_astar.py
+src/skl/modules/p04_csp.py
+src/skl/modules/p05_rules.py
+src/skl/modules/p06_minimax.py
+src/skl/modules/p07_preprocess.py
+src/skl/modules/p08_nlp.py
+src/skl/modules/p09_bayes.py
+src/skl/modules/p10_regression.py
+src/skl/modules/p11_4queens.py
+src/skl/modules/p12_8puzzle.py
+src/skl/modules/p13_inventory.py
+src/skl_core.egg-info/PKG-INFO
+src/skl_core.egg-info/SOURCES.txt
+src/skl_core.egg-info/dependency_links.txt
+src/skl_core.egg-info/entry_points.txt
+src/skl_core.egg-info/top_level.txt

skl_core-1.0.0/src/skl_core.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

skl_core-1.0.0/src/skl_core.egg-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+sk-lib = skl.cli:main
+skl = skl.cli:main

skl_core-1.0.0/src/skl_core.egg-info/top_level.txt

@@ -0,0 +1 @@
+skl