DEV Community: Sreethul

Building a Scalable Sidebar Architecture in Django Using Decorators, Registries, and Context Processors

Sreethul — Sun, 10 May 2026 07:06:06 +0000

When building large Django applications, one problem slowly becomes painful:

sidebar management

Especially in modular systems like:

HRMS
CRM
ERP
Admin panels
Multi-app dashboards

At first, updating the sidebar feels simple.

But once your project grows to:

10+ apps
multiple contributors
role-based permissions
dynamic navigation
HTMX interactions

your sidebar.html quickly becomes a maintenance nightmare.

The Problem I Faced

In my Django CRM project, every new app required updating:

sidebar.html
sub_sidebar.html

Example:

<li>
    <a href="/accounts/">Accounts</a>
</li>

<li>
    <a href="/contacts/">Contacts</a>
</li>

This caused several problems:

Every contributor had to modify core sidebar templates
Frequent Git merge conflicts
Sidebar logic became centralized and difficult to maintain
Permission handling became repetitive
Adding new apps required touching unrelated files

The bigger the project became, the worse it felt.

The Idea

Instead of manually editing central sidebar templates, I wanted:

Each app should register its own menu items.

So I created a small registry-based menu system using:

decorators
registries
context processors
app auto-discovery

Now every app owns its own sidebar configuration.

Final Project Structure

Example:

horilla_crm/
├── accounts/
│   ├── menu.py
│   ├── views.py
│   ├── urls.py
│   └── apps.py
│
├── activity/
│   ├── menu.py
│   ├── views.py
│   ├── urls.py
│   └── apps.py
│
├── project/
│   ├── menus/
│   │   ├── main.py
│   │   ├── sub.py
│   │   └── context_processors.py

Step 1 — Creating Menu Registries

Main Sidebar Registry

# project/menus/main.py

main_section_menu = []

def register(cls):
    main_section_menu.append(cls)
    return cls

Sub Sidebar Registry

# project/menus/sub.py

sub_section_menu = []

def register(cls):
    sub_section_menu.append(cls)
    return cls

Step 2 — Registering Menus Inside Apps

Now every app can define its own menus.

Example:

# accounts/menu.py

from django.utils.translation import gettext_lazy as _
from django.urls import reverse_lazy

MAIN_CONTENT_HX_ATTRS = {
    "hx-boost": "true",
    "hx-target": "#mainContent",
    "hx-select": "#mainContent",
    "hx-swap": "outerHTML",
}

Main Section

@main_section_menu.register
class AccountsSection:
    section = "accounts"
    name = _("Accounts")
    icon = "/assets/icons/accounts.svg"
    position = 1

Sub Section

@sub_section_menu.register
class AccountsSubSection:
    section = "accounts"
    app_label = "accounts"

    verbose_name = _("Accounts")
    icon = "/assets/icons/accounts.svg"

    position = 1

    url = reverse_lazy("accounts:list")
    attrs = MAIN_CONTENT_HX_ATTRS

    perm = [
        "accounts.view_accounts",
        "accounts.view_own_accounts",
    ]

Now the app becomes completely self-contained.

Step 3 — Dynamic Menu Loading

I created an AppLauncher system to auto-import modules like:

menu
signals
dashboard
registrations

Example:

class AccountsConfig(AppLauncher):

    auto_import_modules = [
        "registration",
        "signals",
        "menu",
        "dashboard",
    ]

This automatically imports menu.py during startup.

So developers never need to manually import menus.

Step 4 — Building Menu Objects

I created helper functions like:

def get_sub_section_menu(request=None):

which:

validates permissions
groups menus by section
sorts menus using position
validates missing sections
prepares final menu dictionaries

Example validation:

raise ImproperlyConfigured(
    f"Sub section uses section '{section_name}' "
    f"but no matching main section exists."
)

This prevented silent configuration errors.

Step 5 — Using Context Processors

Then I exposed menus globally using a context processor.

def menu_context_processor(request):

    return {
        "main_section_menu": get_main_section_menu(request),
        "sub_section_menu": get_sub_section_menu(request),
    }

Now every template automatically receives menu data.

Step 6 — Rendering Menus in Templates

Main Sidebar

{% for item in main_section_menu %}
    <a href="{{ item.url }}">
        {{ item.name }}
    </a>
{% endfor %}

Sub Sidebar

{% for item in current_items %}
    <a href="{{ item.url }}">
        {{ item.label }}
    </a>
{% endfor %}

Now templates became extremely small and clean.

Why This Architecture Helped

This solved multiple problems immediately.

Contributors No Longer Modify Core Sidebar Templates

They only create:

menu.py

inside their app.

No More Merge Conflicts

Huge improvement for collaborative development.

Permissions Became Centralized

Each menu controls its own permissions.

HTMX Integration Became Easy

Each menu can define custom HTMX attributes:

attrs = MAIN_CONTENT_HX_ATTRS

Apps Became Plug-and-Play

A new app can register itself automatically.

Things I Learned

While building this, I realized:

Sidebar systems are actually plugin systems.

Once apps can contribute:

menus
dashboard widgets
settings pages
navigation items

your architecture becomes much more scalable.

Future Improvements

Some ideas I plan to add later:

menu caching
badge counts
nested menus
feature flags
dynamic visibility
app-level menu ordering
reusable Django package

Final Thoughts

This started as:

"I don't want to edit sidebar.html repeatedly."

But eventually evolved into a modular registry-based navigation architecture.

For large Django projects, this approach made the codebase:

cleaner
contributor-friendly
scalable
easier to maintain

especially in multi-app systems like HRMS and CRM platforms.

Tech Stack

Django
HTMX
Tailwind CSS
Python decorators
Context processors
Dynamic registries

Integrating ETimeOffice Attendance API with Python and Django

Sreethul — Sun, 10 May 2026 06:14:51 +0000

If you’ve worked with biometric attendance systems, you already know the hardest part usually isn’t the device itself — it’s the integration layer.

Different vendors expose different APIs, date formats, authentication methods, and response structures. One of the systems I recently worked with was ETimeOffice, and I wanted a cleaner way to interact with its attendance APIs directly from Python and Django applications.

So I built:

pyetimeoffice

A lightweight Python integration library for working with the ETimeOffice API.

GitHub: https://github.com/KSreethul/pyetimeoffice

PyPI: https://pypi.org/project/pyetimeoffice/

Why I Built It

In HRMS and attendance systems, we often need to:

Download punch records
Process in/out attendance logs
Sync attendance with HRMS platforms
Handle employee punch data programmatically
Normalize inconsistent API response formats

While integrating ETimeOffice into Django-based HRMS systems, I noticed the same boilerplate code being repeated everywhere:

HTTP Basic authentication setup
Date formatting
API request handling
Response parsing
Datetime normalization

So I wrapped those operations into a reusable Python package.

Features

pyetimeoffice currently supports:

DownloadPunchData API
DownloadPunchDataMCID API
DownloadInOutPunchData API
Automatic datetime parsing
Date range validation
HTTP Basic authentication
Easy integration with Django applications

Installation

Install directly from PyPI:

pip install pyetimeoffice

Quick Example

from pyetimeoffice import ETimeOfficeAPI

api = ETimeOfficeAPI(
    username="your_username",
    password="your_password",
    base_url="https://api.etimeoffice.com/api/",
)

data = api.download_punch_data(
    from_date="25/03/2025_00:00",
    to_date="25/03/2025_12:22",
    emp_code="ALL",
)

print(data)

Example Use Cases

This library can be useful for:

Django HRMS integrations
Attendance synchronization
Payroll processing systems
Employee tracking systems
ERP integrations
Attendance analytics dashboards

Built for Django & HRMS Workflows

I mainly work with Django-based HRMS and CRM systems, so the library was designed to fit naturally into backend workflows.

Typical integration flow:

Fetch attendance logs from ETimeOffice
Normalize punch timestamps
Map employee codes
Store records in Django models
Generate attendance reports

Future Plans

Some features planned for future releases:

Async API support
Retry mechanisms
Pagination helpers
Webhook/event support
Better filtering utilities
Additional biometric vendor integrations

Open Source

The project is fully open source and contributions are welcome.

GitHub Repository:
https://github.com/KSreethul/pyetimeoffice

If you’re working on attendance systems, HRMS platforms, or biometric integrations, I’d love feedback and suggestions.

django #hrms #attendance

Integrating Biometric Devices with Django: ZKTeco, Anviz, Dahua & COSEC Made Simple (With Python SDKs)

Sreethul — Fri, 24 Apr 2026 09:54:44 +0000

If you’ve ever tried integrating biometric devices into a real-world system like an HRMS or attendance platform, you already know:

It’s never just “connect → fetch logs → done”.

Instead, you end up dealing with:

Different APIs for each vendor
Authentication nightmares (tokens, digest auth, basic auth)
XML, JSON, and sometimes unreadable raw responses
Pagination and large log handling
Device-specific quirks and undocumented behavior

I ran into all of this while building production systems.

So instead of solving the same problems again and again, I built reusable Python libraries to simplify integrations across multiple biometric platforms.

🧠 The Reality of Biometric Integrations

Every vendor works differently:

Device	Challenge
ZKTeco	SDK limitations, network sync issues
Anviz (CrossChex Cloud)	Token lifecycle + pagination
Dahua	Digest auth + complex HTTP APIs
Matrix COSEC	XML responses + cryptic codes

There’s no standard.
And that’s the real problem.

🔧 My Approach: Build Once, Reuse Everywhere

While working on HRMS systems, I realized:

“Why am I rewriting the same integration logic for every project?”

So I created lightweight Python libraries for each major system I worked with.

☁️ 1. Simplifying Anviz CrossChex Cloud (crosschexcloudapi)

If you've used CrossChex Cloud API, you’ve probably struggled with:

Token generation & expiration
Pagination loops
Complex request structures

✅ Solution: `crosschexcloudapi`

A Python SDK that abstracts all of that.

👉 GitHub: https://github.com/KSreethul/crosschexcloudapi

Quick Example

from crosschexcloudapi import CrossChexCloudAPI

api = CrossChexCloudAPI(
    api_url="https://api.crosschexcloud.com",
    api_key="YOUR_API_KEY",
    api_secret="YOUR_API_SECRET",
    anviz_request_id="REQUEST_ID"
)

records = api.get_attendance_records()
print(records)

What It Handles

Automatic token generation & refresh
Pagination internally
Clean structured response
Retry on token expiry

🔌 2. Dahua Device Integration Made Easy (pydahua)

Dahua APIs are powerful—but painful.

You typically deal with:

HTTP Digest authentication
Raw key-value responses
Manual parsing

✅ Solution: `pydahua`

👉 GitHub: https://github.com/KSreethul/pydahua

Quick Example

from pydahua import DahuaAPI

dahua = DahuaAPI(
    ip="http://192.168.1.100",
    username="admin",
    password="password"
)

print(dahua.get_system_info())
print(dahua.fetch_attendance_logs())

Features

Built-in digest authentication
Clean Python responses
Attendance logs parsing
User & access control management
Device control (reboot, config, etc.)

🏢 3. Matrix COSEC Integration Without XML Pain (pycosec)

COSEC devices are reliable—but developer experience?

Not great.

Problems include:

XML responses everywhere
Manual URL construction
Confusing response codes

✅ Solution: `pycosec`

👉 GitHub: https://github.com/KSreethul/pycosec

Example

from pycosec import COSECBiometric

device = COSECBiometric(
    machine_ip="192.168.1.100",
    port=80,
    username="admin",
    password="admin123"
)

events = device.get_attendance_events(
    roll_over_count=0,
    seq_num=1,
    no_of_events=50
)

print(events)

What It Fixes

XML → Python dict conversion
Response code mapping
Authentication handling
Clean reusable methods

⚙️ Django Integration: The Real Goal

All these libraries were built for one purpose:

👉 Seamless integration into Django-based systems

Typical flow:

Biometric Device → Python SDK → Django Service → Database → HRMS UI

Example Workflow

Fetch logs from device
Normalize data
Store in Django models
Trigger attendance processing

🚀 Real-World Use Cases

These integrations power:

HRMS platforms
Payroll automation
Attendance sync systems
Access control dashboards
SaaS workforce tools

💡 Key Lessons Learned

After working with multiple biometric systems:

1. There is no standard

Every device behaves differently—design abstraction layers.

2. Always normalize data

Unify formats before saving to DB.

3. Handle scale early

Attendance logs grow fast—optimize queries and batching.

4. Expect failures

Devices disconnect. APIs break. Plan retries.

🔥 Why This Matters

Biometric integration is a niche—but high-impact skill.

Most developers avoid it because it's messy.

But if you solve it well, you can build:

Enterprise-grade HR systems
Scalable attendance platforms
Integration-heavy SaaS products

📦 Open Source — Contributions Welcome

All libraries are open source:

CrossChex Cloud → https://github.com/KSreethul/crosschexcloudapi
Dahua → https://github.com/KSreethul/pydahua
COSEC → https://github.com/KSreethul/pycosec

Feel free to:

Report issues
Suggest features
Contribute improvements

🧾 Final Thoughts

Biometric integrations don’t have to be painful.

Instead of fighting APIs every time, you can:

Abstract complexity
Build reusable SDKs
Focus on business logic

That’s exactly what I aimed to do with these libraries.

If this helped you or saved you time, consider ⭐ starring the repos — it really supports open source.

Simplifying Anviz CrossChex Cloud Integration in Python (crosschexcloudapi)

Sreethul — Tue, 21 Apr 2026 10:53:57 +0000

If you’ve worked with the Anviz CrossChex Cloud API, you’ve probably faced this:

Token-based authentication complexity
Token expiration handling
Pagination headaches
Complex request/response formats

It’s powerful—but not exactly developer-friendly.

So I built something to make it simple

Introducing crosschexcloudapi

A lightweight Python SDK that simplifies working with the CrossChex Cloud API.

GitHub: https://github.com/KSreethul/crosschexcloudapi

What This Library Fixes

Instead of:

Manually generating tokens
Tracking expiry time
Writing pagination loops
Handling retry logic

You can just call one method and get everything.

Quick Example

```python id="z1q0py"
from crosschexcloudapi import CrossChexCloudAPI

api = CrossChexCloudAPI(
api_url="https://api.crosschexcloud.com",
api_key="YOUR_API_KEY",
api_secret="YOUR_API_SECRET",
anviz_request_id="REQUEST_ID"
)

Fetch attendance records

records = api.get_attendance_records()

print(records)




No manual token handling. No pagination loops.

---

##  Key Features

*  Automatic token generation & refresh
*  Built-in pagination handling
*  Fetch attendance logs easily
*  Clean and structured responses
*  Smart retry on token expiry
*  Minimal dependency (`requests`)

---

##  Real Example: Fetch Records with Date Range



```python id="y5w8r3"
from datetime import datetime

records = api.get_attendance_records(
    begin_time=datetime(2025, 10, 1, 0, 0, 0),
    end_time=datetime(2025, 10, 18, 23, 59, 59)
)

print(records)

Example Output

```json id="3g1wvn"
{
"token": "abc123",
"expires": "2025-10-20T10:00:00",
"count": 2,
"list": [
{
"employee_id": "E1001",
"check_time": "2025-10-18T09:00:00",
"type": "checkin"
}
]
}




Everything is already combined and structured for you.

---

##  How It Works

* Generates token using API key & secret
* Stores token and expiry internally
* Automatically refreshes expired tokens
* Fetches all paginated records behind the scenes
* Returns a single clean response

---

##  Real-World Use Cases

This library is useful if you’re building:

* HRMS systems
* Payroll automation
* Attendance sync tools
* SaaS platforms integrating biometric data

---

##  Installation



```bash id="3v6q7d"
pip install crosschexcloudapi

Open Source — Contributions Welcome

If you’re working with Anviz devices:

Report issues
Suggest features
Contribute improvements

Let’s make biometric integrations easier for everyone.

Final Thoughts

CrossChex Cloud API is powerful—but working with it directly is time-consuming.

crosschexcloudapi removes the complexity and lets you focus on building.

Simplifying Dahua Biometric Integration with Python (pydahua)

Sreethul — Tue, 21 Apr 2026 10:51:17 +0000

If you've ever worked with Dahua biometric or access control devices, you already know the pain:

Complex HTTP APIs
Digest authentication headaches
Raw, unreadable responses
Manual pagination & parsing

I faced the same challenges while building real-world HRMS and attendance systems.
So I built something to fix it

Introducing pydahua

pydahua is a Python library that makes interacting with Dahua biometric devices simple, clean, and developer-friendly.

GitHub: https://github.com/KSreethul/pydahua

What Problems Does It Solve?

Instead of writing low-level API calls like this:

Constructing URLs manually
Handling HTTP Digest authentication
Parsing raw key-value responses
Managing logs manually

You can now do everything with simple Python methods.

Quick Example

from pydahua import DahuaAPI

dahua = DahuaAPI(
    ip="http://192.168.1.100",
    username="admin",
    password="password"
)

# Get system info
print(dahua.get_system_info())

# Fetch attendance logs
print(dahua.fetch_attendance_logs())

That’s it. No complexity.

Key Features

Built-in HTTP Digest authentication
Clean and structured API responses
User management (add, delete, fetch)
Access card enrollment
Attendance log retrieval (with parsing)
Device configuration support
Device control (reboot, shutdown)

Real-World Use Cases

I built this while working on:

HRMS systems
Attendance automation
Biometric integrations
Access control solutions

If you're building something similar, this will save you hours (or days).

Example: Fetch Attendance Logs

from datetime import datetime

logs = dahua.get_control_card_rec(
    card_no="123456",
    start_time=datetime(2025, 1, 1, 0, 0, 0),
    end_time=datetime(2025, 1, 18, 23, 59, 59)
)

print(logs)

Output (clean & structured)

{
  "records": [
    {
      "card_no": "123456",
      "card_name": "John Doe",
      "attendance_state": "CheckIn",
      "door": "1",
      "create_time": "2025-01-18T09:12:33"
    }
  ],
  "count": 1
}

Why I Built This

Most biometric SDKs are:

Either poorly documented
Or locked behind enterprise systems

I wanted a simple, open-source solution that developers can plug into any system.

Installation

pip install pydahua

Supported Devices

Works with Dahua devices that support:

magicBox.cgi
configManager.cgi
userManager.cgi
recordFinder.cgi

Open Source — Contributions Welcome

If you're working with biometric systems, I'd love your feedback.

Found a bug? Open an issue
Need a feature? Suggest it
Want to contribute? PRs are welcome

Final Thoughts

If you're building:

HR software
Attendance systems
Access control tools

pydahua can save you a lot of time and frustration.

Give it a try and let me know what you think

I Built a Python Library for Matrix COSEC Biometric Devices (So You Don’t Have To)

Sreethul — Tue, 21 Apr 2026 10:31:32 +0000

If you’ve ever worked with COSEC biometric devices, you probably already know…

It’s not as simple as:

“Connect device → Fetch attendance → Done”

In reality, it looks more like:

Confusing APIs
XML responses everywhere
Authentication quirks
Trial-and-error debugging for hours

I ran into all of this while building an HRMS system.

So instead of repeating the same pain in every project, I built a reusable solution:

pycosec

Why I Built This

While working on biometric integration, I expected a clean API experience.

But what I got was:

Raw XML responses
Hard-to-understand response codes
Manual URL construction for every request
Repetitive integration code across projects

At some point, it became clear:

“This shouldn’t be this hard every single time.”

So I created a Python library to simplify everything.

What is pycosec?

pycosec is a lightweight Python package that helps you interact with COSEC biometric devices in a clean and structured way.

It takes care of:

Authentication (Basic Auth)
API communication
XML parsing → Python dictionaries
Response code mapping
Argument validation

So you can focus on your application instead of fighting the device API.

Installation

You can install it directly from PyPI:

https://pypi.org/project/pycosec/

pip install pycosec

Or explore the source code:

https://github.com/KSreethul/pycosec

Real Usage (Based on Actual Implementation)

Here’s a real example based on how the library actually works:

from pycosec import COSECBiometric

# Initialize device connection
device = COSECBiometric(
    machine_ip="192.168.1.100",
    port=80,
    username="admin",
    password="admin123"
)

#  Get basic device configuration
basic_config = device.basic_config()
print("Device Config:", basic_config)


#  Fetch attendance events
events = device.get_attendance_events(
    roll_over_count=0,
    seq_num=1,
    no_of_events=50
)
print("Attendance Events:", events)


#  Create or update a user
response = device.set_cosec_user(
    user_id="EMP001",
    ref_user_id=1,
    name="John Doe",
    user_active=True,
    user_group=1
)
print("User Response:", response)


#  Get user details
user = device.get_cosec_user("EMP001")
print("User Details:", user)


#  Delete user
delete_response = device.delete_cosec_user("EMP001")
print("Delete Response:", delete_response)

Device Configuration Example

You can also configure device settings easily:

# Set device date & time
device.date_and_time_configuration(
    action="set",
    date_dd=21,
    date_mm=4,
    date_yyyy=2026,
    time_hh=15,
    time_mm=30
)

# Configure access settings
device.access_settings_configuration(
    action="set",
    auto_relock=True,
    alarm=True
)

What’s Happening Behind the Scenes?

This is where the library actually saves you a ton of effort:

Automatically builds correct API URLs
Handles authentication headers (Base64 encoded)
Converts XML → Python dictionaries
Filters and parses attendance events
Maps response codes to readable messages
Validates supported arguments before sending requests

Instead of writing all this logic repeatedly, you just call methods.

Real Use Case

I built this while working on an HRMS system where:

Employees check in via biometric devices
Attendance logs need to sync with the backend
The system handles large volumes of data

This library acts as a bridge between COSEC devices and your application.

Before vs After

Before pycosec:

Manual API calls
XML parsing everywhere
Duplicate code in every project
Hard debugging

After pycosec:

Clean Python methods
Faster integration
Reusable code
Easier debugging

Future Improvements

I’m actively working on improving the library. Some ideas:

Async support
More endpoint wrappers
Better error handling
Webhook-based event sync

Contributions Welcome

If you’ve worked with COSEC devices, you know there’s always something new to figure out.

Feel free to:

Open issues
Suggest improvements
Contribute

Let’s make biometric integrations easier for everyone.

Final Thoughts

This library came out of a real problem I faced while building production systems.

It’s not just a wrapper—it’s a way to:

Reduce repetitive work
Simplify integrations
Build faster and cleaner systems

If you’re working with COSEC devices, this might save you hours (or even days).

How to Convert a Django App into a Pip-Installable Package

Sreethul — Wed, 22 Oct 2025 11:43:34 +0000

Sometimes you develop a reusable Django app in your project and want to share it across multiple projects—or even publicly via PyPI. Here’s a step-by-step guide on how to convert your Django app into a pip-installable package.

Step 1: Create a Dedicated Django App

Inside your Django project, create a new app for your reusable functionality:

python manage.py startapp your_app_name

Do all your coding only inside this app.
Outside the app, only update settings.py → INSTALLED_APPS if needed.
Keep the app self-contained so that it can work independently when installed in other projects.

Step 2: Prepare Your App for Packaging

Once your app is ready, create a new folder outside your Django project with the same name as your app:

mkdir your_app_name

Copy your Django app into this folder.
Add the following files to the folder:

LICENSE – your license file
README.md – a brief description of your app
MANIFEST.in – to include non-Python files
setup.py – packaging script
pyproject.toml – build configuration

Example `setup.py`

from setuptools import setup, find_packages

setup(
    name="your_app_name",
    version="0.1.0",
    packages=find_packages(),
    include_package_data=True,
    install_requires=[
        "Django>=4.2",  # specify dependencies
    ],
    license="MIT",
    description="A reusable Django app",
    long_description=open("README.md").read(),
    long_description_content_type="text/markdown",
    url="https://github.com/yourusername/your_app_name",
)

Step 3: Build the Package

Run the following command in your app folder:

python -m build

This will create a dist/ folder containing .whl and .tar.gz files.

Step 4: Install Locally

Go back to your Django project.
Remove the old app from your project.
Install the package from the dist folder:

pip install ../your_app_name/dist/your_app_name-0.1.0-py3-none-any.whl

4.Now your app is installed into your virtual environment and can be used like any other installed package.

Step 5: Publish to PyPI

Go back to your django app standalone folder,Same folder that you run python -m build.
Upload to PyPI using Twine:

python -m twine upload dist/*

It will prompt for your PyPI API token. Generate one from your PyPI account.
After a successful upload, your app is publicly available! Anyone can install it with:

pip install your_app_name

Build and test locally before uploading to PyPI.
After publishing, your app can be reused across projects or shared with the community.

DEV Community: Sreethul

Building a Scalable Sidebar Architecture in Django Using Decorators, Registries, and Context Processors

The Problem I Faced

The Idea

Final Project Structure

Step 1 — Creating Menu Registries

Main Sidebar Registry

Sub Sidebar Registry

Step 2 — Registering Menus Inside Apps

Main Section

Sub Section

Step 3 — Dynamic Menu Loading

Step 4 — Building Menu Objects

Step 5 — Using Context Processors

Step 6 — Rendering Menus in Templates

Main Sidebar

Sub Sidebar

Why This Architecture Helped

Contributors No Longer Modify Core Sidebar Templates

No More Merge Conflicts

Permissions Became Centralized

HTMX Integration Became Easy

Apps Became Plug-and-Play

Things I Learned

Future Improvements

Final Thoughts

Tech Stack

Integrating ETimeOffice Attendance API with Python and Django

pyetimeoffice

Why I Built It

Features

Installation

Quick Example

Example Use Cases

Built for Django & HRMS Workflows

Future Plans

Open Source

django #hrms #attendance

Integrating Biometric Devices with Django: ZKTeco, Anviz, Dahua & COSEC Made Simple (With Python SDKs)

🧠 The Reality of Biometric Integrations

🔧 My Approach: Build Once, Reuse Everywhere

☁️ 1. Simplifying Anviz CrossChex Cloud (crosschexcloudapi)

✅ Solution: crosschexcloudapi

Quick Example

What It Handles

🔌 2. Dahua Device Integration Made Easy (pydahua)

✅ Solution: pydahua

Quick Example

Features

🏢 3. Matrix COSEC Integration Without XML Pain (pycosec)

✅ Solution: pycosec

Example

What It Fixes

⚙️ Django Integration: The Real Goal

Example Workflow

🚀 Real-World Use Cases

💡 Key Lessons Learned

1. There is no standard

2. Always normalize data

3. Handle scale early

4. Expect failures

🔥 Why This Matters

📦 Open Source — Contributions Welcome

🧾 Final Thoughts

Simplifying Anviz CrossChex Cloud Integration in Python (crosschexcloudapi)

Introducing crosschexcloudapi

What This Library Fixes

Quick Example

Fetch attendance records

Example Output

Open Source — Contributions Welcome

Final Thoughts

Links

Simplifying Dahua Biometric Integration with Python (pydahua)

Introducing pydahua

What Problems Does It Solve?

Quick Example

Key Features

Real-World Use Cases

Example: Fetch Attendance Logs

✅ Solution: `crosschexcloudapi`

✅ Solution: `pydahua`

✅ Solution: `pycosec`

Example `setup.py`