DEV Community: Jean Pier Elias

Building a Web App with CouchDB Capella and Kafka for Community Problem Reporting with Change Data Capture

Jean Pier Elias — Sat, 14 Dec 2024 03:43:22 +0000

Introduction

In today's world, real-time data processing and visualization play a critical role in decision-making for many applications. This article showcases the development of an air quality monitoring platform that integrates Apache Kafka and Couchbase Capella for real-time data capture and management, leveraging Streamlit to deploy a visually engaging interface.

Development

1. Setting up Couchbase Capella

Couchbase Capella is a high-performance NoSQL database ideal for real-time data storage. Follow these steps to configure it:

Sign up at Couchbase Capella.
Create a cluster:

Select a deployment region.
Configure a bucket named TopicosAppU3.
1. Generate the required credentials:
User: your_user
Password: your_password
Cluster endpoint: your_endpoint

2. Configuring Apache Kafka on Confluent Cloud

Apache Kafka is a distributed messaging system that enables real-time data transmission. To set it up:

Sign up at Confluent Cloud.
Create a basic cluster.
Set up a topic named calidad-del-aire.
Generate API credentials:

API Key: your_api_key
API Secret: your_api_secret
Bootstrap server: your_bootstrap_server

3. Project Development

The project uses Python along with the libraries streamlit, couchbase, and confluent-kafka to integrate Couchbase and Kafka.

Dependency Configuration

Ensure you install the necessary dependencies with:

pip install streamlit couchbase confluent-kafka pandas

Code Implementation

The code is structured as follows:

Connecting to Couchbase:

from couchbase.cluster import Cluster
from couchbase.options import ClusterOptions
from couchbase.auth import PasswordAuthenticator

cluster = Cluster(
    "couchbases://your_endpoint",
    ClusterOptions(PasswordAuthenticator("your_user", "your_password"))
)
bucket = cluster.bucket("TopicosAppU3")
collection = bucket.default_collection()

Configuring Kafka:

from confluent_kafka import Producer, Consumer

producer = Producer({
    'bootstrap.servers': "your_bootstrap_server",
    'sasl.mechanisms': 'PLAIN',
    'security.protocol': 'SASL_SSL',
    'sasl.username': "your_api_key",
    'sasl.password': "your_api_secret",
})

consumer = Consumer({
    'bootstrap.servers': "your_bootstrap_server",
    'sasl.mechanisms': 'PLAIN',
    'security.protocol': 'SASL_SSL',
    'sasl.username': "your_api_key",
    'sasl.password': "your_api_secret",
    'group.id': 'streamlit-consumer',
    'auto.offset.reset': 'earliest',
})
consumer.subscribe(["calidad-del-aire"])

Streamlit Interface:

import streamlit as st
import random

def generate_data():
    return {
        "City": random.choice(["Lima", "Arequipa", "Cusco"]),
        "PM2.5": round(random.uniform(5, 150), 2),
        "PM10": round(random.uniform(10, 300), 2),
        "Humidity (%)": random.randint(30, 90),
        "Temperature (°C)": round(random.uniform(15, 35), 1),
    }

st.title("Air Quality Monitoring Platform")

if st.button("Generate and Save Data"):
    data = generate_data()
    collection.upsert("last_change", data)
    st.json(data)
    producer.produce("calidad-del-aire", value=str(data))
    producer.flush()
    st.success("Data sent to Kafka.")

if st.button("Consume Kafka Data"):
    message = consumer.poll(1.0)
    if message:
        st.json(eval(message.value().decode('utf-8')))
    else:
        st.warning("No messages available.")

4. Deploying with Streamlit Community Cloud

Publish your code in a GitHub repository.
Connect it to Streamlit Community Cloud at Streamlit Cloud.
Configure the required environment variables in the Streamlit settings page:

   COUCHBASE_USER=your_user
   COUCHBASE_PASSWORD=your_password
   KAFKA_BOOTSTRAP_SERVERS=your_bootstrap_server

Github Repository. Repositorio del codigo en Github

Conclusion

This project demonstrates how to integrate Apache Kafka and Couchbase Capella to capture and visualize real-time data. With Kafka managing data transmission and Couchbase providing persistent storage, the application is scalable, efficient, and easy to implement using Streamlit. This combination is ideal for modern applications requiring real-time data processing and visualization.

Building a Web App with CouchDB Capella for Community Problem Reporting

Jean Pier Elias — Thu, 12 Dec 2024 05:29:21 +0000

Introduction

In an increasingly connected world, community problems such as potholes, broken streetlights, and garbage accumulation can be managed more efficiently with technology. This project presents a web application for reporting community issues, designed with a modern interface using Streamlit as the web framework and Couchbase Capella as the cloud database.

The application allows users to report problems in their communities by providing details such as name, district, address, description, and an image of the issue. Once submitted, the report is stored in Couchbase Capella and displayed in real-time with visually appealing effects.

Development

Initial Setup

The project was developed using Streamlit, a lightweight framework that facilitates the creation of interactive web applications with Python. The database used is Couchbase Capella, a cloud-based solution for fast and scalable data storage and retrieval.

Project Structure

The main code for the project is in the app.py file, which includes:

Configuration for Couchbase Capella.
Modern user interface with interactive elements.
Form for submitting reports.
Display of existing reports with animations.

Dependency Installation

Before starting, a virtual environment was created to isolate the project dependencies:

python -m venv env
source env/bin/activate  # On Windows: env\Scripts\activate
pip install streamlit requests couchbase pillow

A requirements.txt file was generated with the following content:

streamlit
requests
couchbase
pillow

Configuring Couchbase Capella

Cluster Creation:
- Access Couchbase Capella.
- Create a cluster and a bucket named As_You_Wish.
IP Configuration:
- In the security panel, add your machine's IP address or allow all connections for testing.
Retrieve Credentials:
- Copy the cluster URL, username, and password.

The code to connect to Couchbase is as follows:

from couchbase.cluster import Cluster
from couchbase.options import ClusterOptions
from couchbase.auth import PasswordAuthenticator

COUCHDB_URL = "couchbases://cb.cj1kcvgq695ufzto.cloud.couchbase.com"
COUCHDB_USERNAME = "your_username"
COUCHDB_PASSWORD = "your_password"
COUCHDB_BUCKET = "TopicosAppU2"

auth = PasswordAuthenticator(COUCHDB_USERNAME, COUCHDB_PASSWORD)
cluster = Cluster(COUCHDB_URL, ClusterOptions(auth))
bucket = cluster.bucket(COUCHDB_BUCKET)
collection = bucket.default_collection()

Application Development

User Interface

CSS was used to achieve a visually appealing design with vibrant colors and animations:

st.markdown(
    """
    <style>
    body {
        background-color: #0f0f0f;
        color: #ffffff;
        font-family: 'Courier New', Courier, monospace;
    }
    h1, h2, h3 {
        color: #e600ff;
        text-shadow: 0px 0px 8px #ff00ff, 0px 0px 12px #ff1aff;
    }
    .stButton button {
        background: linear-gradient(45deg, #ff1aff, #1affff);
        color: #ffffff;
        font-size: 18px;
        border-radius: 10px;
        transition: 0.5s;
    }
    .report-card {
        background: linear-gradient(135deg, #1a1a1a, #3a3a3a);
        border: 1px solid #ff00ff;
        box-shadow: 0px 0px 10px #1affff;
    }
    </style>
    """
    , unsafe_allow_html=True
)

Report Form

The form includes fields to capture name, district, address, description, and an image:

with st.form("report_form"):
    name = st.text_input("👤 Name")
    district = st.selectbox("📍 District", ["Tacna", "Alto de la Alianza", "Palca", ...])
    address = st.text_input("📍 Exact Address")
    title = st.text_input("📌 Problem Title")
    description = st.text_area("📝 Description")
    image = st.file_uploader("📷 Image", type=["jpg", "jpeg", "png"])
    submitted = st.form_submit_button("🚀 Submit Report")

Deployment

The application was deployed on Streamlit Community Cloud:

Upload the project to GitHub:
- Create a repository and push your project files (including app.py and requirements.txt).
Deploy on Streamlit Cloud:
- Access Streamlit Cloud.
- Connect the repository and select the app.py file.
- Configure environment variables:
  - COUCHDB_URL
  - COUCHDB_USERNAME
  - COUCHDB_PASSWORD
Final Result:
- The application is available at: Community Problem Reporting App.
Evidence

Page´s Title

Report Submission Form

Latest Reports

Conclusions

The Community Problem Reporting App demostrates how technology can enhance the management of community issues by empowering citizens with easy-to-use tools. The integration of Couchbase Capella ensures efficient and scalable data storage, while deployment on Streamlit Community Cloud provides global accessibility.

Github Repository

repositorio

Building a Kanban Task Management App with Flask and CouchDB Capella

Jean Pier Elias — Sat, 26 Oct 2024 04:58:36 +0000

Introduction

In this guide, We’ll show you how we built a Kanban-style task management app using Flask and CouchDB. This simple app allows users to add, edit, move, and delete tasks across different columns: Tasks-To Do, In Progress, and Done. Using Flask as the backend and CouchDB as a cloud-hosted NoSQL database makes it easy to create a flexible and scalable application for task management.

Overview

The project includes a frontend interface for managing tasks and a backend to store and retrieve data from CouchDB. The app structure allows us to move tasks between columns, with each column representing a stage in the task’s lifecycle.

Getting Started

Step 1: Set Up the Project Structure
To begin, We created a folder for the project with the following structure:

app.py: The main Flask application file.
templates/: Contains HTML files, including index.html for the Kanban board.
static/: Stores CSS and JavaScript files for styling and functionality.

Step 2: Installing Dependencies
After setting up a virtual environment, We installed Flask and CouchDB SDK using pip:

pip install flask couchbase

This provides the necessary tools for handling routes in Flask and connecting to CouchDB as our NoSQL database.

Configuring CouchDB in the Cloud

We used CouchDB’s cloud service (Capella) to host the database and set up a cluster. CouchDB stores each task as a JSON document, allowing for flexible data storage.

Here’s the code to connect Flask to CouchDB using the Couchbase SDK:

from couchbase.cluster import Cluster, ClusterOptions
from couchbase.auth import PasswordAuthenticator
from datetime import timedelta

endpoint = "your_couchdb_endpoint"
username = "your_username"
password = "your_password"

auth = PasswordAuthenticator(username, password)
cluster = Cluster(endpoint, ClusterOptions(auth))
bucket = cluster.bucket("tasks")
collection = bucket.default_collection()

Backend with Flask

We created several endpoints in Flask for handling task management:

GET /tasks - Retrieves all tasks.
POST /tasks - Adds a new task.
PUT /tasks/ - Updates a task’s title or status.
DELETE /tasks/ - Deletes a task.
Here’s the Flask code to handle these routes:

@app.route('/tasks', methods=['GET'])
def get_tasks():
    tasks = collection.get_all()
    return jsonify(tasks)

@app.route('/tasks', methods=['POST'])
def add_task():
    data = request.json
    # Add task to CouchDB and return the new task ID

@app.route('/tasks/<task_id>', methods=['PUT'])
def update_task(task_id):
    data = request.json
    # Update task in CouchDB

@app.route('/tasks/<task_id>', methods=['DELETE'])
def delete_task(task_id):
    # Delete task from CouchDB

Building the Kanban Board Frontend

The front end of the application is a simple HTML and JavaScript interface. It features three columns representing the stages of a task’s lifecycle. Tasks can be moved between columns by clicking directional buttons.

Color Coding
Tasks are color-coded based on their status:

Tasks-To Do: White
Done: Orange These colors visually indicate the task’s stage, enhancing usability. To run the project we need this command:

async function loadTasks() {
  const response = await fetch('/tasks');
  const tasks = await response.json();
  tasks.forEach(task => addTaskToColumn(task));
}

async function moveTask(id, direction) {
  const currentStatus = document.getElementById(id).parentNode.id;
  let newStatus = currentStatus;

  if (direction === 'right') {
    newStatus = currentStatus === 'tasksTodo' ? 'inProgress' : 'done';
  } else if (direction === 'left') {
    newStatus = currentStatus === 'done' ? 'inProgress' : 'tasksTodo';
  }

  await fetch(`/tasks/${id}`, {
    method: 'PUT',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({ status: newStatus })
  });

  document.getElementById(id).classList = `kanban-item ${newStatus}`;
}

Running the Flask App

To start the Flask app, We ran the following command in the terminal:

flask run

Final Thoughts

Using Flask and CouchDB allowed me to create a flexible and scalable task management application with minimal setup. Flask handles routing and server logic, while CouchDB provides a simple way to persist JSON-based task data in the cloud. This combination of tools is ideal for rapidly building and deploying lightweight web applications.

Next Steps: This project could be expanded with user authentication, real-time updates, and deployment to a cloud hosting platform.

Reference link to code in a github repository:

Codigo-Repositorio-Github

Creating a Generative AI Chatbot using GPT-2 and Flask

Jean Pier Elias — Tue, 09 Jul 2024 11:36:00 +0000

Generative chatbots are revolutionizing human-computer interaction by allowing machines to not only respond to predefined commands but also generate contextually relevant and coherent responses. This technological advancement has found applications in a variety of sectors, from online customer service to virtual assistance on educational and business platforms. The ability of chatbots to understand natural language and generate near-human responses is transforming the way we interact with technology, offering scalable and efficient solutions for automated communication

Chatbot implementation in Flask

Initial configuration:

In this snippet, the necessary libraries are imported and the GPT-2 model and tokenizer are loaded.


from flask import Flask, request, jsonify
from transformers import GPT2LMHeadModel, GPT2Tokenizer

print("Starting application...")

app = Flask(__name__)

# Cargar el modelo y el tokenizer
print("Loading model and tokenizer...")
tokenizer = GPT2Tokenizer.from_pretrained("distilgpt2")
model = GPT2LMHeadModel.from_pretrained("distilgpt2")

print("Model and tokenizer loaded.")

Flask and other libraries are imported to configure the web server.
GPT2LMHeadModel and GPT2Tokenizer are imported from transformers to load the GPT-2 model and its tokenizer.
A Flask instance (app) is initialized to create the web application.

Function to generate responses:

This snippet defines the generate_response function that uses the GPT-2 model to generate responses based on a given prompt.

def generate_response(prompt):
    print(f"Generating response for prompt: {prompt}")
    inputs = tokenizer.encode(prompt, return_tensors="pt")
    outputs = model.generate(
        inputs, 
        max_length=50,  
        num_beams=5,    
        early_stopping=True,
        no_repeat_ngram_size=2,  
        temperature=0.7,  
        top_k=50,         
        top_p=0.95        
    )
    response = tokenizer.decode(outputs[0], skip_special_tokens=True)
    print(f"Generated response: {response}")
    return response

generate_response takes a prompt as input and encodes it using the tokenizer.
model.generate generates a response based on the prompt using parameters such as max_length to limit the length, num_beams to improve quality, temperature to control creativity, among others.
The result is decoded using the tokenizer to obtain the final response. Flask API for the chatbot:

In this snippet, we configure a POST /chatbot route that accepts JSON requests with a prompt, generates a response using the generate_response function, and returns the generated response as JSON.

@app.route('/chatbot', methods=['POST'])
def chatbot():
    try:
        print("Received request.")
        body = request.get_json()
        prompt = body.get('prompt', '')
        response = generate_response(prompt)
        return jsonify({'response': response})
    except Exception as e:
        print(f"Error: {str(e)}")
        return jsonify({'message': 'Internal server error', 'error': str(e)}), 500

if __name__ == '__main__':
    print("Starting Flask server...")
    app.run(debug=True)

@app.route('/chatbot', methods=['POST']) defines a /chatbot route that accepts POST methods to receive JSON requests.
chatbot() is the function that handles POST requests, gets the JSON request body prompt, generates a response using generate_response, and returns the generated response as JSON.
In case of errors, they are captured and handled by returning an error message with status code 500.

Testing with CURL

First question:

curl -X POST http://127.0.0.1:5000/chatbot -H "Content-Type: application/json" -d "{\"prompt\": \"Can you tell me about the weather today?\"}"

Second question:

curl -X POST http://127.0.0.1:5000/chatbot -H "Content-Type: application/json" -d "{\"prompt\": \"hello?\"}""

Third question:

curl -X POST http://127.0.0.1:5000/chatbot -H "Content-Type: application/json" -d "{\"prompt\": \"how are you?\"}"

Next Steps:

We should always try to deploy this type of projects in the cloud, whether AWS or Azure, in this case I leave an illustrative diagram of what the deployment would look like using AWS lambda, AWS Api Gateway and AWS S3.

Conclusion:

The combination of GPT-2 and Flask allows the development of chatbots for educational purposes, capable of dealing naturally and effectively with users. These technological advances are rapidly transforming how we think about human-computer interaction, offering scalable and efficient solutions for a variety of applications, from customer service to AI-assisted education, as long as we use the most advanced models such as GPT-4 or GPT. -4o. As we continue to explore and refine these tools, it's clear that generative chatbots represent a significant step toward smarter, more adaptive systems in the digital future.

Creating a Generative AI Chatbot using GPT-2 and Flask

Jean Pier Elias — Tue, 09 Jul 2024 11:36:00 +0000

Chatbot implementation in Flask

Initial configuration:

In this snippet, the necessary libraries are imported and the GPT-2 model and tokenizer are loaded.


from flask import Flask, request, jsonify
from transformers import GPT2LMHeadModel, GPT2Tokenizer

print("Starting application...")

app = Flask(__name__)

# Cargar el modelo y el tokenizer
print("Loading model and tokenizer...")
tokenizer = GPT2Tokenizer.from_pretrained("distilgpt2")
model = GPT2LMHeadModel.from_pretrained("distilgpt2")

print("Model and tokenizer loaded.")

Flask and other libraries are imported to configure the web server.
GPT2LMHeadModel and GPT2Tokenizer are imported from transformers to load the GPT-2 model and its tokenizer.
A Flask instance (app) is initialized to create the web application.

Function to generate responses: This snippet defines the generate_response function that uses the GPT-2 model to generate responses based on a given prompt.

def generate_response(prompt):
    print(f"Generating response for prompt: {prompt}")
    inputs = tokenizer.encode(prompt, return_tensors="pt")
    outputs = model.generate(
        inputs, 
        max_length=50,  
        num_beams=5,    
        early_stopping=True,
        no_repeat_ngram_size=2,  
        temperature=0.7,  
        top_k=50,         
        top_p=0.95        
    )
    response = tokenizer.decode(outputs[0], skip_special_tokens=True)
    print(f"Generated response: {response}")
    return response

generate_response takes a prompt as input and encodes it using the tokenizer.
model.generate generates a response based on the prompt using parameters such as max_length to limit the length, num_beams to improve quality, temperature to control creativity, among others.
The result is decoded using the tokenizer to obtain the final response.
1. Flask API for the chatbot: In this snippet, we configure a POST /chatbot route that accepts JSON requests with a prompt, generates a response using the generate_response function, and returns the generated response as JSON.

@app.route('/chatbot', methods=['POST'])
def chatbot():
    try:
        print("Received request.")
        body = request.get_json()
        prompt = body.get('prompt', '')
        response = generate_response(prompt)
        return jsonify({'response': response})
    except Exception as e:
        print(f"Error: {str(e)}")
        return jsonify({'message': 'Internal server error', 'error': str(e)}), 500

if __name__ == '__main__':
    print("Starting Flask server...")
    app.run(debug=True)

@app.route('/chatbot', methods=['POST']) defines a /chatbot route that accepts POST methods to receive JSON requests.
chatbot() is the function that handles POST requests, gets the JSON request body prompt, generates a response using generate_response, and returns the generated response as JSON.
In case of errors, they are captured and handled by returning an error message with status code 500.

Testing with CURL

First question:

curl -X POST http://127.0.0.1:5000/chatbot -H "Content-Type: application/json" -d "{\"prompt\": \"Can you tell me about the weather today?\"}"

Second question:

curl -X POST http://127.0.0.1:5000/chatbot -H "Content-Type: application/json" -d "{\"prompt\": \"hello?\"}""

Third question:

curl -X POST http://127.0.0.1:5000/chatbot -H "Content-Type: application/json" -d "{\"prompt\": \"how are you?\"}"

Next Steps:

Conclusion:

Building a web app on auto parts sales analysis using Streamlit with deployment on StreamShare

Jean Pier Elias — Sat, 20 Apr 2024 03:41:01 +0000

Streamlit

It is an open source Python library for creating interactive web
applications quickly and easily.
Ideal for developing dashboards for data visualization,
applications for machine learning models, tools for exploratory
data analysis, and rapid prototyping of web applications.
It allows us to create interactive user interfaces using simple
Python code, without the need to write HTML, CSS or JavaScript.
Widely used in data science, data analysis, machine learning, and web application development.

Streamshare

It is a cloud service that complements Streamlit, allowing to
deploy and share web applications created with Streamlit.
It facilitates the process of putting applications developed
with Streamlit into production, without the need to configure
servers or web infrastructure.
It allows us to upload and host Streamlit applications in the
cloud, generating public URLs to share with other users.
It is useful for sharing analysis results, collaborating on data
science projects, creating web application demos, and
distributing web applications to a wider audience.

1. Installing Streamlit:

To be able to use Streamlit, we will have to install the package through the console (CMD), to do so we execute the following command line: pip install streamlit

2. Creating the web app code :

For the demonstration of the use of Streamlite, a basic web app was developed, about the analysis of auto parts sales, which will show different data visualization graphs:

# Importación de Librerías
import streamlit as st
import pandas as pd
import matplotlib.pyplot as plt

# Datos de productos y ventas
productos = {
    'Articulos': ['Cremalleras', 'Baterías', 'Faros', 'Radiadores'],
    'Stock': [250, 46, 25, 145],
    'Pre. Und': [275.00, 180.00, 90.00, 150.00]
}
productos_df = pd.DataFrame(productos)

ventas = {
    'Mes': ['Enero', 'Febrero', 'Marzo', 'Abril', 'Mayo'],
    'Cremalleras': [7425, 6325, 11550, 5225, 4125],
    'Baterías': [900, 1440, 1260, 2160, 1980],
    'Faros': [720, 270, 450, 270, 360],
    'Radiadores': [3300, 4650, 2700, 3600, 1950]
}
ventas_df = pd.DataFrame(ventas)

# Cálculo de Ingresos, Egresos y Ganancia Neta
precios = {'Cremalleras': 275.00, 'Baterías': 180.00, 'Faros': 90.00, 'Radiadores': 150.00}

ventas_df['Ingresos'] = (ventas_df.drop('Mes', axis=1) * pd.Series(precios)).sum(axis=1)
ingresos_totales = 60660.00

egresos_totales = ingresos_totales * 0.5
ganancia_neta = ingresos_totales - egresos_totales

ventas_df['Egresos'] = ventas_df['Ingresos'] * (egresos_totales / ingresos_totales)

# Configuración de la Página Streamlit
st.set_page_config(page_title="Ventas de Autopartes", layout="wide")

# Título y Subtítulos
st.title("Ventas de Autopartes")
st.subheader("Tabla de Productos y Stock")
st.table(productos_df)

# Tabla de Ventas por Mes
st.subheader("Tabla de Ventas por Mes (en S/)")
st.table(ventas_df.drop(['Ingresos', 'Egresos'], axis=1).applymap
         (lambda x: f"S/ {x:,.2f}" if isinstance(x, (int, float)) else x))

# Ingresos y Egresos por Mes (Gráfico de Barras)
st.subheader("Ingresos y Egresos por Mes (en S/)")
fig, ax = plt.subplots()
ventas_df[['Mes', 'Ingresos', 'Egresos']].plot(kind='bar', x='Mes', ax=ax)
ax.set_xlabel('Mes')
ax.set_ylabel('Monto (S/)')
st.pyplot(fig)

# Distribución de Ingresos por Artículo (Gráfico de Pastel)
st.subheader("Distribución de Ingresos por Artículo (Enero) (en S/)")
fig, ax = plt.subplots()
ax.pie(ventas_df.iloc[0, 1:5], labels=ventas_df.columns[1:5], autopct='%1.1f%%')
ax.axis('equal')
st.pyplot(fig)

# Tendencia de Ventas (Gráfico de Líneas)
st.subheader("Tendencia de Ventas (en S/)")
fig, ax = plt.subplots()
for col in ventas_df.columns[1:5]:
    ax.plot(ventas_df['Mes'], ventas_df[col], marker='o', label=col)
ax.set_xlabel('Mes')
ax.set_ylabel('Monto (S/)')
ax.legend()
st.pyplot(fig)

# Resumen de Ventas (Métricas)
st.subheader("Resumen de Ventas (en S/)")
col1, col2, col3 = st.columns(3)
col1.metric("Ingresos Totales", f"S/ {ingresos_totales:,.2f}")
col2.metric("Egresos Totales", f"S/ {egresos_totales:,.2f}")
col3.metric("Ganancia Neta", f"S/ {ganancia_neta:,.2f}")

We run our program using the following command line: streamlit run (filename)

-After executing the above command, a web page with our graphics
that we have defined in the code of the example exercise will
automatically open locally:

3. Deployment using Streamlit Share :

We enter the Streamlit share page, where we will have 3 options to deploy our web app, in this case we will make use of a previously created repository where we have uploaded our example exercise:

In the repository where we upload the exercise, we must make sure that it is in the main branch. In addition, if necessary, we must add the requirements in a .txt file.

Now, returning to Streamlit Share, we must select the name of our repository, in which branch it is located, the name of the file where we uploaded the code and click on deploy.

We waited a few minutes, and we will see that our deployment of our exercise could be completed.

As we can see, from the Streamlit installation process to deployment using Streamlit Share is done quickly and easily.
Link of the deployed test exercise:
https://app-example-vydyjngb4z5cbzz9ljqufe.streamlit.app/