nnflow 0.1.0__tar.gz

nnflow-0.1.0/.github/workflows/publish.yml

@@ -0,0 +1,63 @@
+name: Build and Publish to PyPI
+
+on:
+  release:
+    types: [published] # Triggers when you create a new GitHub Release
+  workflow_dispatch:   # Allows you to manually trigger it via GitHub UI if needed
+
+jobs:
+  # JOB 1: Build wheels and source distribution on Ubuntu Linux
+  build_package:
+    name: Build wheels and sdist on Ubuntu
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Check out repository
+        uses: actions/checkout@v4
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.11"
+
+      - name: Install build tools
+        run: |
+          python -m pip install --upgrade pip
+          pip install cibuildwheel build
+
+      - name: Build C++ Binary Wheels
+        run: python -m cibuildwheel --output-dir dist
+        env:
+          # Targets standard 64-bit Linux architectures only
+          CIBW_BUILD: "cp*-manylinux_x86_64"
+          CIBW_BUILD_FRONTEND: "build"
+
+      - name: Build Source Distribution (sdist)
+        run: python -m build --sdist --outdir dist
+
+      - name: Upload Artifacts for Safety
+        uses: actions/upload-artifact@v4
+        with:
+          name: pypi-artifacts-${{ github.sha }}
+          path: ./dist/*
+
+  # JOB 2: Safely authenticate and upload to PyPI
+  publish:
+    name: Publish package to PyPI
+    needs: build_package
+    runs-on: ubuntu-latest
+    environment:
+      name: pypi
+      url: https://pypi.org
+    permissions:
+      id-token: write # Required for PyPI Trusted Publisher OIDC authentication
+
+    steps:
+      - name: Download built distributions
+        uses: actions/download-artifact@v4
+        with:
+          name: pypi-artifacts-${{ github.sha }}
+          path: dist
+
+      - name: Publish package distributions to PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1

nnflow-0.1.0/.gitignore

@@ -0,0 +1,209 @@
+# Created by https://www.toptal.com/developers/gitignore/api/c++,python
+# Edit at https://www.toptal.com/developers/gitignore?templates=c++,python
+
+### C++ ###
+# Prerequisites
+*.d
+
+# Compiled Object files
+*.slo
+*.lo
+*.o
+*.obj
+
+# Precompiled Headers
+*.gch
+*.pch
+
+# Compiled Dynamic libraries
+*.so
+*.dylib
+*.dll
+
+# Fortran module files
+*.mod
+*.smod
+
+# Compiled Static libraries
+*.lai
+*.la
+*.a
+*.lib
+
+# Executables
+*.exe
+*.out
+*.app
+
+### Python ###
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/#use-with-ide
+.pdm.toml
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/
+
+### Python Patch ###
+# Poetry local configuration file - https://python-poetry.org/docs/configuration/#local-configuration
+poetry.toml
+
+# ruff
+.ruff_cache/
+
+# LSP config files
+pyrightconfig.json
+
+# End of https://www.toptal.com/developers/gitignore/api/c++,python

nnflow-0.1.0/.vscode/c_cpp_properties.json

@@ -0,0 +1,19 @@
+{
+    "configurations": [
+        {
+            "name": "Local Env",
+            "includePath": [
+                "${workspaceFolder}/**",
+                "${workspaceFolder}/include",
+                "${workspaceFolder}/.venv/lib/python*/site-packages/pybind11/include",
+                "${workspaceFolder}/.venv/include/site/"
+            ],
+            "defines": [],
+            "compilerPath": "/usr/bin/g++", 
+            "cStandard": "c11",
+            "cppStandard": "c++14",
+            "intelliSenseMode": "linux-gcc-x64"
+        }
+    ],
+    "version": 4
+}

nnflow-0.1.0/.vscode/launch.json

@@ -0,0 +1,9 @@
+{
+    // Use IntelliSense to learn about possible attributes.
+    // Hover to view descriptions of existing attributes.
+    // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
+    "version": "0.2.0",
+    "configurations": [
+    
+    ]
+}

nnflow-0.1.0/CMakeLists.txt

@@ -0,0 +1,20 @@
+cmake_minimum_required(VERSION 3.15)
+project(nnflow_backend LANGUAGES CXX)
+
+# Force standard required for modern pybind11
+set(CMAKE_CXX_STANDARD 14) 
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+
+# Find pybind11 (resolved automatically by uv and scikit-build-core)
+find_package(pybind11 CONFIG REQUIRED)
+
+# Include your header file directory
+include_directories(include layers)
+
+# Compile your main binding file and the underlying batchnorm logic together
+pybind11_add_module(_core 
+    nnflow/main.cpp
+)
+
+# Crucial: Install the binary directly into the flat python folder
+install(TARGETS _core DESTINATION nnflow)

nnflow-0.1.0/PKG-INFO

@@ -0,0 +1,7 @@
+Metadata-Version: 2.2
+Name: nnflow
+Version: 0.1.0
+Summary: NNFlow
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+

nnflow-0.1.0/include/nnf_layer.h

@@ -0,0 +1,40 @@
+#pragma once
+
+#include <map>
+#include <string>
+#include <vector>
+
+using namespace std;
+
+enum NNF_DataType {
+    NNF_UINT8,
+    NNF_INT8,
+    NNF_UINT16,
+    NNF_INT16,
+    NNF_FLOAT16,
+    NNF_BFLOAT16,
+    NNF_FLOAT32
+};
+
+class NNF_Tensor {
+    void *ptr;
+    std::string name;
+    std::vector<int> shape;
+    NNF_DataType dataType;
+};
+
+class NNF_Buffer {
+    std::string name;
+    std::vector<int> shape;
+    NNF_DataType dataType;
+};
+
+class NNF_Layer {
+    std::string name;
+    std::vector<NNF_Buffer*> inputs, outputs;
+};
+
+class NNF_Graph{
+    std::map<string, std::string> metadata;
+    std::vector<NNF_Layer*> layers;
+};

nnflow-0.1.0/layers/batchnorm.h

@@ -0,0 +1,23 @@
+#include <cmath>
+#include <nnf_layer.h>
+
+class BatchNorm : public NNF_Layer {
+public:
+    float eps = 1e-5;
+    float momentum = 0.1;
+    
+    void *scale;
+    void *bias;
+    void *mean;
+    void *variance;
+    
+    BatchNorm(
+        std::string name,
+        float eps, 
+        float momentum
+    ) {
+        name = name;
+        this->eps = eps;
+        this->momentum = momentum;
+    }
+};

nnflow-0.1.0/nnflow/__init__.py

@@ -0,0 +1 @@
+from ._core import *

nnflow-0.1.0/nnflow/main.cpp

@@ -0,0 +1,47 @@
+#include <pybind11/pybind11.h> // Must be included first
+#include <pybind11/stl.h>
+#include <nnf_layer.h>
+#include <batchnorm.h>
+
+namespace py = pybind11;
+
+PYBIND11_MODULE(_core, m) {
+    m.doc() = "nnflow structural and layers C++ backend core plugin";
+
+    // --- Bind Enums ---
+    py::enum_<NNF_DataType>(m, "NNF_DataType")
+        .value("NNF_UINT8", NNF_DataType::NNF_UINT8)
+        .value("NNF_INT8", NNF_DataType::NNF_INT8)
+        .value("NNF_UINT16", NNF_DataType::NNF_UINT16)
+        .value("NNF_INT16", NNF_DataType::NNF_INT16)
+        .value("NNF_FLOAT16", NNF_DataType::NNF_FLOAT16)
+        .value("NNF_BFLOAT16", NNF_DataType::NNF_BFLOAT16)
+        .value("NNF_FLOAT32", NNF_DataType::NNF_FLOAT32)
+        .export_values();
+
+    // --- Bind Base Structural Classes ---
+    py::class_<NNF_Tensor>(m, "NNF_Tensor")
+        .def(py::init<>()); // Assumes a default constructor exists
+
+    py::class_<NNF_Buffer>(m, "NNF_Buffer")
+        .def(py::init<>());
+
+    py::class_<NNF_Layer>(m, "NNF_Layer")
+        .def(py::init<>());
+
+    py::class_<NNF_Graph>(m, "NNF_Graph")
+        .def(py::init<>());
+
+    // --- Bind Derived Layer Subclasses ---
+    // Passing NNF_Layer as the second template argument enables native Python OOP inheritance!
+    py::class_<BatchNorm, NNF_Layer>(m, "BatchNorm")
+        // Binds the constructor with default keyword arguments matching your architecture definitions
+        .def(py::init<std::string, float, float>(),
+             py::arg("name"),
+             py::arg("eps") = 1e-5,
+             py::arg("momentum") = 0.1)
+        
+        // Expose parameters so you can read/write them from Python scripts directly
+        .def_readwrite("eps", &BatchNorm::eps)
+        .def_readwrite("momentum", &BatchNorm::momentum);
+}

nnflow-0.1.0/pyproject.toml

@@ -0,0 +1,13 @@
+[build-system]
+requires = ["scikit-build-core>=0.4.3", "pybind11"]
+build-backend = "scikit_build_core.build"
+
+[project]
+name = "nnflow"
+version = "0.1.0"
+description = "NNFlow"
+readme = "README.md"
+requires-python = ">=3.8"
+
+[tool.scikit-build]
+cmake.build-type = "Release"

nnflow-0.1.0/test.py

@@ -0,0 +1,31 @@
+import nnflow
+
+print("====================================")
+print("🎉 Success! nnflow loaded perfectly.")
+print("====================================")
+
+# 1. Verify and inspect your custom Enum types
+print("Available Data Types:")
+print(f"  - Float32: {nnflow.NNF_DataType.NNF_FLOAT32}")
+print(f"  - BFloat16: {nnflow.NNF_DataType.NNF_BFLOAT16}")
+
+# 2. Instantiate structural classes to confirm their baseline wrappers work
+tensor = nnflow.NNF_Tensor()
+graph = nnflow.NNF_Graph()
+print(f"\nCreated baseline internal C++ objects:")
+print(f"  - Tensor instance: {tensor}")
+print(f"  - Graph instance:  {graph}")
+
+# 3. Create and customize your header-only BatchNorm layer 
+# This runs the inlined constructor we set up in batchnorm.h!
+bn_layer = nnflow.BatchNorm(name="my_batchnorm_layer", eps=1e-4, momentum=0.2)
+
+print(f"\nInstantiated BatchNorm Layer:")
+print(f"  - Object type: {type(bn_layer)}")
+print(f"  - Current eps value: {bn_layer.eps}")
+print(f"  - Current momentum value: {bn_layer.momentum}")
+
+# 4. Modify properties dynamically from Python to confirm read/write bindings
+bn_layer.eps = 3e-5
+print(f"  - Updated eps value: {bn_layer.eps}")
+print("====================================")

nnflow-0.1.0/uv.lock

@@ -0,0 +1,8 @@
+version = 1
+revision = 5
+requires-python = ">=3.8"
+
+[[package]]
+name = "nnflow"
+version = "0.1.0"
+source = { editable = "." }