DEV Community: Alessandro Pischedda

Mustiolo: A Python library for creating CLI applications.

Alessandro Pischedda — Mon, 26 May 2025 19:44:15 +0000

A couple of weeks ago, I started to wonder if it is possible to write a library in Python to create a CLI application that uses only standard packages as dependencies.

The idea seems fun, so I've started to build it.
The main features in my mind were:

command register via decorator,
autocomplete,
command history,
help menu via docstring,
Use of typing hints and annotations to retrieve:
- mandatory/optional parameter
- parameter type (and check types).

Long road to accomplish something more complete, like sub-commands.

The meaning of the name

The 'mustiolo' is the smallest mammal in the world, weighing about 1.2-2.5 grams as an adult.
It is present in Sardinia, in the Italian, Balkan, Iberian peninsulas, and in North Africa.

This library aims to be the smallest library for building CLI applications in Python just like a mustiolo is the smallest mammal.

Example

from mustiolo.cli import CLI

cli = CLI()

@cli.command()
def greet(name: str):
    """Greet a user by name."""
    print(f"Hello {name}!")

@cli.command()
def add(a: int, b: int):
    """Add two numbers and print the result."""
    print(f"The result is: {a + b}")

if __name__ == "__main__":
    cli.run()

This example allows to have

> ?
greet    Greet a user by name.
add      Add two numbers and print the result.
> ? add
Usage add Add two numbers and print the result.

add A B

Parameters:
        A   Type INTEGER [required]
        B   Type INTEGER [required]
> exit

If you're interested please visit Mustilo repository on GitHub.

Hacktoberfest from a maintainer's point of view

Alessandro Pischedda — Thu, 10 Oct 2024 13:16:53 +0000

This time I've decided to participate in Hacktoberfest as a project maintainer.

The project is (AnadiCSV)[https://github.com/Cereal84/AnadiCSV] a simple tool to query data from a CSV file via SQL query.

AnadiCSV is written in Python and uses DuckDB and Textual, the project was submitted to the hacktoberfest in an embryonic state. The idea was to take advantage of the hacktoberfest for two reasons:

learn to manage a project with 'external' contributors
improve the code letting the people contribute.

Now some lessons that I've learned until now.

Write detailed issues

Even if the issue is crystal clear for you it does not mean that is the same for external contributors, especially if they are not experienced ones.

Try to have a dialogue on the issue

Details can be not enough, it is better to start a dialogue in order to be sure that everyone understands the work to do.

CONTRIBUTING file is important

I've always ignored this file in my repositories instead if you want to help people contribute is quite important, you can write the way you expect they work, the rules to follow, and sometimes which is the logic behind some section (i.e. if you want to add a cli option which are all the files involved if it is not so clear in the code).

Doing a poor code review is not a good idea

Sometimes you are in a hurry but you want to merge some PR as soon as possible; you read the PR quickly and it seems to be alright, skip some files because you forget about them or because you think that the changes will be so simple that surely they are correct.
Obviously, they will break the repository :).

GitHub Actions are good

Adding some checks like code formatter, linter, etc is a good idea to avoid doing those things during the code review and let you focus on important things.

Conclusion

Until now I've learned a lot and I'm happy to have started this project and suggest to anyone to try to do the same.

For anyone who is looking for issues on hacktoberfest please come and visit us :).

Hacktoberfest: AnadiCSV project

Alessandro Pischedda — Tue, 24 Sep 2024 13:51:24 +0000

Hi everyone,
I wrote a tool called AnadiCSV which allows you to use SQL query on CSV files.

This tool is written in Python using Textual as UI library and DuckDB to handle CSV data, at the moment works on Docker container.
I think this project can be a good start to partecipates in Hacktoberfest, it is already a couple of open issues.

[UPDATE]
After few days many issues are taken from different users, I'm happy to see people contributing ton the project :).

Thank you everyone

LinkedIn Support Added to FastAPI-SSO!

Alessandro Pischedda — Wed, 14 Feb 2024 12:00:00 +0000

Hi everybody,
in my previous post I talked about the importance of developing a side project and how this can help you to contribute to an open-source project.

In that case, I added the support to GitLab into fastapi-sso library. In the comments, @fpischedda suggested integrating LinkedIn SSO, guess what? I did it again, I've added the support to LinkedIn SSO into the fastapi-sso library and used it in my project Breves.

In this way I've accomplished 2 things:

another contribution to the open-source world
let the user of Breves login and signup via LinkedIn.

I would ask the DEV.to community to suggest other features I can add.

Thank you :)

P.S. fastapi-sso is growing in importance by integrating more and more SSO providers both thanks to its creator and external contributions from other developers.
The code is well written and the community that is springing up around it is very friendly.
For these reasons, I suggest anyone who wants to approach the world of open-source try to make some contributions

Let's meet Pylint: Python Linter

Alessandro Pischedda — Mon, 12 Feb 2024 11:00:00 +0000

After the post about Black (a formatter for Python) today we'll talk about another tool, Pylint (plus one you can find at the end before the "Conclusion" section).

Pylint is a linter... ok, a step back, what is a linter?

A linter is a static code analyzer used to find programming errors, bugs, stylistic errors, and suspicious constructs. This kind of tool can:

find syntax errors
find unused variables and undeﬁned variables
unused import
enforce consistent coding practice
etc.

You can find the full list of checks here.

So helps to find some problems earlier contributing to higher-quality code.
It is better to specify, that the real improvement in quality code happens only by the developer writes a code more readable, uses the right design patterns, etc.

Usually, the linter builds a report about the code quality according to the guidelines used to configure it.

Due Python is an interpreted language a linter is useful for finding some errors before running the code.

Basic

As usual, the first step is to install it, you can do it in your system or in a virtual environment.

pip install pylint

The easiest way to run it is to run it file by file or in a directory

$ pylint {source_file_or_directory}

The code will be rated:

\-----------------------------------

Your code has been rated at 4.10/10

Options

By default, all the checks are enabled.

--disable=all

Disable all the checks.

--disable=id

Disable a specific check.
You can specify more checks by using commas

     --disable=<id_1>,<id_2>,...,<id_N>

--enable=id

Works exactly like the disable option.

--ignore=

Ignore one or more files.

for a full list of options please use --help option or check the documentation.

Configuration

Pylint supports a configuration file with all the configuration you need. To use it you need to place a file called .pylintrc or pylintrc into your directory.

Well, Pylint searches for this kind of file by looking in the following directory order and uses the first one it found:

working directory
The file named by environment variable PYLINTRC
.pylintrc in your home directory

Plugin

It is possible to extend the behavior of Pylint using or writing plugins.

This topic is out of the scope of this post but you can find all the information and examples in the documentation.

My 2 Cents

Someone uses this rate as a quality gate, this means that if the code does not reach a threshold then is not possible to push the code into a branch, create PR, etc.

In my opinion, if you want to use that as a quality gate do not use it as a threshold for a full score, or better do not use it as a quality gate :D. Remember that a full score does not mean that the code has high quality.

It can be a useful tool if used together with pre-commit because it can prevent you from sending code with some errors/problems by easing the code review. And it can be very useful to the newly hired especially if they are junior position.

Pylint likes the f-string instead of the use of "".format()
so I suggest to use flynt before pylint. This tool replaces "%-formatted" and .format(...) strings into f-strings.

Conclusion

Like every tool it can be helpful if used correctly or slow down the work if used wrongly.

In any case, I recommend anyone to use this type of tool at least once; but don't do it on projects with a large codebase because it could be frustrating, in that case run it on one or a few files at a time.

Let's meet Black: Python Code Formatting

Alessandro Pischedda — Wed, 07 Feb 2024 11:00:00 +0000

While each developer may have different preferences for coding style, the importance of a unified style is very important for maintaining readable code.
This has a bigger importance if you think of a project in which many developers are involved.

In Python exists the 'Style Guide for Python Code' known as PEP 8, which recommends specific code conventions to maintain a standardized code format.
This style guide is about:

indentation
imports
max line length
name conventions
comments
etc

In the realm of Python development, there is a multitude of code formatters that adhere to PEP 8 guidelines. Today, we will briefly discuss how to install and utilize black.

Basics

Let's stop talking and get our hands dirty because it's a great way to learn.

First of all, let's install it using pip:

$ pip install black

Once installed, to use it, just execute the following command:

$ black {source_file_or_directory}

This command will initiate black with the standard configuration and reformat all the Python files it finds.

Options

As you can see running Black is quite simple but what if we want not to change the file/s but perform only a check ?
We can use the options furnished by Black.

--check

Do not change the file but return only the exit value:

0, nothing to change
1, some files would be reformatted
123, an internal error occurred.

Example

black --check main.py 
would reformat main.py

Oh no! 💥 💔 💥
1 file would be reformatted.

--diff

Even this command does not reformat the files but prints the diff which indicates the changes.
[Note]: use --color if you want colored diff.

I suggest reading the documentation for a complete list of options.
In my opinion some of the most useful are:

--required-version
--exclude.

Example

black --diff --color main.py 
--- main.py 2023-09-08 21:03:49.860827+00:00
+++ main.py 2024-02-04 22:31:31.130282+00:00
@@ -5,29 +5,31 @@
 from starlette.middleware.base import BaseHTTPMiddleware

 from app.frontend import pages
-from app.core import config 
+from app.core import config

-app.include_router(pages.router, prefix='')
+app.include_router(pages.router, prefix="")
-
-
-
-
-
would reformat main.py

All done! ✨ 🍰 ✨
1 file would be reformatted.

Configuration

If you want to customize the configuration of Black you can remember the list of the options or configure it using a configuration file.

Black uses by default the pyproject.toml file.
This file contains a section for each different tool we want to use. The use of a configuration file like pyproject.toml is quite a good choice and helps the contributors to use the same tools and configurations you're using.

Black uses [tool.black] section, the option names/keys are the same as the long names of options used in the command line. Below you can see an example:

[tool.black]
line-length = 80
target-version = ['py37']

Conclusion

We've explored, briefly, the formatted called Black talking about the aim of this tool, how to use and how to configure it using a configuration file.
I hope this post can help you to improve your repository and code.

Build a personal project is a good thing

Alessandro Pischedda — Mon, 14 Aug 2023 14:12:08 +0000

Hi everyone,
I'm Alessandro, the developer behind Breves a service for developers.You can find more details in this post.

A while back, I pondered the idea of modernizing the existing signup/login process by implementing Single Sign-On (SSO) capabilities. This shift aimed to streamline the login procedure and enhance user experience.

The service is crafted using Python and FastAPI, this led me to SSO-supporting libraries. Given the developer-centric nature of the service, I set my sights on integrating GitHub SSO at the very least.

After some searching, I stumbled upon fastapi-sso This library proved to be elegantly straightforward, with well-crafted examples. Encouraged by its capabilities, I decided to retire the previous signup/login mechanism in favor of GitHub SSO. The transition was seamless, and everything appeared to be sailing smoothly.

Everything seems fine except.... Why didn't login via GitLab too?

Regrettably, fastapi-sso lacked GitLab support, and I was hesitant to switch libraries. But every challenge brings an opportunity. This marked the perfect juncture to contribute to an open-source project :).

The process of contributing turned out to be surprisingly straightforward, as showcased in the PR.
During the process I've learn something very usefull by following the guide lines in "CONTRIBUTING.md" file which I used in my job too.

Embarking on personal projects has numerous advantages. Not only do they enable skill growth across various domains – from mastering new frameworks to becoming adept with different libraries – but they also open doors to contributing to previously unknown open-source ventures.

My recommendation? Build something you're passionate about. Moreover, allow yourself the freedom to dive into contributing to diverse projects.

Please let me know if you want other SSO providers in my service (or in fastapi-sso library), such as BitBucket or others.

Best regards,
Alessandro

map() - how processing iterable without a loop

Alessandro Pischedda — Mon, 16 Jan 2023 13:03:47 +0000

It is common to have to work with list or iterable by manipulating the values of their elements. Usually, this is done by using a for loop or a list comprehension but
Python allows the user to do that using a mapping technique via the built-in function map().

The syntax is

map(function, iterable)

This function can be useful in a variety of situations, including

transforming data
performing calculation
combining multiple iterables.

Following we'll see some, very, simple examples.

Transforming data

You can use it to uppercase a string or convert a list of integer in string format into int type.

Example 1

def upper_char(char: str):
    return char.upper()

lower_str = 'hello world'
print("".join(map(upper_char, lower_str)))
# 'HELLO WORLD'

Example 2

input_str = ['1', '2', '3', '4']
input_int = list(map(int, input_str))
print(input_int)
# [1, 2, 3, 4]

The last one can be usefull when you have to parse a numeric input read from a file or stdin (standard input). I.e. if you have tried to solve AoC (Adventure of Code) exercises you have to parse a file and convert data from string to int.

Performing calculation

Calculate the square value for each element of a list of int.

def square(x):
    return x*x

data = [1, 2, 3, 4]
print(list(map(square, data)))
# [1, 4, 9, 16]

Combining multiple iterables

map() can be used to apply a function to corresponding elements of multiple iterables.
In fact the real syntax is

map(function, iterable, *iterables)

As you can see it can accept more than one iterable and in that case, it pass a single item for each iterator to the function in parallel.
For example, you can use map() to add corresponding elements of two lists together, or perform other types of operations on multiple iterables.


def add_elements(x, y):
    return x + y

list_1 = [1, 3, 5, 7]
list_2 = [2, 4, 6, 8]

print(list(map(add_elements, list_1, list_2)))
# [3, 7, 11, 15]

If more iterables are passed to map() it stops when the shortest iterable is exhausted.

Conclusion

In summary, the map() function is a useful tool for manipulating data. By allowing you to apply a function to each element of an iterable, it enables you to make transformations, perform calculations, and combine multiple iterables in a concise and efficient manner. This versatility makes it a valuable tool.

Breves.it - a service that can help you to avoid uninteresting job position

Alessandro Pischedda — Fri, 13 May 2022 13:52:56 +0000

Hi,
after getting tired of numerous cognitive interviews for job positions that did not match my profile, I decided to build a service that helps me select potentially interesting job positions and those to avoid without having to do cognitive interviews.
The service is very simple but very useful. It allows the user to write a questionnaire to share with a recruiter / headhunter, and based on the answers, decide whether or not to continue with the cognitive interview.

The service is available here and it is completely free.

feedbacks are appreciated :)

SHOWDEV: data-bubbles

Alessandro Pischedda — Mon, 26 Apr 2021 09:29:42 +0000

Hello everyone,
I want to show you data-bubble.it, a service which I've built in my spare time in the last 3 weeks.
The service allows a user to share text and images with others; the data is reachable by URL or API REST and it is available for 10 minutes or until a user retrieves it.

At now only the free plan is available, I'm still working on the user registration to furnish the payment version too.

I want to ask you what you think about the service and some feedback to improve it.

Thank you.

How to reduce compile time using Docker as dev environment on C++

Alessandro Pischedda — Sun, 21 Jun 2020 09:08:52 +0000

Abstract

In this post I'll show how to avoid to wasting your time rebuilding a fresh new image every time you make a small change in your code. The reference language is C ++ but the proposed solution can be used for every compiled languages and project which require time consuming building process.

Problem

Best practices suggest to use multi-stage Dockerfile copying all the source code in the builder stage, compile it and then copy the binary file on next stage. This approach makes sense in production instead while you're in dev mode and you're forced to use the container to compile and makes test has a great problem. Every time you make a small change in the source code this means a fresh new Docker image; even if the rebuild uses previous layer and just recompile whole the project this can be a problem if it is time consuming requiring several minutes to recompile.

If you're in dev mode waiting for several minutes every time you make a simple change can be annoying.

Idea

It will be great to recompile only the files with the changes just like when you're developing and compiling on your system. In order to do this the source code is stored inside the host's file system and mounted as volume by the container. This guarantee that all the object files are not looses and b reused on next compile processes.

Hence the idea is to have a container with the following features:

have all the necessary to compile
recompile only the changes on source code
generate the binary file on host's file system
there is no need to rebuild the image to generate the binary file.

This container will be a "binary generator" and it's purpose its to generate a new binary file without recompile whole the project. Then use new binary file to create the runtime docker image.

Solution

In order to better explain my solution I have created a simple "Hello world" project that you can find here. The tree of the project is the following:

    .
    ├── core.cpp
    ├── core.hpp
    ├── dev_env
    │   ├── builder
    │   │   ├── docker-compose.yml
    │   │   └── Dockerfile
    │   └── runtime
    │       ├── docker-compose.yml
    │       └── Dockerfile
    ├── docker-compose.yml
    ├── Dockerfile
    ├── main.cpp
    ├── Makefile
    └── README.md

The Dockerfile and docker-compose.yml at the root level show a single stage build process that will show the original problem: changing one file will rebuild the the whole process, which is what we are trying to avoid.

In the dev_env directory we can find the proposed solution:

the builder directory contains the Dockerfile and docker-compose to generate the builder container (the one used to generate the binary file).
the runtime directory contains all the necessary to build test or runtime image. Instead the runtime contains all the necessary to build test or runtime image.

Builder directory

docker-compose.yml

version: '2.3'

services:
   
    binary_builder:
        container_name: "binary_builder"
        image: binary_builder
        build:
            dockerfile: ./dev_env/builder/Dockerfile
            context: ../../
            args:
                src_path: /src
        volumes:
            - ../.././:/src:rw

As you can see on the src directory, on container, is mounted the root of the project, source code included.

Dockerfile

    FROM ubuntu:18.04
    ARG src_path=/src
            
    RUN apt-get update                          && \ 
        apt-get install -y                         \
        g++ build-essential
     
     RUN mkdir -p $src_path
     WORKDIR $src_path
     CMD     make

The Dockerfile is quite simple it takes the source code from $src_path and the compile it (if necessary) every time it will be started. Another advantage is that it is not necessary to rebuild the builder container to generate a new binary.

Runtime directory

The Dockerfile is very simple, use the same base image used in builder level and copy the binary file from the host file system.

Dockerfile

    FROM ubuntu:18.04 as run_time
    COPY  hello_world /hello_world
    WORKDIR /
    CMD ./hello_world

The advantage is that to rebuild the runtime container you have to generate a new binary file and copy it on the new image saving time.

Conclusion

I hope this article has helped you.

Repositories for Hacktoberfest2019

Alessandro Pischedda — Fri, 11 Oct 2019 09:59:12 +0000

Hi,
in order to help people to find, quickly, some issues for the hacktoberfest I thought to create a post where all of you can post your projects.
The format should be something like:

LEVEL
Link to the repo - [languages, mini description, tags]

In example today I've add some issues on my old respository

Beginner

github_text_search - [javascript, chrome extension].

I hope this initiative can help some of you.