modelit 0.1.0__py3-none-any.whl

modelit/__init__.py

@@ -0,0 +1,19 @@
+"""ModelIt exports local ML boilerplate templates."""
+
+from __future__ import annotations
+
+from .registry import available_models, build_template_callable
+
+__all__ = list(available_models())
+
+
+def __getattr__(name: str):
+    if name in available_models():
+        fn = build_template_callable(name)
+        globals()[name] = fn
+        return fn
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
+
+
+def __dir__():
+    return sorted(set(globals()) | set(available_models()))

modelit/__main__.py

@@ -0,0 +1,9 @@
+"""Run ModelIt as a module."""
+
+from __future__ import annotations
+
+from .cli import main
+
+
+if __name__ == "__main__":
+    main()

modelit/cli.py

@@ -0,0 +1,24 @@
+"""Command-line entry point for ModelIt."""
+
+from __future__ import annotations
+
+import argparse
+
+from .registry import available_models, build_template_callable
+
+
+def _create(args: argparse.Namespace) -> None:
+    build_template_callable(args.name)(output=args.output)
+
+
+def main(argv: list[str] | None = None) -> None:
+    parser = argparse.ArgumentParser(prog="modelit", description="Print or save ML template code.")
+    subparsers = parser.add_subparsers(dest="command", required=True)
+
+    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.set_defaults(func=_create)
+
+    args = parser.parse_args(argv)
+    args.func(args)

modelit/registry.py

@@ -0,0 +1,94 @@
+"""Template discovery and loading."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from importlib.resources import files
+from pathlib import Path
+import json
+import sys
+
+
+PACKAGE_NAME = "modelit"
+TEMPLATES_DIR = "templates"
+TEMPLATE_FILENAME = "template.py"
+METADATA_FILENAME = "metadata.json"
+
+
+@dataclass(frozen=True)
+class TemplateInfo:
+    name: str
+    title: str
+    output_file: str
+    description: 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 child.joinpath(TEMPLATE_FILENAME).is_file():
+            names.append(child.name)
+    return tuple(sorted(names))
+
+
+def load_metadata(name: str) -> TemplateInfo:
+    metadata_path = _template_dir(name).joinpath(METADATA_FILENAME)
+    data: dict[str, str] = {}
+    if metadata_path.is_file():
+        data = json.loads(metadata_path.read_text(encoding="utf-8"))
+
+    title = data.get("title") or name.replace("_", " ").title()
+    output_file = data.get("output_file") or f"{name}.py"
+    description = data.get("description") or f"Print the {title} template."
+
+    return TemplateInfo(
+        name=name,
+        title=title,
+        output_file=output_file,
+        description=description,
+    )
+
+
+def load_source(name: str) -> str:
+    source_path = _template_dir(name).joinpath(TEMPLATE_FILENAME)
+    if not source_path.is_file():
+        raise FileNotFoundError(f"Missing template source for {name!r}")
+    return source_path.read_text(encoding="utf-8")
+
+
+def build_template_callable(name: str):
+    info = load_metadata(name)
+    source = load_source(name)
+
+    def runner(output: str | None = None) -> None:
+        if output:
+            path = Path(output)
+            if path.exists():
+                raise FileExistsError(f"{path} already exists")
+            path.parent.mkdir(parents=True, exist_ok=True)
+            path.write_text(source, encoding="utf-8")
+            print(f"Generated {path}")
+            return None
+
+        for chunk in source.splitlines(keepends=True):
+            sys.stdout.write(chunk)
+
+    runner.__name__ = name
+    runner.__qualname__ = name
+    runner.__module__ = "modelit"
+    runner.__doc__ = info.description
+    runner.output_file = info.output_file  # type: ignore[attr-defined]
+    runner.template_info = info  # type: ignore[attr-defined]
+    return runner

modelit/templates/perceptron/metadata.json

@@ -0,0 +1,6 @@
+{
+  "name": "perceptron",
+  "title": "Perceptron Learning Algorithm",
+  "output_file": "perceptron.py",
+  "description": "Print the full perceptron learning algorithm example."
+}

modelit/templates/perceptron/template.py

@@ -0,0 +1,319 @@
+# =========================================================
+# PERCEPTRON LEARNING ALGORITHM
+# AND, OR, NAND, NOR using
+# 1. Bipolar Representation
+# 2. Unipolar Representation
+# =========================================================
+
+
+# =========================================================
+# COMMON FUNCTIONS
+# =========================================================
+
+def net_input(w, x, b):
+    net = 0
+
+    for i in range(len(w)):
+        net = net + w[i] * x[i]
+
+    net = net + b
+
+    return net
+
+
+# =========================================================
+# BIPOLAR ACTIVATION FUNCTION
+# output:
+#  1  if net > 0
+#  0  if net = 0
+# -1  if net < 0
+# =========================================================
+
+def bipolar_activation(net):
+
+    if net > 0:
+        return 1
+
+    elif net == 0:
+        return 0
+
+    elif net < 0:
+        return -1
+
+
+# =========================================================
+# UNIPOLAR ACTIVATION FUNCTION
+# output:
+# 1 if net >= 0
+# 0 if net < 0
+# =========================================================
+
+def unipolar_activation(net):
+
+    if net >= 0:
+        return 1
+
+    elif net < 0:
+        return 0
+
+
+# =========================================================
+# ERROR CALCULATION
+# error = desired_output - actual_output
+# =========================================================
+
+def calc_error(output, det_output):
+
+    return (det_output - output)
+
+
+# =========================================================
+# CHANGE IN WEIGHT
+# Δw = c * e * x
+# =========================================================
+
+def delta_w(c, e, x):
+
+    return c * e * x
+
+
+# =========================================================
+# CHANGE IN BIAS
+# Δb = c * e
+# =========================================================
+
+def delta_b(c, e):
+
+    return c * e
+
+
+# =========================================================
+# UPDATE FUNCTION
+# new_value = old_value + delta
+# =========================================================
+
+def update(old, delta):
+
+    return old + delta
+
+
+# =========================================================
+# TRAINING FUNCTION
+# =========================================================
+
+def train_perceptron(data, activation_type, gate_name):
+
+    print("\n=================================================")
+    print(f"{gate_name}")
+    print("=================================================")
+
+    w1 = 0
+    w2 = 0
+    b = 0
+
+    c = 1
+    max_epochs = 100
+
+    print(f"\nInitial weights:")
+    print(f"w1 = {w1}, w2 = {w2}")
+    print(f"Initial Bias:")
+    print(f"b = {b}")
+
+    for epoch in range(max_epochs):
+
+        all_errors = []
+
+        print(f"\nEpoch {epoch + 1}:")
+        print("x1\tx2\td\tnet\to\te\tdel_w1\tdel_w2\tdel_b\tw1\tw2\tb")
+
+        for i in range(len(data)):
+
+            x = data[i][:2]
+            d = data[i][2]
+
+            # Net Input
+            net = net_input([w1, w2], x, b)
+
+            # Activation
+            if activation_type == "bipolar":
+                output = bipolar_activation(net)
+
+            elif activation_type == "unipolar":
+                output = unipolar_activation(net)
+
+            # Error
+            error = calc_error(output, d)
+
+            all_errors.append(error)
+
+            # Weight Updates
+            d_w1 = delta_w(c, error, x[0])
+            w1 = update(w1, d_w1)
+
+            d_w2 = delta_w(c, error, x[1])
+            w2 = update(w2, d_w2)
+
+            # Bias Update
+            d_b = delta_b(c, error)
+            b = update(b, d_b)
+
+            print(
+                f"{x[0]}\t{x[1]}\t{d}\t{net}\t{output}\t{error}\t"
+                f"{d_w1}\t{d_w2}\t{d_b}\t{w1}\t{w2}\t{b}"
+            )
+
+        # Stop if all errors are zero
+        if all(e == 0 for e in all_errors):
+            break
+
+    print(f"\nAll errors zero at epoch {epoch + 1}")
+
+    print("\nFinal weights:")
+    print(f"w1 = {w1}, w2 = {w2}")
+
+    print("Final bias:")
+    print(f"b = {b}")
+
+
+# =========================================================
+# AND GATE USING BIPOLAR
+# =========================================================
+
+X_and_bi = [
+    [-1, -1, -1],
+    [1, -1, -1],
+    [-1, 1, -1],
+    [1, 1, 1]
+]
+
+train_perceptron(
+    X_and_bi,
+    activation_type="bipolar",
+    gate_name="AND Gate using Bipolar"
+)
+
+
+# =========================================================
+# AND GATE USING UNIPOLAR
+# =========================================================
+
+X_and_uni = [
+    [0, 0, 0],
+    [0, 1, 0],
+    [1, 0, 0],
+    [1, 1, 1]
+]
+
+train_perceptron(
+    X_and_uni,
+    activation_type="unipolar",
+    gate_name="AND Gate using Unipolar"
+)
+
+
+# =========================================================
+# OR GATE USING BIPOLAR
+# =========================================================
+
+X_or_bi = [
+    [-1, -1, -1],
+    [1, -1, 1],
+    [-1, 1, 1],
+    [1, 1, 1]
+]
+
+train_perceptron(
+    X_or_bi,
+    activation_type="bipolar",
+    gate_name="OR Gate using Bipolar"
+)
+
+
+# =========================================================
+# OR GATE USING UNIPOLAR
+# =========================================================
+
+X_or_uni = [
+    [0, 0, 0],
+    [1, 0, 1],
+    [0, 1, 1],
+    [1, 1, 1]
+]
+
+train_perceptron(
+    X_or_uni,
+    activation_type="unipolar",
+    gate_name="OR Gate using Unipolar"
+)
+
+
+# =========================================================
+# NAND GATE USING UNIPOLAR
+# =========================================================
+
+X_nand_uni = [
+    [0, 0, 1],
+    [0, 1, 1],
+    [1, 0, 1],
+    [1, 1, 0]
+]
+
+train_perceptron(
+    X_nand_uni,
+    activation_type="unipolar",
+    gate_name="NAND Gate using Unipolar"
+)
+
+
+# =========================================================
+# NOR GATE USING UNIPOLAR
+# =========================================================
+
+X_nor_uni = [
+    [0, 0, 1],
+    [0, 1, 0],
+    [1, 0, 0],
+    [1, 1, 0]
+]
+
+train_perceptron(
+    X_nor_uni,
+    activation_type="unipolar",
+    gate_name="NOR Gate using Unipolar"
+)
+
+
+# =========================================================
+# NAND GATE USING BIPOLAR
+# =========================================================
+
+X_nand_bi = [
+    [-1, -1, 1],
+    [-1, 1, 1],
+    [1, -1, 1],
+    [1, 1, -1]
+]
+
+train_perceptron(
+    X_nand_bi,
+    activation_type="bipolar",
+    gate_name="NAND Gate using Bipolar"
+)
+
+
+# =========================================================
+# NOR GATE USING BIPOLAR
+# =========================================================
+
+X_nor_bi = [
+    [-1, -1, 1],
+    [-1, 1, -1],
+    [1, -1, -1],
+    [1, 1, -1]
+]
+
+train_perceptron(
+    X_nor_bi,
+    activation_type="bipolar",
+    gate_name="NOR Gate using Bipolar"
+)

modelit-0.1.0.dist-info/METADATA

@@ -0,0 +1,94 @@
+Metadata-Version: 2.4
+Name: modelit
+Version: 0.1.0
+Summary: Local-first ML starter templates you can print or save
+Author: Yashsmith
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/Yashsmith/modelit
+Project-URL: Source, https://github.com/Yashsmith/modelit
+Project-URL: Issues, https://github.com/Yashsmith/modelit/issues
+Keywords: ml,deep-learning,templates,boilerplate,pytorch,scikit-learn
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Operating System :: OS Independent
+Classifier: Intended Audience :: Education
+Classifier: Intended Audience :: Developers
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# ModelIt
+
+Tiny local-first ML template printer.
+
+## Install
+
+```bash
+pip install modelit
+```
+
+For development from a clone, use:
+
+```bash
+pip install -e .
+```
+
+## Run
+
+```python
+from modelit import perceptron
+
+perceptron()
+```
+
+Or from CLI:
+
+```bash
+modelit create perceptron
+```
+
+## Save to file
+
+```python
+from modelit import perceptron
+
+perceptron(output="code1.py")
+```
+
+Or:
+
+```bash
+modelit create perceptron --output code1.py
+```
+
+Then run:
+
+```bash
+python3 code1.py
+```
+
+## Publish
+
+This project is set up for PyPI publishing with GitHub Actions.
+
+1. Push a tag like `v0.1.0`
+2. GitHub Actions builds and publishes to PyPI
+3. Users install with `pip install modelit`
+
+To update later, change the version, add your new templates, and publish a new tag.
+
+## Add a new code
+
+Create:
+
+```text
+modelit/templates/<name>/template.py
+modelit/templates/<name>/metadata.json
+```
+
+Then the new name is exposed automatically as:
+
+```python
+from modelit import <name>
+```

modelit-0.1.0.dist-info/RECORD

@@ -0,0 +1,12 @@
+modelit/__init__.py,sha256=HWqcsz1ZnP26mu4h8HhzJcNuy5TB40Y-PgY_Nl3jaaY,498
+modelit/__main__.py,sha256=S3dwPvsSp3kFstl1emKzBvsO-Tkd9Rx-SVRlD9tmoW4,130
+modelit/cli.py,sha256=CXeDARDv8QsIJgfb8N3nw_sZewQar9umL2WSvV8MLe8,873
+modelit/registry.py,sha256=HAdYMfiJZvJr93qep54RqWWeuXlOaBXOUFCzNQcVyeE,2612
+modelit/templates/perceptron/metadata.json,sha256=whYa5Gsf3u-a2YBtZyj5MfbPRpZL0vjucZO56W0DAuI,179
+modelit/templates/perceptron/template.py,sha256=PGC3C7coO031FGBVzPG07l3TH0z-_yxAU149-9GsPPs,6587
+modelit-0.1.0.dist-info/licenses/LICENSE,sha256=lXD4AUG6BxKcVQQyo1ZZ1EmLeddhv5BiTijXn9dxniw,1073
+modelit-0.1.0.dist-info/METADATA,sha256=eF89jySNBo479KgWbmx9mpkybcK-XmVAN8TTKozsx94,1724
+modelit-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+modelit-0.1.0.dist-info/entry_points.txt,sha256=lo9IncMlsAGm4J-pBatrr6jRX5YZnpnIXXxQBc5bEyM,45
+modelit-0.1.0.dist-info/top_level.txt,sha256=9Xbdh13DiWvN4gKgklCotpkFXxGoIQivD_JOihCKHHA,8
+modelit-0.1.0.dist-info/RECORD,,

modelit-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

modelit-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+modelit = modelit.cli:main

modelit-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Sameer Yashsmith
+
+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.

modelit-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+modelit