modelit 0.2.5__tar.gz → 0.2.6__tar.gz

{modelit-0.2.5 → modelit-0.2.6}/CONTRIBUTING.md

@@ -17,6 +17,8 @@ modelit/templates/<name>/
 modelit/templates/<name>/template.py
 ```
 
+For multi-file templates, add more files in the same folder.
+
 4. Make sure the folder name is the function name.
 5. Test it locally:
 
@@ -39,6 +41,7 @@ modelit create <name>
 - Do not add `metadata.json`.
 - Keep file names lowercase.
 - Prefer clean, beginner-friendly code.
+- If a template has multiple files, `--output` should be treated as a directory.
 
 ## Pull request flow
 

{modelit-0.2.5 → modelit-0.2.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: modelit
-Version: 0.2.5
+Version: 0.2.6
 Summary: Local-first ML starter templates you can print or save
 Author: Yashsmith
 License-Expression: MIT
@@ -28,6 +28,8 @@ ModelIt is a tiny Python package for storing your ML/DL boilerplate templates.
 - `perceptron()` prints the full code
 - `perceptron(output="code1.py")` saves it to a file
 - `modelit create perceptron` works from the terminal
+- single-file templates write to a file
+- multi-file templates write to a folder
 
 ## Install
 
@@ -94,6 +96,8 @@ modelit/templates/mycode/template.java
 
 3. Done. The folder name becomes the function name.
 
+If a template has more than one file, `--output` must be a directory path.
+
 That means this will work automatically:
 
 ```python
@@ -109,6 +113,12 @@ modelit create mycode
 modelit create mycode --output mycode.py
 ```
 
+For multi-file templates:
+
+```bash
+modelit create solid_notification --output out/solid_notification
+```
+
 ## Publish flow
 
 1. Add a new template folder.

{modelit-0.2.5 → modelit-0.2.6}/README.md

@@ -8,6 +8,8 @@ ModelIt is a tiny Python package for storing your ML/DL boilerplate templates.
 - `perceptron()` prints the full code
 - `perceptron(output="code1.py")` saves it to a file
 - `modelit create perceptron` works from the terminal
+- single-file templates write to a file
+- multi-file templates write to a folder
 
 ## Install
 
@@ -74,6 +76,8 @@ modelit/templates/mycode/template.java
 
 3. Done. The folder name becomes the function name.
 
+If a template has more than one file, `--output` must be a directory path.
+
 That means this will work automatically:
 
 ```python
@@ -89,6 +93,12 @@ modelit create mycode
 modelit create mycode --output mycode.py
 ```
 
+For multi-file templates:
+
+```bash
+modelit create solid_notification --output out/solid_notification
+```
+
 ## Publish flow
 
 1. Add a new template folder.

{modelit-0.2.5 → modelit-0.2.6}/modelit/cli.py

@@ -17,7 +17,7 @@ def main(argv: list[str] | None = None) -> None:
 
     create_parser = subparsers.add_parser("create", help="Print or save a template")
     create_parser.add_argument("name", choices=available_models(), help="Template name")
-    create_parser.add_argument("-o", "--output", help="Write the template to a file instead of printing")
+    create_parser.add_argument("-o", "--output", help="Write to a file for single-file templates or a directory for multi-file templates")
     create_parser.set_defaults(func=_create)
 
     args = parser.parse_args(argv)

modelit-0.2.6/modelit/registry.py

@@ -0,0 +1,92 @@
+"""Template discovery and loading."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from importlib.resources import files
+from pathlib import Path
+
+PACKAGE_NAME = "modelit"
+TEMPLATES_DIR = "templates"
+
+@dataclass(frozen=True)
+class TemplateInfo:
+    name: str
+
+def _templates_root():
+    return files(PACKAGE_NAME).joinpath(TEMPLATES_DIR)
+
+def _template_dir(name: str):
+    return _templates_root().joinpath(name)
+
+def available_models() -> tuple[str, ...]:
+    root = _templates_root()
+    if not root.is_dir():
+        return ()
+
+    names: list[str] = []
+    for child in root.iterdir():
+        if child.is_dir() and not child.name.startswith("__"):
+            if any(child.iterdir()):
+                names.append(child.name)
+    return tuple(sorted(names))
+
+def load_metadata(name: str) -> TemplateInfo:
+    return TemplateInfo(name=name)
+
+def load_template_files(name: str) -> dict[str, str]:
+    target_dir = _template_dir(name)
+    if not target_dir.is_dir():
+        raise FileNotFoundError(f"Missing template directory for {name!r}")
+        
+    file_contents = {}
+    for child in target_dir.iterdir():
+        if child.is_file() and not child.name.startswith("__"):
+            file_contents[child.name] = child.read_text(encoding="utf-8")
+    return file_contents
+
+def build_template_callable(name: str):
+    files_dict = load_template_files(name)
+    info = load_metadata(name)
+
+    is_single_file = len(files_dict) == 1
+    default_filename = list(files_dict.keys())[0] if is_single_file else name
+
+    def runner(output: str | None = None) -> None:
+        if output:
+            out_path = Path(output)
+
+            if is_single_file:
+                if out_path.exists():
+                    raise FileExistsError(f"Output path already exists: {out_path}")
+                out_path.parent.mkdir(parents=True, exist_ok=True)
+                out_path.write_text(list(files_dict.values())[0], encoding="utf-8")
+                print(f"Generated {out_path}")
+            else:
+                if out_path.suffix:
+                    raise ValueError("Multi-file templates require a directory output path")
+                if out_path.exists() and not out_path.is_dir():
+                    raise FileExistsError(f"Output path already exists and is not a directory: {out_path}")
+                out_path.mkdir(parents=True, exist_ok=True)
+                for fname, content in files_dict.items():
+                    file_path = out_path / fname
+                    if file_path.exists():
+                        print(f"Skipping {file_path} (already exists)")
+                        continue
+                    file_path.write_text(content, encoding="utf-8")
+                    print(f"Generated {file_path}")
+            return None
+
+        # If no output is specified, print to terminal
+        for fname, content in files_dict.items():
+            if not is_single_file:
+                print(f"\n{'='*40}\nFile: {fname}\n{'='*40}")
+            print(content, end="\n\n" if not is_single_file else "")
+
+    runner.__name__ = name
+    runner.__qualname__ = name
+    runner.__module__ = "modelit"
+    runner.__doc__ = f"Print or save the {name} template."
+    runner.output_file = default_filename  # type: ignore[attr-defined]
+    runner.template_info = info  # type: ignore[attr-defined]
+    return runner

modelit-0.2.6/modelit/templates/advanced_exceptions/template.java

@@ -0,0 +1,42 @@
+import java.io.BufferedReader;
+import java.io.FileReader;
+import java.io.IOException;
+
+class InsufficientFundsException extends Exception {
+    public InsufficientFundsException(String message) {
+        super(message);
+    }
+}
+
+public class AdvancedExceptionDemo {
+    
+    public static void processTransfer(int accountBalance, int transferAmount) throws InsufficientFundsException {
+        if (transferAmount > accountBalance) {
+            throw new InsufficientFundsException("Transfer failed: Attempted to send $" + transferAmount + " but balance is $" + accountBalance);
+        }
+        System.out.println("Transfer of $" + transferAmount + " completed successfully.");
+    }
+
+    public static void main(String[] args) {
+        try {
+            processTransfer(5000, 7500);
+        } catch (InsufficientFundsException e) {
+            System.err.println("Business Error: " + e.getMessage());
+        }
+
+        System.out.println("-----------------");
+
+        String filePath = "non_existent_transactions.csv";
+        
+        try (BufferedReader reader = new BufferedReader(new FileReader(filePath))) {
+            System.out.println(reader.readLine());
+            int value = Integer.parseInt("Not_A_Number"); 
+            
+        } catch (IOException | NumberFormatException e) {
+            System.err.println("System Failure: Could not process file or format was corrupted.");
+            System.err.println("Root Cause: " + e.getClass().getSimpleName() + " -> " + e.getMessage());
+        } finally {
+            System.out.println("Cleanup executed. System remains stable.");
+        }
+    }
+}

modelit-0.2.6/modelit/templates/assertions/template.java

@@ -0,0 +1,19 @@
+class DiscountCalculator {
+    public static double applyDiscount(double originalPrice, double discountPercentage) {
+        double discountAmount = originalPrice * (discountPercentage / 100);
+        double finalPrice = originalPrice - discountAmount;
+        
+        assert finalPrice >= 0 : "CRITICAL LOGIC ERROR: Final price fell below zero!";
+        
+        return finalPrice;
+    }
+}
+
+public class AssertionDemo {
+    public static void main(String[] args) {
+        System.out.println("Final Price: $" + DiscountCalculator.applyDiscount(1000, 20));
+        
+        System.out.println("Testing invalid logic...");
+        System.out.println("Final Price: $" + DiscountCalculator.applyDiscount(500, 150)); 
+    }
+}

modelit-0.2.6/modelit/templates/diffusion/template.py

@@ -0,0 +1,231 @@
+# =========================================================
+# DENOISING DIFFUSION PROBABILISTIC MODEL (DDPM)
+# Learning the y = -x Manifold via Reverse Diffusion
+# Built using PyTorch
+# =========================================================
+
+
+# =========================================================
+# IMPORTS
+# =========================================================
+
+import numpy as np
+import torch
+import torch.nn as nn
+import torch.optim as optim
+import matplotlib.pyplot as plt
+
+
+# =========================================================
+# DATA GENERATION FUNCTION (REAL MANIFOLD)
+# =========================================================
+
+def sample_line_data(n_samples=512):
+
+    x = torch.empty(n_samples, 1).uniform_(-4.5, 4.5)
+
+    y = -x
+
+    return torch.cat([x, y], dim=1)
+
+
+# =========================================================
+# DIFFUSION HYPERPARAMETERS & SCHEDULING
+# =========================================================
+
+steps = 120
+
+betas = torch.linspace(2e-4, 0.015, steps)
+
+alphas = 1.0 - betas
+
+alpha_cum = torch.cumprod(alphas, dim=0)
+
+
+# =========================================================
+# FORWARD DIFFUSION PROCESS (NOISING)
+# =========================================================
+
+def diffuse(x0, t_idx):
+
+    noise = torch.randn_like(x0)
+
+    a_bar = alpha_cum[t_idx].view(-1, 1)
+
+    x_t = torch.sqrt(a_bar) * x0 + torch.sqrt(1 - a_bar) * noise
+
+    return x_t, noise
+
+
+# =========================================================
+# NOISE ESTIMATOR NETWORK (MLP WITH TIME EMBEDDING)
+# =========================================================
+
+class NoiseEstimator(nn.Module):
+
+    def __init__(self, dim=2, hidden=128):
+
+        super().__init__()
+
+        self.mlp = nn.Sequential(
+
+            nn.Linear(dim + 16, hidden),
+
+            nn.SiLU(),
+
+            nn.Linear(hidden, hidden),
+
+            nn.SiLU(),
+
+            nn.Linear(hidden, dim)
+
+        )
+
+
+    def time_embed(self, t):
+
+        half = 8
+
+        freqs = torch.exp(torch.linspace(0, 3, half))
+
+        t = t.float().unsqueeze(1)
+
+        emb = torch.cat(
+            [torch.sin(t / freqs), torch.cos(t / freqs)], 
+            dim=1
+        )
+
+        return emb
+
+
+    def forward(self, x, t):
+
+        t_emb = self.time_embed(t)
+
+        return self.mlp(torch.cat([x, t_emb], dim=1))
+
+
+# =========================================================
+# INITIALIZATION & CONFIGURATION
+# =========================================================
+
+model = NoiseEstimator()
+
+opt = optim.Adam(model.parameters(), lr=2e-3)
+
+loss_fn = nn.L1Loss()
+
+epochs = 1800
+
+batch = 128
+
+
+# =========================================================
+# DIFFUSION MODEL TRAINING LOOP
+# =========================================================
+
+print("\n=================================================")
+print("TRAINING DENOISING DIFFUSION MODEL")
+print("=================================================")
+
+for ep in range(epochs):
+
+    x0 = sample_line_data(batch)
+
+    t = torch.randint(0, steps, (batch,))
+
+    xt, eps = diffuse(x0, t)
+
+    eps_hat = model(xt, t)
+
+    loss = loss_fn(eps_hat, eps)
+
+    opt.zero_grad()
+
+    loss.backward()
+
+    opt.step()
+
+
+    # =========================================================
+    # PROGRESS LOGGING
+    # =========================================================
+
+    if ep % 300 == 0:
+
+        print(f"Epoch {ep:04d} | L1 Loss: {loss.item():.5f}")
+
+
+print("\nDiffusion Training Complete.")
+
+
+# =========================================================
+# REVERSE DIFFUSION PROCESS (GENERATION)
+# =========================================================
+
+@torch.no_grad()
+def generate(n=800):
+
+    x = torch.randn(n, 2)
+
+    for t in reversed(range(steps)):
+
+        t_batch = torch.full((n,), t)
+
+        eps = model(x, t_batch)
+
+        a = alphas[t]
+
+        a_bar = alpha_cum[t]
+
+        b = betas[t]
+
+        coef1 = 1 / torch.sqrt(a)
+
+        coef2 = (1 - a) / torch.sqrt(1 - a_bar)
+
+        noise = torch.randn_like(x) if t > 0 else 0
+
+        x = coef1 * (x - coef2 * eps) + torch.sqrt(b) * noise
+
+    return x
+
+
+# =========================================================
+# GENERATING SAMPLES FOR EVALUATION
+# =========================================================
+
+real = sample_line_data(1000)
+
+fake = generate(1000)
+
+
+# =========================================================
+# VISUALIZATION
+# =========================================================
+
+plt.figure(figsize=(6, 6))
+
+plt.scatter(
+    real[:, 0], 
+    real[:, 1], 
+    s=5, 
+    alpha=0.4, 
+    label="Real data"
+)
+
+plt.scatter(
+    fake[:, 0], 
+    fake[:, 1], 
+    s=5, 
+    alpha=0.4, 
+    label="Generated"
+)
+
+plt.legend()
+
+plt.title("Diffusion learns y = -x manifold")
+
+plt.axis("equal")
+
+plt.show()

modelit-0.2.6/modelit/templates/gan/template.py

@@ -0,0 +1,233 @@
+# =========================================================
+# GENERATIVE ADVERSARIAL NETWORK (GAN) FOR 2D DISTRIBUTION
+# Learning the y = -x Manifold from Scratch
+# Built using PyTorch
+# =========================================================
+
+
+# =========================================================
+# IMPORTS
+# =========================================================
+
+import torch
+import torch.nn as nn
+import torch.optim as optim
+import matplotlib.pyplot as plt
+
+
+# =========================================================
+# HYPERPARAMETERS & DEVICE CONFIGURATION
+# =========================================================
+
+batch_size = 128
+
+noise_dim = 2
+
+lr = 0.0002
+
+epochs = 2000
+
+device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+
+
+# =========================================================
+# DATA GENERATION FUNCTION (REAL DISTRIBUTION)
+# =========================================================
+
+def get_real_samples(batch_size):
+
+    x = torch.randn(batch_size, 1)
+
+    y = -x
+
+    data = torch.cat([x, y], dim=1)
+
+    return data.to(device)
+
+
+# =========================================================
+# GENERATOR ARCHITECTURE
+# =========================================================
+
+class Generator(nn.Module):
+
+    def __init__(self):
+
+        super().__init__()
+
+        self.model = nn.Sequential(
+
+            nn.Linear(noise_dim, 16),
+
+            nn.ReLU(),
+
+            nn.Linear(16, 16),
+
+            nn.ReLU(),
+
+            nn.Linear(16, 2)
+
+        )
+
+
+    def forward(self, z):
+
+        return self.model(z)
+
+
+# =========================================================
+# DISCRIMINATOR ARCHITECTURE
+# =========================================================
+
+class Discriminator(nn.Module):
+
+    def __init__(self):
+
+        super().__init__()
+
+        self.model = nn.Sequential(
+
+            nn.Linear(2, 16),
+
+            nn.ReLU(),
+
+            nn.Linear(16, 16),
+
+            nn.ReLU(),
+
+            nn.Linear(16, 1),
+
+            nn.Sigmoid()
+
+        )
+
+
+    def forward(self, x):
+
+        return self.model(x)
+
+
+# =========================================================
+# MODEL INITIALIZATION & OPTIMIZERS
+# =========================================================
+
+G = Generator().to(device)
+
+D = Discriminator().to(device)
+
+criterion = nn.BCELoss()
+
+optimizer_G = optim.Adam(G.parameters(), lr=lr)
+
+optimizer_D = optim.Adam(D.parameters(), lr=lr)
+
+
+# =========================================================
+# GAN TRAINING LOOP
+# =========================================================
+
+print("\n=================================================")
+print("TRAINING GENERATIVE ADVERSARIAL NETWORK")
+print("=================================================")
+
+for epoch in range(epochs):
+
+
+    # =========================================================
+    # TRAIN DISCRIMINATOR
+    # =========================================================
+
+    real_data = get_real_samples(batch_size)
+
+    real_labels = torch.ones(batch_size, 1).to(device)
+
+    noise = torch.randn(batch_size, noise_dim).to(device)
+
+    fake_data = G(noise)
+
+    fake_labels = torch.zeros(batch_size, 1).to(device)
+
+    real_preds = D(real_data)
+
+    fake_preds = D(fake_data.detach())
+
+    loss_real = criterion(real_preds, real_labels)
+
+    loss_fake = criterion(fake_preds, fake_labels)
+
+    loss_D = loss_real + loss_fake
+
+    optimizer_D.zero_grad()
+
+    loss_D.backward()
+
+    optimizer_D.step()
+
+
+    # =========================================================
+    # TRAIN GENERATOR
+    # =========================================================
+
+    noise = torch.randn(batch_size, noise_dim).to(device)
+
+    fake_data = G(noise)
+
+    fake_preds = D(fake_data)
+
+    loss_G = criterion(fake_preds, real_labels)
+
+    optimizer_G.zero_grad()
+
+    loss_G.backward()
+
+    optimizer_G.step()
+
+
+    # =========================================================
+    # PROGRESS LOGGING
+    # =========================================================
+
+    if epoch % 200 == 0:
+
+        print(f"Epoch {epoch:04d} | D Loss: {loss_D.item():.4f} | G Loss: {loss_G.item():.4f}")
+
+
+print("\nGAN Training Complete.")
+
+
+# =========================================================
+# EVALUATION & IMAGE GENERATION
+# =========================================================
+
+noise = torch.randn(1000, noise_dim).to(device)
+
+generated = G(noise).detach().cpu()
+
+real = get_real_samples(1000).cpu()
+
+
+# =========================================================
+# VISUALIZATION
+# =========================================================
+
+plt.figure(figsize=(6, 6))
+
+plt.scatter(
+    real[:, 0], 
+    real[:, 1], 
+    label="Real (y=-x)", 
+    alpha=0.5
+)
+
+plt.scatter(
+    generated[:, 0], 
+    generated[:, 1], 
+    label="Generated", 
+    alpha=0.5
+)
+
+plt.legend()
+
+plt.title("GAN Learning y = -x Distribution")
+
+plt.show()