DEV Community: Selva Ganapathi Arumugam

TamilPY Framework v0.1.10 is now available!

Selva Ganapathi Arumugam — Thu, 30 Jul 2026 09:39:10 +0000

I'm thrilled to announce TamilPY Framework v0.1.10, introducing one of the biggest productivity updates yet! This release brings a visual Studio builder, starter project templates, incremental code generation, and a shared schema foundation—making it faster than ever to build production-ready FastAPI applications.

🎨 TamilPY Studio

The headline feature of this release is TamilPY Studio — a visual application builder for designing your backend with an intuitive interface.

✨ Features include:

Visual Model Designer
Relations Canvas
Database Manager
Authentication Configuration
API Explorer
Schema Diff & Preview
Build Console with live progress
Starter Template Browser

Launch Studio with a single command:

tpy studio

No additional npm install required—the React UI is pre-built and bundled with TamilPY.

🚀 Starter Templates

Kickstart new projects using ready-made templates:

CRM
Institute Admin
Inventory
Helpdesk
Blog CMS

Create a project instantly:

tpy new myapp --template crm

Templates include:

Schema definitions
Admin theme
Seed data
Project README
⚡ Incremental Code Generation

Generate only what you need without rebuilding the entire application.

New commands:

tpy make:model Invoice --fields "amount:float,status:enum(draft,paid)"
tpy make:controller Invoice
tpy make:service Invoice

Generated files now include checksum markers to protect manual changes.

🏗️ Shared Schema Foundation

A completely new schema infrastructure powers both the CLI and Studio.

✅ Deterministic schema serialization

✅ JSON AST bridge for tooling

✅ Shared parse, serialize & validate API

✅ Line-accurate validation errors

✅ Helpful "Did you mean...?" suggestions

🛠️ More Improvements
Semantic validation before code generation
Bundled Studio UI with package distribution
Admin theme presets
Better project scaffolding
Faster developer workflow
📦 Upgrade
pip install --upgrade "tamilPY[all]"
🔗 Resources

📦 PyPI

https://pypi.org/project/tamilPY/

📖 Documentation

https://selvaganapathiarumugam.github.io/tamilPY/

🎨 Studio Guide

https://selvaganapathiarumugam.github.io/tamilPY/studio.html

📚 Starter Templates

https://selvaganapathiarumugam.github.io/tamilPY/templates.html

⚡ Make Commands

https://selvaganapathiarumugam.github.io/tamilPY/make-commands.html

TamilPY Framework continues to evolve into a complete schema-driven FastAPI development platform. With Studio, starter templates, and incremental code generation, v0.1.10 significantly streamlines application development while preserving the framework's schema-first philosophy.

As always, feedback, ideas, and contributions are welcome. Let's keep building together! 🚀

🚀 TamilPY v0.1.9 Released — A Schema-Driven FastAPI Platform Gets Even More Powerful

Selva Ganapathi Arumugam — Wed, 29 Jul 2026 09:40:14 +0000

We're excited to announce TamilPY v0.1.9, our biggest release yet! 🎉

This release transforms TamilPY into a more complete schema-driven FastAPI platform, introducing powerful runtime capabilities, a fluent Query Builder, background jobs, scheduling, caching, application lifecycle management, and a significantly improved developer experience.

Whether you're building APIs, internal tools, or enterprise applications, v0.1.9 helps you build faster while writing less boilerplate.

📚 Documentation

TamilPY Docs

Our documentation has also received a major upgrade with a professional GitHub Pages site featuring clickable feature cards, responsive layouts, and detailed study guides.

✨ What's New in v0.1.9

🔍 Fluent Query Builder

Introducing tpy.query, a schema-driven query builder designed for clean, readable, and secure database queries.

Highlights

Parameterized queries
SQLite support
PostgreSQL support
MySQL support
MongoDB helpers
Built-in pagination
Repository integration

Instead of writing raw SQL, developers can now build expressive queries directly from repositories.

🔗 ORM Relationships

TamilPY now supports ORM-style relationships directly inside schema.tpy.

Supported relationships:

belongs_to
has_one
has_many
belongs_to_many

It also includes eager loading through:

with_()
EagerLoader

This makes complex data retrieval significantly cleaner and faster.

⚡ Event System

A brand-new event-driven architecture is now available.

Features include:

Event
Listener
EventDispatcher
Wildcard listeners
Stop propagation
Process singleton support

Perfect for decoupling business logic from application workflows.

🧵 Queue System

Background job processing is now built into TamilPY.

Supported drivers:

Sync
Database
Redis (optional)

New CLI commands:

tpy queue table
tpy queue work

⏰ Scheduler

Schedule recurring jobs with simple cadence helpers.

Features:

app/schedule.py
Overlap protection
Register-based scheduling

Commands:

tpy schedule run
tpy schedule list

⚡ Cache System

Built-in cache abstraction supporting:

Memory
File
Redis

Command:

tpy cache clear

🌐 Standard API Responses

The new ApiResponse class provides consistent JSON responses across every endpoint.

Available responses include:

success
created
paginated
error
validation_error
not_found

No more manually formatting response payloads.

✅ Validation

A completely redesigned validation system featuring:

Pipe-rule validation
Validator
ValidationException

Simple, expressive, and reusable.

🏗️ Application Kernel

TamilPY now includes a fully featured application kernel.

Capabilities include:

Application create()
mount()
Dependency Injection Container
Service Providers
Plugin support

This lays the foundation for scalable enterprise applications.

🛡 Middleware Groups

Middleware can now be organized using MiddlewareManager, making request pipelines cleaner and easier to maintain.

❤️ Health Checks & Lifecycle Hooks

Production-ready health endpoints:

/health
/health/ready

Lifecycle hooks:

boot
shutdown
before request
after request
exception

📝 Logging

A new logging system supports:

Console logging
File logging
Stack channels

Managed through:

LogManager
get_logger()

⚙️ Configuration Improvements

Configuration now supports:

Nested keys
Environment overlays
Configuration caching
Automatic loading
Freshness checks

Production deployments become significantly faster using:

TPY_CONFIG_CACHE=1

🚀 Route Cache

Cache application routes for faster startup.

Commands:

tpy route cache
tpy route list
tpy route clear

👨‍💻 Better CLI Experience

Developer productivity has improved with several new commands.

tpy about
tpy commands
tpy -V

Rich-powered banners, tables, and improved terminal output make the CLI more enjoyable to use.

⚡ Optimize & Watch Mode

Development is now faster than ever.

tpy optimize

Builds optimized configuration and route caches.

tpy watch

Automatically rebuilds whenever schema.tpy changes.

📖 Documentation Improvements

Documentation has been completely redesigned.

Highlights include:

Professional GitHub Pages site
Feature cards
Dedicated documentation pages
Mobile responsive layout
Improved navigation
Schema relationship grammar guide

Learning TamilPY is now easier than ever.

🔄 Changes

Repositories now expose query()
Existing CRUD methods remain compatible
Automatic configuration loading
New project scaffolding
Legacy response helpers remain supported for backward compatibility

🚀 New CLI Commands

tpy queue table
tpy queue work

tpy schedule run
tpy schedule list

tpy cache clear

tpy config show
tpy config cache
tpy config status
tpy config clear

tpy route cache
tpy route list
tpy route clear

tpy optimize

tpy watch

tpy about
tpy commands
tpy -V

⬆️ Upgrade

Upgrade everything:

pip install --upgrade "tamilPY[all]"

Redis only:

pip install --upgrade "tamilPY[redis]"

After upgrading, regenerate repositories using:

tpy build

tpy crud

For the best production performance:

tpy optimize

Enable configuration caching:

TPY_CONFIG_CACHE=1

🎯 Looking Ahead

TamilPY continues to evolve toward becoming a complete schema-driven FastAPI platform that minimizes boilerplate while maximizing developer productivity.

Version 0.1.9 represents a major milestone, bringing together data access, background processing, scheduling, caching, validation, lifecycle management, and an improved developer experience into one cohesive framework.

We'd love your feedback, feature requests, and contributions from the community.

⭐ If you find TamilPY useful, consider starring the project on GitHub and sharing it with fellow Python developers.

Happy Coding! 🚀

I built a schema-driven Python web framework that generates your entire FastAPI stack — meet tamilPY

Selva Ganapathi Arumugam — Wed, 29 Jul 2026 09:33:06 +0000

If you've ever hand-rolled the same models → migrations → repositories → services → controllers → routes boilerplate for the fifth API in a row, this one's for you.

I just shipped tamilPY (v0.1.9) on PyPI — a schema-first Python web framework built on top of FastAPI. You write one file, schema.tpy, and it generates a production-ready backend (and optionally a full admin dashboard) around it.

bash
pip install tamilPY
The pitch in one sentence

Define your models once in a tiny domain-specific schema language, run tpy build, and get a fully wired FastAPI application — models, migrations, repositories, services, controllers, and routes — without writing any of the plumbing by hand.

Why "tamilPY"?

Small personal touch: the name nods to my mother tongue, Tamil. The framework itself isn't Tamil-specific at all — it's a general-purpose tool for any team, any language, any project.

What's actually in the box
Schema-first generation — schema.tpy drives everything downstream
Multi-database support — SQLite, PostgreSQL, MySQL, and MongoDB
Full CRUD generation from a single build step
Query builder + relationships — fluent queries, relations { } blocks, eager loading
Events, queues, and a scheduler — sync event bus, background jobs, cron-style tasks
Caching, validation, and API envelopes — memory/file/Redis cache, pipe-style validation rules, ApiResponse
A small "kernel" platform — providers/plugins, middleware groups, health checks, lifecycle hooks
Generated admin dashboard — an optional Vite + React UI built straight from your schema
A real CLI — scaffolding, migrations, seeding, queues, scheduling, cache control, and a dev server
A taste of the schema language
tpy
database postgres

model User {
id: uuid primary
email: string unique required
}

model Post {
id: uuid primary
title: string required index
body: string nullable
user_id: uuid references User
status: string default "draft"
published: bool default false
views: int default 0

relations {
belongs_to User as author via user_id
has_many Comment as comments
}
}

Constraints like required, unique, nullable, index, default, and references map straight to real column definitions, indexes, and foreign keys. Define parent models before their dependents and migrations run in the right order automatically.

From zero to running API
bash
tpy new myapp
cd myapp

edit schema.tpy, then:

tpy build # configure your database + generate app layers
tpy migrate # apply migrations
tpy seed # optional sample data
tpy serve # http://127.0.0.1:8000

Want an admin panel too?

bash
tpy admin
cd admin && npm install && npm run dev # http://127.0.0.1:5173

Need auth? tpy auth scaffolds JWT login/register/refresh/logout, roles, and seeds a default super-admin — one command, and your dashboard is already gated by role.

How it stacks up
Criteria Django Flask FastAPI (plain) tamilPY
Boilerplate High Build it yourself Moderate Very low (schema-generated)
Code generation ❌ ❌ ❌ ✅ Full stack
Admin dashboard ✅ Built-in ❌ ❌ ✅ Generated (Vite + React)
Type safety Optional Optional ✅ Pydantic ✅ Pydantic-enforced
Time to MVP Days/weeks Weeks Days Hours to a few days

(Ratings reflect typical experience on standard CRUD/API projects — your mileage will vary with team familiarity and project scope.)

One honest caveat

Generated repositories and DB providers are synchronous, and FastAPI route handlers call them directly. That keeps things simple and portable across all four database backends, but if you're planning for heavy IO under load, run workers behind a process manager rather than assuming the DB layer is async-native — that's on the roadmap, not in v0.1.9.

Try it
bash
pip install tamilPY
python -m tpy.cli version
📦 PyPI: https://pypi.org/project/tamilPY/
📚 Docs: https://selvaganapathiarumugam.github.io/tamilPY/
💻 GitHub: https://github.com/Selvaganapathiarumugam/tamilPY

Requires Python 3.12+. MIT licensed.

I'd genuinely love feedback from this community — especially on the schema language design and where the generated code gets in your way. Issues and PRs welcome. 🙏

Built by Selvaganapathi Arumugam.