DEV Community: Kanak Tanwar

reducing memory cost of boolean in python

Kanak Tanwar — Fri, 13 Feb 2026 11:00:03 +0000

while scrolling through twitter i came across a tweet about how python boolean variable takes up 192 bits. this was new to me, i had never really thought about how much space python variables actually take(if this was a concern i should not have been using python at all).

so i researched it a bit and though it wasn't entirely correct, it wasn't entirely wrong either (explanation below). this prompted me into looking more into how bools are represented in python and how (possibly using underhanded means) can we reduce the space taken by booleans.

booleans in python

booleans are simple. just 2 values - TRUE or FALSE. theoretically they can be represented by just 1 bit (0 or 1).

so why does python use 192 bits (on 32 bit systems) and 224 bits (on 64 bit systems)?

the True and False values in cpython are not primitives, but a python object (a subclass of int actually, which is also a python object and not a primitive).
the catch however is that the bool class is a singleton class (there exists only a single object which is shared by all the references)
this means that the 28 byte size is actually just paid once. apart from this constant cost however, we use an extra 8 bytes used by pointer references to the bool objects.

how small can booleans get

now that we have established that storing a boolean inside a container in CPython costs ~8 bytes per value due to pointer references, let us see how low we can go.

the theoritical limit will obviously be 1 bit (0 or 1), so let's try to reach that benchmark

results

i have measured most of the sizes by taking average over a list of values as that is what gives the actual image of how large the data is after removing the constant overhead

Representation	Storage cost per boolean (approx)
Python `bool` (in list/container)	8 bytes
`bytearray`	1 byte
`int` bitset	~0.13 bytes (~1.05 bits)

bool datatype (baseline)

True (or False) singleton object is of size 28 bytes.

a pointer to bool objects take 8 bytes of space. so the average value of using bool in python is ~8 bytes.

bytearray

bytearray in python allows us to storing raw bytes. so the smallest unit in a bytearray takes up only 1 byte.

bitset (kind of)

python does not have bitset like c++, but we can use int as a replacement. python int range is not fixed, so we can have a large number of bits.

True and False can be represented by 1 and 0 in an integer like 0b110100101.

the amortized cost of per bit when using int comes out to be ~0.13 bytes = ~1.05 bit (pretty close to the theoretical minimum)

conclusion

python isn’t designed for memory-dense primitives, but with a little bit of abuse you can get surprisingly close to the theoretical 1-bit limit.

should you do this in real code? probably not. if something like this is a concern you shoudln't be using python at all :).
but if you still do, here's how you can take advantage of it.

REST Pagination techniques

Kanak Tanwar — Sun, 05 Oct 2025 07:13:40 +0000

My thoughts had always been that pagination was straightforward — just throw in a LIMIT and OFFSET and you’re good to go. But recently, I got to know that there are different pagination techniques, some more efficient, some used for a specific use case. And so I thought of writing about them, along with code a rudimentary code implementation in FastAPI and some benchmarks of their performance.

The code can be found https://github.com/kanakOS01/pagination.
The instructions for running the code are in the repo itself. If you find it helpful a star would be great.

Among the different types of pagination I found online (offset, page, cursor, keyset etc), we can broadly classify pagination into 2 categories

Offset Pagination

Offset pagination is the most common form. It’s the classic LIMIT/OFFSET approach:

SELECT * FROM data
ORDER BY id
OFFSET 1000 LIMIT 10;

Pros:
- Simple to implement.
- Great for small datasets.
- Supports “jump to page X.”
Cons:
- Slow for large offsets (e.g., OFFSET 1M).
- Can cause inconsistent results if data changes between requests.

Page Pagination

Page pagination is just a wrapper around offset. Instead of offset=1000, you say page=100 with page_size=10, and the system translates it into an offset internally.

SELECT * FROM data
ORDER BY id
OFFSET (page - 1) * page_size LIMIT page_size;

Pros:
- Familiar and user-friendly.
- Easier UX for users who want to jump to a specific page.
Cons:
- Same performance problems as offset.
- Still prone to data inconsistency with inserts/deletes.

Cursor Pagination

Cursor pagination uses a known column value as an anchor (like id or created_at) instead of a raw offset.

SELECT * FROM pagination_dataset
WHERE id > cursor_id
ORDER BY id
LIMIT 10;

Pros:
- Super efficient — no scanning and discarding rows.
- Scales well for large datasets.
- Great for sequential or immutable data (logs, feeds).
Cons:
- No direct “jump to page 100.”
- Exposes database internals (like IDs) if not wrapped.

This is the approach used by modern APIs like GitHub, Twitter, and Facebook.

Keyset Pagination

I could not find much difference between keyset and cursor pagination. The idea for both of them is the same (like offset and page). One difference would be that cursor pagination returns a cursor like object (encoded by the application code), this prevents leaking information through endpoints. This however also introduces minor overhead.

Benchmarking

So, I thought it would be fun to benchmark these approaches myself to verify the results I had in my mind (there are a number of benchmarks and comparisons available on the net already but I thought why not just do it again :)).

So I made a simple script (available in the github repo mentioned at the top) to benchmark offset and cursor pagination. And here are the results.

Final Thoughts

Use offset/page pagination for small datasets or cases where “jump to page X” is important.
Use keyset or cursor pagination for large datasets, APIs, and infinite scroll use cases.
If you’re building a public API, cursor pagination is the way to go.

Pagination might look trivial at first, but at scale, the right choice can save you massive performance headaches.

Benchmarking python JSON libraries

Kanak Tanwar — Thu, 24 Jul 2025 15:08:39 +0000

While reading the FastAPI documentation I came across various python libraries for working with json. This got me thinking which one is the best, performance wise (including the python's built-in json module).

I surfed the net, found some resources and comparisions, and thought of implementing them on my own. So, this article is about the perf benchmarks I got when testing these libraries and the methodology.

Test Setup

Ubuntu 24.04 LTS
RAM - 24 GB
Python version - 3.12

Libraries tested

json - Built-in Python JSON library; widely used but relatively slow.
ujson - Fast C-based JSON parser; a drop-in replacement for json.
orjson - Extremely fast Rust-based library with rich type support.
rapidjson - Python wrapper for RapidJSON (C++); good performance and flexibility.
msgspec - Ultra-fast library with optional typed structs for maximum speed.

Results

Library	Serialization Time (s)	Deserialization Time (s)
json	1.616786	1.616203
ujson	1.413367	1.853332
orjson	0.417962	1.272813
rapidjson	2.044958	1.717067
msgspec	0.489964	0.930834

Takeways

The top contendors are orjson and msgspec (duh).

I personally like to use orjson when working with fastAPI as it has builtin support for orjson response format making it a more developer friendly option.

msgspec on the other hand is like a swiss army knife as it has support for other structs as well like yaml, toml etc. And it has a ton of more validation features like validating with a python class (sort of like pydantic).

Methodology

Generating sample data

A simple script to generate the testing data (can be made complex for better benchmarking).

def generate_sample_data(n):
    return [
        {
            "id": i,
            "name": f"User{i}",
            "active": bool(i % 2),
            "scores": [random.random() for _ in range(10)],
            "info": {"age": random.randint(20, 40), "city": "City" + str(i)}
        }
        for i in range(n)
    ]

data = generate_sample_data(10_000)

Benchmarking function

Store the encoding and decoding methods of every library in a dictionary with the lib names as the key and run this function.

def benchmark_json_libs(data, runs=10):
    results = []

    # Pre-serialize data for each lib
    pre_serialized = {}
    for name, funcs in libs.items():
        try:
            pre_serialized[name] = funcs["dumps"](data)
        except Exception as e:
            print(f"Serialization failed for {name}: {e}")
            continue

    for name, funcs in libs.items():
        if name not in pre_serialized:
            continue

        try:
            ser_time = timeit.timeit(lambda: funcs["dumps"](data), number=runs)
            deser_time = timeit.timeit(lambda: funcs["loads"](pre_serialized[name]), number=runs)
            results.append({
                "Library": name,
                "Serialization Time (s)": ser_time,
                "Deserialization Time (s)": deser_time
            })
        except Exception as e:
            print(f"Benchmarking failed for {name}: {e}")

    return pd.DataFrame(results)

Visualization

Visualize the result using seaborn and matplotlib.

fig, axes = plt.subplots(1, 2, figsize=(14, 5))

sns.barplot(x="Library", y="Serialization Time (s)", data=results_df, ax=axes[0])
axes[0].set_title("JSON Serialization Time")

sns.barplot(x="Library", y="Deserialization Time (s)", data=results_df, ax=axes[1])
axes[1].set_title("JSON Deserialization Time")

plt.tight_layout()
plt.show()

And that's it. Thanks for reading. Bye.

Automation | A Developer's Personal Assisstant with Runner H

Kanak Tanwar — Sun, 06 Jul 2025 07:02:56 +0000

This is a submission for the Runner H "AI Agent Prompting" Challenge
This is a submission for the Runner H "AI Agent Prompting" Challenge

What I Built

As part of the Runner H AI Agent Prompting Challenge, I built a virtual personal assistant workflow tailored for developers like myself. This AI-powered assistant handles a curated set of daily non-technical tasks — from scanning Hacker News and Product Hunt for updates, to checking my Google Calendar and even sending me a motivational nudge.

This assistant helps developers stay informed, organized, and inspired — without lifting a finger.

Think of this as a template of what the assisstant can do and can be easily finetuned according to everyone's need.

Demo

The run of the task can be found here

And some snapshots of the output are here -

How I Used Runner H

I created a custom prompt that instructs Runner H to complete four tasks each day, mimicking the flow of a helpful executive assistant. This required external tool calling and connections, specifically google calendar, gmail and google docs Here's how it breaks down:

Task 1: News Digest
Runner H visits Hacker News and scrapes the latest articles and threads related to:

AI
Startups
Open Source Software

It then generates summaries for each relevant post, adds the original URLs, and neatly organizes everything into a Google Doc titled News Digest [Date]. This keeps me updated without doomscrolling through the HN front page.

Task 2: Product Hunt Highlights
Runner H checks Product Hunt for top products from yesterday.
It then:

Summarizes the general trends and categories of the products launched.
Highlights standout tools or startups showing technical innovation.
Compiles the results in a doc titled Product Hunt [Date].

This is my shortcut to understanding what's new in the product ecosystem — ideal for inspiration and trend tracking.

Task 3: Calendar Check
Runner H connects to my Google Calendar and:

Lists all scheduled meetings or events for the day.
Alerts me about any special occasions (birthdays, holidays, etc.).

This daily briefing helps me stay prepared and avoid surprises during the workday.

Task 4: Motivation Check
To keep morale high, Runner H sends me a motivational quote during the second half of the day. This small but meaningful gesture provides a mental reset and helps me push through the afternoon dip.

Real-World Impact:

Time Saved: I avoid 30–60 minutes of daily manual browsing across HN, Product Hunt, and email/calendar platforms.
Better Focus: No more tab overload. Everything is delivered in one place.
Motivation Boost: A mid-day quote might sound small, but it helps me reset when energy dips.

The Prompt

Here’s the full prompt I used to power this personal assistant via Runner H:

You are to complete the following tasks as my personal assistant.

## Task 1 - News Digest
Go to https://news.ycombinator.com/ and find articles, threads and blogs on AI, Startup and Open Source Software. Generate a summary for all the relevant items that you find and put them in a google docs along with the original url to the post. Organize the summaries into a google doc named `News Digest [Today's date]`.

## Task 2 - Product Hunt
Go to product hunt and find the top products of yesterday. Give a summary of the overall intent of the products, their domains and some products that stood out of the rest in terms of technical innovation. Report this in a google doc named `Product Hunt [Today's date]`.

## Task 3 - Calendar Check
Check my google calendar for any meetings or events that I have planned for today. Also give a reminder if there is any occasion planned for today.

## Task 4 - Motivation Check
Send me a motivational quote in the latter half of the day to keep me going with my work.

Socials

Shared on Twitter/X and LinkedIn links below:

// Detect dark theme var iframe = document.getElementById('tweet-1941756502064136626-193'); if (document.body.className.includes('dark-theme')) { iframe.src = "https://platform.twitter.com/embed/Tweet.html?id=1941756502064136626&theme=dark" }

Automation | A Developer's Personal Assisstant with Runner H | Kanak Tanwar

https://lnkd.in/gjvi7b8b

linkedin.com

That's all from me today. Thanks.

Using MindsDB to create a smart email CLI client

Kanak Tanwar — Mon, 30 Jun 2025 17:53:15 +0000

Building an AI-powered Semantic Email Search in Your Terminal

So, a new quest came out on quira in which we had to make something using MindsDB Knowledge Bases. As I read through the description it struck to me that a semantic powered email client would be a great thing to work on. It would hit off all the required points while also having some actual irl usecase.

And so i made grepmail: a terminal-based CLI app that lets you semantically search your inbox using natural language queries. It uses MindsDB, PGVector, Gemini, and ollama to turn your mailbox into an AI-searchable database.

It’s like grep for your email—but smart.

Here is the grepMail github repo incase you want to go through the code. The code is decently large so i won't be able to explain everything in the article itself.

What grepmail Can Do

Search your email inbox semantically using plain English
Sync with IMAP mailboxes (Gmail, Outlook, etc.)
Store vectorized email content in Postgres via PGVector
Use LLMs (Gemini, Ollama) for embedding and querying
Display results in a clean, rich terminal UI

⚙️ Tech Stack Overview

Part	Tech
CLI	Typer, Rich
LLM	Ollama, `nomic-embed-text`, Gemini
Email Access	IMAP via MindsDB Email Engine
Vector DB	PGVector
Orchestration	MindsDB Knowledge Base
Packaging	Poetry

File structure

├── grepmail
│   ├── __init__.py
│   ├── logger.py
│   ├── main.py
│   ├── mindsdb
│   ├── handlers
│   │   ├── common.py
│   │   ├── email.py
│   │   └── __init__.py
│   └── main.py
├── grepmail.log
├── handlers.txt
├── LICENSE
├── poetry.lock
├── pyproject.toml
└── README.md

The main parts to keep notice of are -

grepmail/main.py - the cli

grepmail/handlers/common.py - functions for some common tasks

grepmail/handlers/email.py - functions for email related tasks

Major Components

As i said i wont be going through the entire code but rather the main parts of the system. Connecting these together is a pretty trivial task.

1. Email Access with MindsDB Email Engine

You can access you email account with the MindsDB Email Integration

2. Vectorizing Emails with Ollama

I used nomic-embed-text for generating vector embeddings locally. With Ollama, it was as easy as:

ollama pull nomic-embed-text

And then, when loading emails for the first time, grepmail chunks and vectorizes each one, storing them in the PGVector store.

3. Setting Up PGVector for Storage

Emails are heavy, so I wanted a fast and efficient vector store. MindsDB has an integration with PGVector, and I used that to store and search through embeddings efficiently.

4. MindsDB Knowledge Base for Semantic Search

Here’s where the magic happens:

Store email content as vector chunks
Index them via CREATE INDEX
Query using natural language like this:

SELECT * FROM email_kb
WHERE content = 'flight confirmation from last week'
LIMIT 5;

That’s literally it.

5. Local Caching for Speed

The first time you run grepmail, it loads all your emails into:

MindsDB’s knowledge base
A local Postgres DB (so future queries are instant)

This took some engineering because:

IMAP servers are slow
Ollama runs one model instance at a time

So I had to skip concurrency for now (sorry 🫠), but the system is built to handle these steps incrementally and linearly.

6. CLI Experience with Typer + Rich

I wanted this tool to feel smooth in the terminal. Typer gave me auto-generated help menus and clean argument parsing. Rich handled beautiful tables, syntax highlighting, and progress bars.

7. Syncing Emails

https://docs.mindsdb.com/generative-ai-tables#generative-ai-tables.
Another important task to be done is syncing emails to the local db and knowledge base. MindsDB has a builtin in Jobs module which helped in fetching the email from the server every hour without any deep technical work.

8. Summarizing Emails

Another nice quirk i added was to create an AI table / model which would summarize my email content into a few lines ;))

That's it from my side. The architecture is pretty simple and going through the MindsDB docs you will be able to replicated this kind of application yourself.

Managing Python Deps with Poetry

Kanak Tanwar — Thu, 27 Feb 2025 07:46:19 +0000

Introduction

Managing dependencies in Python projects can often become cumbersome, especially as projects grow in complexity. Poetry is a modern dependency management and packaging tool that simplifies this process, offering a streamlined way to create, manage, and distribute Python projects.

Use Cases

Poetry offers several advantages over traditional dependency managers like pip and venv:

1) Simplified Dependency Management: Unlike requirements.txt, Poetry uses a pyproject.toml file to handle dependencies more effectively.

2) Automatic Virtual Environments: Poetry automatically creates and manages virtual environments for your projects.

3) Semantic Versioning: It ensures that dependencies adhere to semantic versioning, reducing compatibility issues.

4) Publishing Made Easy: With a single command, you can publish your package to PyPI.

Although there are a lot of use cases, in this article we will focus on how to setup a project with poetry and manage its dependencies.

Installation

The easiest way to do this is to use pipx as it installs packages in an isolated environment.

If you don't have poetry install you can insatll it from here.

pipx install poetry

There are other methods of installation listed here.

Project Setup

There are a few ways to setup your project with poetry.

In the official poetry documentation it is recommended to use poetry new <project-name>. This creates a folder with the name of the project and creates some boilerplate which include a README.md, src, tests and pyproject.toml.

I, however, prefer using poetry init to initialize poetry in a project. This allows me to manually configure the directory structure.

You can find the code used in this article at my github repository

1) Create project directory:

mkdir poetry-test && cd poetry-test

2) Initialize Poetry:

This will run an interactive module in which you can enter values according to your needs.
After running it will only create a pyproject.toml.

poetry init

3) Setup Directory Structure:

For this article we will make a simple fastapi endpoint so I will follow the general dir structure of a fastapi application along with a README.md.

4) Installing dependencies:

We only have one dependency as of now - "fastapi[standard]".

poetry add "fastapi[standard]"

You can mention a particular version as well. Running this will update the pyproject.toml and create a poetry.lock file.

5) Fastapi endpoint code:

Add this code in the app/main.py file.

from fastapi import FastAPI

app = FastAPI()

@app.get("/")
async def root():
    return {"message": "Hello World"}

Now to run this server run

poetry run fastapi dev app/main.py

and then go to http://localhost:8000/.

And that's it. The server is up.

Poetry commands

Now let's take a look at the poetry commands we used (and some more) to understand what exactly they do.

1) poetry init - Initialize a poetry project interactively.

2) poetry add - Add a dependency to the environment.

3) poetry add --dev - Add a dev dependency to the environment.

4) poetry install - If you have a pyproject.toml file you can run this to install the dependencies.

Similar to pip install -r requirements.txt

5) poetry run - This allows us to run a command in the poetry environment without actually entering the environment.

6) poetry shell - This allows you to enter the poetry environment.

Similar to sourcing the virtual environment.

In newer poetry versions the shell command does not come built-in but needs to be installed as a plugin.
This can be done with the following command -

pipx inject poetry poetry-plugin-shell

7) poetry show - Lists the installed dependencies.

Similar to pip freeze or pip list

8) poetry show --tree - Lists the installed dependencies in tree form(recommended).

And, that's it from my side. Check out the docs of poetry at https://python-poetry.org/docs/ for other info.
Byee.

Setup Zsh on Ubuntu (How and Why)

Kanak Tanwar — Tue, 18 Feb 2025 15:03:51 +0000

I have been using Zsh for a really long time. Why? I don't know just because. And, it is pretty cool. You can get a ton of customizations make your terminal look better and feel help yourself feel like a better developer (you r not).

Well, anyways I sort of fked up my graphic drivers and has to reinstall Ubuntu and set up everything (including Zsh) so I thought I'd write article while I am at it.

Psh, this setup is for Ubuntu only, incase u didn't read the title ;)

What is Zsh?

Zsh(short for Z shell) is a shell...

Ok so on a serious note, Zsh is a program that lets you interact with your computer using commands instead of clicking around with a mouse. So... it is a shell.
That's it.

The great thing about Zsh however is that it has a ton of options for customizations unlike Bash which is the default shell in Ubuntu.

Why is Zsh better than Bash?

Rich customization
Better plugins
Stronger autosuggestions and tab completions
Cooler

(isn't this so much better that out of the box bash?)

Setting up Zsh

1) Make sure your system is up to date before starting.

sudo apt update && sudo apt upgrade -y

2) Install Zsh

sudo apt install zsh -y

3) Change default shell to Zsh

chsh -s /usr/bin/zsh

You may need to restart the terminal for this to take place.

4) Install Oh My Zsh

sh -c "$(curl -fsSL https://raw.githubusercontent.com/ohmyzsh/ohmyzsh/master/tools/install.sh)"

Oh My Zsh allows you to easily manage your Zsh configuration.

5) Install powerline fonts

sudo apt-get install fonts-powerline

Helps improve prompt visuals

6) Install powerlevel10k

git clone --depth=1 https://github.com/romkatv/powerlevel10k.git ${ZSH_CUSTOM:-$HOME/.oh-my-zsh/custom}/themes/powerlevel10k

Powerlevel10k is a custom theme for Zsh. Like dark/light themes, but more powerful

7) Install dconf-cli

sudo apt-get install dconf-cli

8) Install Zsh Plugins

git clone https://github.com/zsh-users/zsh-autosuggestions.git $ZSH_CUSTOM/plugins/zsh-autosuggestions
git clone https://github.com/zsh-users/zsh-syntax-highlighting.git $ZSH_CUSTOM/plugins/zsh-syntax-highlighting

Zsh has a lot of plugins. These 2 will give syntax highlighting and autosuggestion based on history.

9) Update ~/.zshrc

Now we need to update the ~/.zshrc file so that all the changes we have made can take effect.

nano ~/.zshrc

Find a line which says ZSH_THEME="<theme_name>" and replace it with ZSH_THEME="powerlevel10k/powerlevel10k"

Find a line which says plugins=(git) and replace it with plugins=(git zsh-autosuggestions zsh-syntax-highlighting)

Now exit the editor and apply the changes you made using

source ~/.zshrc

10) Customize using powerlevel10k

You can now use the powerlevel10k (p10k) theme to customize your terminal. It will ask you some questions which you just have to answer and you will be done.

It is possible that the configuration will run automatically after you source the .zshrc file. If it does not then you can run it with the following command. This can be repeated anytime in the future.

p10k configure

And you are done.

If at any point some effects do not seem to take place close and reopen the terminal.

Thanks. Bye.

Create a CLI application with Python

Kanak Tanwar — Sun, 09 Feb 2025 09:42:44 +0000

A CLI(command line interface) application is a software tool that allows users to interact with an application directly through your terminal/command prompt.

They are not just useful but also low-key cool ;)

CLI Intro

A CLI application consists of various components -

Commands - The program that runs in the terminal window (like git)
Subcommands - An optional identifier that comes after the command to do a certain task (like commit in git commit)
Arguments - An optional/required piece of data used by a command/subcommand for processing (like "initial commit" in git commit -m "initial commit")
Option/flag - An option argument that modifies the commands behaviour (like -m in git commit -m)

Creating a CLI with `argparse`

Creating CLI applications may seem like a big deal but it is actually pretty simple. The difficult part in the project is usually the core logic and not the cli portion.

Python has a built in module argparse which allows us to interact with the cli with minimal code.

Let's see how we can build a simple CLI calculator in python using argparse. It will have the capability to perform the 4 basic arithmetic operations and will be called from the CLI as such - calcli add 5 10.

The code used in this post is available at this github repo

Directory Structure

.
├── calcli
│   ├── calculator.py
│   ├── __init__.py
│   └── __main__.py
├── README.md
├── requirements.txt
└── setup.py

calcli is the name of the package/cli tool.
the calculator.py file has the logic for +,-,*,% operations.
the __init__.py is used to define that calcli is to be treated as a package. this file will be empty.
__main__.py holds the logic to interact with the CLI. the main motive behind this post.
setup.py is used to package the application

calculator.py

class Calculator:
    def __init__(self):
        self.result = 0

    def add(self, a, b):
        self.result = a + b
        return self.result

    def sub(self, a, b):
        self.result = a - b
        return self.result

    def mul(self, a, b):
        self.result = a * b
        return self.result

    def div(self, a, b):
        if b == 0:
            raise ValueError("Division by 0 NOT supported")
        self.result = a / b
        return self.result

main.py

1) parser object - First we will create an object that will help us parse through the arguments given in CLI. This is done with using argparse.ArgumentParser(description="...").

import argparse
from calcli.calculator import Calculator


def main():
    calculator = Calculator()

    parser = argparse.ArgumentParser(description="A CLI Calculator Tool", epilog="Example calcli add 5 10")


if __name__ == "__main__":
    main()

2) adding arguments - With argparse we can add arguments for commands and subcommands using the add_argument() method.
The first 2 parameters of this method are the long-hand and short-hand names of the argument/option, followed by optional parameters like type, default, help.

def main():
    calculator = Calculator()

    parser = argparse.ArgumentParser(description="A CLI Calculator Tool", epilog="Example calcli add 5 10")
    parser.add_argument("--precision", "-p", type=int, default=2, help="Number of decimal places")

3) subparser - Subparsers are used to add subcommands (add, sub, div, mul in our case).
The title is a placeholder for the subparser and the dest is the place where the arguments passed from the cli will be stored.

def main():
    calculator = Calculator()

    parser = argparse.ArgumentParser(description="A CLI Calculator Tool", epilog="Example calcli add 5 10")
    parser.add_argument("--precision", "-p", type=int, default=2, help="Number of decimal places")

    subparsers = parser.add_subparsers(title="Operators", dest="operator")

4) adding subcommands - We can now add the subcommands (add, sub, mul, div) using the subparser we created. This is done with the help of add_parser() method followed by using the add_argument() method to add arguments for the subcommands.

def main():
    calculator = Calculator()

    parser = argparse.ArgumentParser(description="A CLI Calculator Tool", epilog="Example calcli add 5 10")
    parser.add_argument("--precision", "-p", type=int, default=2, help="Number of decimal places")

    subparsers = parser.add_subparsers(title="Operators", dest="operator")

    add_parser = subparsers.add_parser("add", help="Add 2 numbers")
    add_parser.add_argument("a", type=float, help="First number")
    add_parser.add_argument("b", type=float, help="Second number")

    sub_parser = subparsers.add_parser("sub", help="Subtract 2 numbers")
    sub_parser.add_argument("a", type=float, help="First number")
    sub_parser.add_argument("b", type=float, help="Second number")

    mul_parser = subparsers.add_parser("mul", help="Multiply 2 numbers")
    mul_parser.add_argument("a", type=float, help="First number")
    mul_parser.add_argument("b", type=float, help="Second number")

    div_parser = subparsers.add_parser("div", help="Divide 2 numbers")
    div_parser.add_argument("a", type=float, help="First number")
    div_parser.add_argument("b", type=float, help="Second number")

5) access cli arguments - You can get the arguments passed in a command using the parse_args() method.
We can access the attributes of the args, which are the dest=... parameter mentioned above, and perform actions with the arguments.

args = parser.parse_args()

if args.operator == "add":
    result = round(calculator.add(args.a, args.b), args.precision)
    print(f"Result: {result}")
elif args.operator == "sub":
    result = round(calculator.sub(args.a, args.b), args.precision)
    print(f"Result: {result}")
elif args.operator == "mul":
    result = round(calculator.mul(args.a, args.b), args.precision)
    print(f"Result: {result}")
elif args.operator == "div":
    try:
        result = round(calculator.div(args.a, args.b), args.precision)
        print(f"Result: {result}")
    except ValueError as e:
        print(f"Error: {e}")
else:
    parser.print_help()

You can now run the package with python -m calcli <op> <a> <b>. This is because python treats calcli as a package.

However we want to access this functionality directly as a utility. This is done by creating a setup.py file which allows us to make the package installable.

setup.py

setup.py has a standard structure. You start by importing setuptools.setup and use it to manage some metadate about the module we have just created.

from setuptools import setup

setup(
    name="calcli",
    version="6.9",
    packages=["calcli"],
    entry_points={
        "console_scripts": ["calcli = calcli.__main__:main"],
    },
    description="A CLI calculator using argparse",
    author="Your Name",
    url="Project URL",
    python_requires=">=3.6",
)

Let's take a look at the parameters in setup() -

name - name of the package
version - current version
entry_points - stores the commands that will be accessible through the CLI. here when we type calcli the calcli.__main__:main script will be executed

After you create a setup.py you are ready to build the package.
Now, there are 2 options -

pip install . - This builds the CLI tool. (Useful for testing)
pip install -e . - This builds the CLI tool in editable mode i.e. any changes you make will be reflected almost instantaneously. (Useful for development)

Run the command that you would like and you are done.
You CLI tool is ready.

Run calcli add 6 9 or calcli --help or calcli div 6 9 -p 5 and so on.

That's all from my side. If you have any questions or suggestions do comment them.

Using Daytona to maintain a Development Environment

Kanak Tanwar — Thu, 09 Jan 2025 05:48:35 +0000

As a developer and someone exploring Open Source, setting up new projects and configuring their development environments have been such a headache and a time eater.

I found Daytona in the Quira Quest 23. Our task was to use Daytona to configure and automate our development environment.

Sounds difficult? Not so much. Just 3 steps and I was all done.

1. Setup your project in you system

In my case this was already done. I had a RAG application that allows you to have a q/a session with any github repository of your choice.
It uses Daytona for managing environment, weaviate cloud vector database to store the embeddings, LangChain with OpenAI for llm models and facilitate queries with context and streamlit for UI.

2. Create a `.devcontainer/devcontainer.json` file in the root dir of the project.

3. Generate a `devcontainer.json`

Go to DevContainer.ai, create your own devcontainer.json using AI and paste its content in the file you created.

{
  "name": "Git Chat Development Environment",
  "image": "mcr.microsoft.com/devcontainers/base:ubuntu", 
  "features": {
    "python": "3.10"
  },
  "forwardPorts": [
    8501
  ],
  "customizations": {
    "vscode": {
      "settings": {
        "python.defaultInterpreterPath": "${workspaceFolder}/gitchat-venv/bin/python",
        "python.linting.enabled": true,
        "python.linting.pylintEnabled": true,
        "python.formatting.autopep8Path": "${workspaceFolder}/gitchat-venv/bin/autopep8",
        "python.formatting.blackPath": "${workspaceFolder}/gitchat-venv/bin/black",
        "python.linting.flake8Path": "${workspaceFolder}/gitchat-venv/bin/flake8",
        "python.linting.mypyPath": "${workspaceFolder}/gitchat-venv/bin/mypy",
        "python.linting.pydocstylePath": "${workspaceFolder}/gitchat-venv/bin/pydocstyle",
        "python.linting.pycodestylePath": "${workspaceFolder}/gitchat-venv/bin/pycodestyle"
      },
      "extensions": [
        "ms-python.python",
        "ms-python.vscode-pylance",
        "njpwerner.autodocstring"
      ]
    }
  },
  "postCreateCommand": "python -m venv gitchat-venv && . gitchat-venv/bin/activate && pip install -r requirements.txt"
}

And you are done. That's it.
But what are the benefits of this you ask?
Here you go.

How Daytona comes into play

Daytona abstracts a lot of steps and allows you to setup development containers without much effort. It simplifies the process of managing environments by providing a clean, modular workspace. Instead of manually cloning repositories, setting up environments, and troubleshooting dependencies, Daytona handles it with a few commands.

Getting started with Daytona

Documentation · Daytona

Start managing your Workspaces with Daytona.

daytona.io

The daytona documentation is very easy to go through. Here I will be going through some basic steps to setup and use Daytona. You can browse the docs for detailed info.

1. Installing Daytona

For Linux, run this in your shell:

(curl -sf -L https://download.daytona.io/daytona/install.sh | sudo bash) && daytona server -y && daytona

Checkout the installation guide for other OS.

2. Configurations

git providers

daytona git-providers add

This helps you work with git and manage your repositories. There are a number of options like github, gitlab, bitbucket etc.

providers

daytona provider install

This allows you to connect to a provider like GCP, AWS etc.

set target

daytona target set

target is the location where you want to set up your development environment.
Select docker if you want to set it up locally on you system.
Select the configurations as they popup. I used all the default configs with docker server.

select ide

daytona ide

Daytona allows you to work with you preferred IDE out of the box without you configuring various things. You can also include IDE specific settings in you .devcontainer/devcontainer.json file to customize the dev env further.

3. Create Workspace

A workspace is a dedicated development environment for the project you are working on.

This can be done simply with the following command:

daytona create https://github.com/kanakOS01/gitchat-daytona

This is my project url which has a .devcontainer/devcontainer.json file. You can replace this with any repo which has a devcontainer.json file in it.

You can find a list of sample repos which you can try out here.

My Takeaways from Using Daytona

Time Saved: By automating repetitive setup tasks, Daytona allowed me to focus on building Git Chat’s core functionality.
Consistency Across Environments: Whether I worked locally or collaborated with others, Daytona ensured the environment was identical every time.
Ease of Use: The intuitive CLI commands and clear documentation made Daytona accessible even for someone trying it for the first time.