Hildie

A Python monorepo built with Bazel, named after the best dog.

About

Hildie is a collection of Python utilities and tools, packaged as a single installable module. This project demonstrates a modern Python monorepo structure using Bazel for builds, testing, and publishing.

Why "Hildie"? Because all the good package names were taken, so this project is named after Hildie — the adorable pup you see above, peacefully napping with her favorite stuffed horse.

Installation

# Install main hildie package
pip install hildie

# Install hildie with optional Python bindings (Rust, Go, C++)
pip install hildie[bindings]

Features

• Modular Design: Multiple sub-packages under a single namespace
• Multi-Language: Rust, Go, Node.js, Java, and C++ implementations
• Python Bindings: Use Rust, Go, and C++ directly from Python via PyO3 and ctypes
• IPython/Jupyter Support: Full support for interactive environments
• Bazel Build System: Fast, reproducible builds with caching
• Automated Publishing: Tag a release and it's automatically published to PyPI, npm, Maven, crates.io
• Fully Tested: Comprehensive test coverage across all packages and languages

Packages

Python Packages

Other Languages

Quick Start

Basic Usage

from hildie.hildie_library import add, multiply

# Simple math operations
result = add(2, 3)      # Returns: 5
product = multiply(4, 5) # Returns: 20

Using the App

from hildie.hildie_app import App

app = App()
result = app.process_numbers([1, 2, 3, 4, 5])
print(result)  # {'sum': 15, 'product': 120}

CLI Tools

# After installing hildie
python -m hildie.hildie_cli --help

GitHub Fork Archiver

from hildie.hildie_archive_git_forks.archiver import GitHubForkArchiver

archiver = GitHubForkArchiver(token="your-github-token")
archiver.archive_forks("username")

Python Bindings (Multi-Language)

With the hildie[bindings] extra, use Rust, Go, and C++ from Python:

from hildie_bindings import (
    greet_rust, add_rust,              # Rust bindings (PyO3)
    greet_go, add_go,                   # Go bindings (ctypes)
    process_data, compute_factorial     # C++ bindings (ctypes)
)

# Use Rust functions
print(greet_rust("Hildie"))  # "Hello, Hildie!"
print(add_rust(5, 10))       # 15

# Use Go functions
print(greet_go("Gophers"))   # "Hello, Gophers!"
print(add_go(100, 200))      # 300

# Use C++ functions
print(process_data([1, 2, 3, 4, 5]))    # [2, 4, 6, 8, 10]
print(compute_factorial(5))              # 120

In IPython/Jupyter

Bindings work seamlessly in interactive environments:

# In IPython or Jupyter - just import and use!
from hildie_bindings import greet_rust, add_rust

# Results displayed immediately
greet_rust("World")
add_rust(42, 8)

See Interactive Demo for a complete Jupyter notebook.

API Reference

hildie.hildie_library

hildie.hildie_app

hildie.hildie_archive_git_forks

Development

Prerequisites

• Bazelisk (recommended) or Bazel 7+
• Python 3.11+

Building

# Build all targets
bazel build //...

# Build the wheel
bazel build //:wheel

Testing

# Run all tests
bazel test //...

Running CLIs

bazel run //:hildie-cli
bazel run //:hildie-archive-git-forks

Project Structure

hildie/
├── source/
│   ├── hildie/                        # Multi-language source code
│   │   ├── java/                      # Java packages (Maven Central)
│   │   ├── go/                        # Go packages (pkg.go.dev)
│   │   ├── rust/                      # Rust crates (crates.io)
│   │   ├── node/                      # JavaScript/npm packages
│   │   ├── bindings/                  # Python bindings
│   │   │   └── python/                # PyO3 + ctypes bindings
│   │   │       ├── hildie_bindings/   # Package source
│   │   │       ├── examples/          # Demo scripts & notebooks
│   │   │       └── tests/             # Binding tests
│   │   └── cpp/                       # C++ components
│   └── python/                        # Python build tools
│       ├── build_bindings.py
│       ├── regenerate_requirements.py
│       ├── test_runners.py
│       └── hildie.bzl
├── docs/                              # Documentation
│   ├── *.md                           # All documentation files
│   ├── pyproject.toml
│   └── BUILD.bazel
├── packages/                          # Python package tests
│   ├── my-library/
│   ├── my-app/
│   ├── my-cli/
│   └── archive-git-forks/
├── BUILD.bazel                        # Root build file
├── MODULE.bazel                       # Bazel dependencies
├── pyproject.toml                     # Project metadata
└── README.md                          # This file

Publishing

Releases are automated via GitHub Actions. To publish a new version:

git tag v0.2.0
git push origin v0.2.0

The workflow will:

1. Run all tests
2. Build the wheel with the tagged version
3. Publish to PyPI
4. Create a GitHub release

Contributing

Contributions are welcome! Please feel free to submit a Pull Request.

1. Fork the repository
2. Create your feature branch (git checkout -b feature/amazing-feature)
3. Run tests (bazel test //...)
4. Commit your changes
5. Push to the branch
6. Open a Pull Request

Maintainer

Clinton Steiner — clintonsteiner@gmail.com

• GitHub: @clintonsteiner

License

This project is licensed under the MIT License — see the LICENSE file for details.

Made by Clinton, inspired by Hildie