DEV Community: Srimathi10

Utilize Kubernetes for container orchestration

Srimathi10 — Tue, 25 Feb 2025 18:14:41 +0000

Create and manage Docker containers for application deployment

Srimathi10 — Tue, 25 Feb 2025 18:14:26 +0000

How to Create and Upload a Python Package to PyPi: A Step-by-Step Guide

Srimathi10 — Tue, 25 Feb 2025 15:28:31 +0000

Creating and uploading a Python package to PyPi (Python Package Index) is an essential skill for sharing your work with the community. In this blog post, we’ll walk through the complete process using an example package, file_compressor, which compresses files into a .zip format. By the end of this guide, you’ll be able to create, build, and upload your own Python package to PyPi.

Let’s get started!

Step 1: Setting Up Your Environment

Before we begin creating the Python package, you need to set up your environment with the necessary tools. If you don't have Python installed, please install it from python.org.

We will also need a few packages to help build and upload the package:

pip install setuptools wheel twine

What Are These Packages?

setuptools: A tool for packaging Python projects.
wheel: A packaging format for Python distribution.
twine: A tool to securely upload your package to PyPi.

Step 2: Create Your Package Directory

Now that you have the necessary tools, create a directory for your project. Inside this directory, you will organize your Python package and related files.

Here’s how your directory structure might look for the file_compressor package:

file_compressor/
├── file_compressor/              # Package directory containing the Python code
│   └── __init__.py               # Mark this directory as a Python package
├── setup.py                      # Metadata about the package
├── LICENSE                       # License information (MIT, GPL, etc.)
├── README.md                     # Documentation about your package
├── MANIFEST.in                   # Include additional non-Python files (optional)
└── tests/                        # Unit tests for the package

Package Code Example:

In the file_compressor/ directory, you might create a Python file, such as compress.py, which contains the core functionality of your package, like compressing files into a .zip format.

Here’s an example implementation of compress.py:

import zipfile
import os

def compress_file(input_file, output_file):
    """Compress a single file into a zip archive."""
    with zipfile.ZipFile(output_file, 'w', zipfile.ZIP_DEFLATED) as zipf:
        zipf.write(input_file, os.path.basename(input_file))

    print(f"File {input_file} compressed to {output_file}.")

Step 3: Create the `setup.py` File

The setup.py file contains important metadata for your Python package, such as its name, version, and description. Here is an example setup.py for file_compressor:

from setuptools import setup, find_packages

setup(
    name='file_compressor',              # Name of your package
    version='0.1.0',                     # Initial version
    packages=find_packages(),            # Find all Python packages
    description='A Python package for compressing files into .zip format',
    long_description=open('README.md').read(),
    long_description_content_type='text/markdown',
    author='Your Name',
    author_email='your-email@example.com',
    url='https://github.com/your-username/file_compressor',  # Link to GitHub repository
    classifiers=[
        'Programming Language :: Python :: 3',
        'License :: OSI Approved :: MIT License',
        'Operating System :: OS Independent',
    ],
    install_requires=[],                 # Add any dependencies here (if needed)
    python_requires='>=3.6',             # Specify the minimum Python version
)

name: The name of your package (e.g., file_compressor).
version: The current version of your package (start with 0.1.0 for the first release).
description: A short description of what your package does.
long_description: A detailed description (this can be fetched from your README.md file).
author: Your name or organization.
author_email: Your email address.
url: The URL to your package's homepage (usually your GitHub repository).

Step 4: Create a README.md

A README.md file is essential to explain the purpose of your package and how to use it. Here's a simple example:

# File Compressor

A Python package that compresses files into `.zip` format.

## Installation

bash
pip install file-compressor


## Usage

python
from file_compressor import compress_file

compress_file('path/to/your/file.txt', 'path/to/output/file.zip')

Step 5: Build the Package

Now it’s time to build the package. In your project directory (where setup.py is located), run the following commands:

python setup.py sdist bdist_wheel

This command creates distribution archives, which include:

sdist: The source distribution, a .tar.gz file.
bdist_wheel: The wheel distribution, a .whl file.

These files will be stored in a dist/ directory inside your project folder.

Step 6: Create a PyPi API Token

To securely upload your package to PyPi, you need to create an API token. Here’s how:

Log in to PyPi: Go to https://pypi.org/ and log in.
Go to Account Settings: Click your username in the top-right corner and select "Account settings".
Create an API Token:
- Scroll down to the API tokens section.
- Click "Add API token".
- Provide a name for the token (e.g., "file_compressor upload").
- Click "Add token".
Save the API token: Make sure to copy and securely store the token. You’ll only see it once.

Step 7: Upload to PyPi

Once the package is built, you can upload it using twine. Run the following command to upload the distribution files to PyPi:

twine upload dist/* -u __token__ -p <your-pypi-api-token>

Replace <your-pypi-api-token> with the actual token you generated in the previous step.

This will securely upload your package to PyPi. If the upload is successful, you'll see a confirmation message.

Step 8: Verify Your Package on PyPi

After uploading, visit https://pypi.org/project/file-compressor/ to verify that your package is live on PyPi. You should see the version, description, and files listed.

Step 9: Install and Test Your Package

To ensure your package is working correctly, try installing it in a new Python environment:

pip install file-compressor

Once installed, test it in a Python script:

from file_compressor import compress_file

compress_file('path/to/your/file.txt', 'path/to/output/file.zip')

If the package works as expected, congratulations! Your package is ready for others to use.

Step 10: Updating Your Package

In the future, if you make any updates to your package, follow these steps:

Modify your package (e.g., add new features or fix bugs).
Update the version number in setup.py (e.g., from 0.1.0 to 0.2.0).
Repeat the build and upload steps to publish the new version.

Conclusion

In this guide, we've gone over the complete process of creating a Python package, specifically the file_compressor package, from scratch. You learned how to:

Set up the package structure.
Write the setup.py and README.md files.
Build and upload your package to PyPi.
Use an API token for secure uploads.

With this knowledge, you can now share your Python packages with the world via PyPi! If you want to explore more about package creation, check out the official PyPi documentation.

Blog: Building a Visitor Management System with PyQt6 and SQLite

Srimathi10 — Tue, 25 Feb 2025 14:09:47 +0000

In this blog, we'll explore how to create a simple yet effective Visitor Management System (VMS) using Python's powerful PyQt6 library and SQLite for database management. This system allows users to register, search, edit, and delete visitor records in a building or organization. Let's break down the key features and explain how everything fits together.

What is the Visitor Management System?

A Visitor Management System (VMS) is designed to efficiently manage the flow of visitors in any facility. It captures details like the visitor's name, the company they represent, and contact information. This system ensures that these records are easily accessible and can be updated when necessary. In this project, we will be building a simple VMS using PyQt6 for the GUI and SQLite as the backend database.

Setting Up the Environment

Before we jump into the code, make sure you have Python installed on your system. You'll also need the following libraries:

PyQt6 – This will be used for the graphical user interface.
SQLite – For storing visitor data.

You can install the necessary libraries using pip:

pip install pyqt6 sqlite3

Database Design

At the heart of our VMS is the SQLite database. The system interacts with a database to store, retrieve, and modify visitor records. The visitors table will consist of the following fields:

id – An auto-incremented primary key.
name – Name of the visitor.
company – The company the visitor is associated with.
contact – Contact information for the visitor.

Here's the SQL script to create the visitors table:

CREATE TABLE IF NOT EXISTS visitors (
    id INTEGER PRIMARY KEY AUTOINCREMENT,
    name TEXT NOT NULL,
    company TEXT NOT NULL,
    contact TEXT NOT NULL
);

This ensures that if the table doesn't already exist, it will be created. The database connection is managed via the DatabaseConnection class in the code.

The PyQt6 User Interface

The user interface (UI) for this VMS is built using PyQt6. We create the main window and add functionality for adding, searching, editing, and deleting visitor records.

Menu Bar

The menu bar provides easy access to common operations. It includes:

File Menu: This contains the action to add a new visitor.
Help Menu: Displays an "About" dialog.
Edit Menu: Contains actions like searching for visitors.

Table View

A table view (QTableWidget) is used to display the visitor records. The columns are set to show:

Id: The visitor's ID.
Visitor Name: Name of the visitor.
Company: The company the visitor is associated with.
Contact: Contact details.

Key Features and Dialogs

The system is designed with several dialogs to handle various operations like adding, editing, deleting, and searching for visitors.

Add Visitor Dialog (InsertDialog)
- This dialog allows the user to input visitor details (name, company, and contact) and add them to the database.
Edit Visitor Dialog (EditDialog)
- The user can update the details of an existing visitor by selecting a record from the table and modifying the information.
Delete Visitor Dialog (DeleteDialog)
- This dialog prompts the user to confirm before deleting a visitor's record from the database.
Search Visitor Dialog (SearchDialog)
- Users can search for a visitor by name. If found, the matching record is highlighted in the table.

Connecting Everything Together

Here's how the components interact:

Database Connection: The DatabaseConnection class manages the connection to the SQLite database. It provides methods to connect to the database and execute queries like creating the table, inserting, updating, and deleting records.
MainWindow Class: This is the heart of the UI. It contains a table (QTableWidget) to display records, a toolbar with actions like "Add Visitor" and "Search", and a status bar that shows options to edit or delete records when a table cell is clicked.
Dialogs: Each dialog handles a specific user action (insert, update, delete, search). When the user interacts with the main window, these dialogs allow for smooth data entry and modification.

Code Breakdown

Creating the Table: The first step is ensuring that the visitors table is created when the application starts. This is handled by the DatabaseConnection class, which includes the create_table method.

class DatabaseConnection:
    def __init__(self, database_file="visitor_db.db"):
        self.database_file = database_file

    def connect(self):
        connection = sqlite3.connect(self.database_file)
        return connection

    def create_table(self):
        connection = self.connect()
        cursor = connection.cursor()
        cursor.execute("""
        CREATE TABLE IF NOT EXISTS visitors (
            id INTEGER PRIMARY KEY AUTOINCREMENT,
            name TEXT NOT NULL,
            company TEXT NOT NULL,
            contact TEXT NOT NULL
        );
        """)
        connection.commit()
        cursor.close()
        connection.close()

Adding a Visitor: The InsertDialog class allows users to input visitor information and store it in the SQLite database.

class InsertDialog(QDialog):
    def __init__(self):
        super().__init__()
        self.setWindowTitle("Insert Visitor Data")
        self.setFixedWidth(300)
        self.setFixedHeight(300)

        layout = QVBoxLayout()

        # Add visitor name widget
        self.visitor_name = QLineEdit()
        self.visitor_name.setPlaceholderText("Visitor Name")
        layout.addWidget(self.visitor_name)

        # Add company name widget
        self.company_name = QLineEdit()
        self.company_name.setPlaceholderText("Company Name")
        layout.addWidget(self.company_name)

        # Add contact number widget
        self.contact_number = QLineEdit()
        self.contact_number.setPlaceholderText("Contact Number")
        layout.addWidget(self.contact_number)

        # Add a submit button
        button = QPushButton("Register Visitor")
        button.clicked.connect(self.add_visitor)
        layout.addWidget(button)

        self.setLayout(layout)

    def add_visitor(self):
        name = self.visitor_name.text()
        company = self.company_name.text()
        contact = self.contact_number.text()
        connection = DatabaseConnection().connect()
        cursor = connection.cursor()
        cursor.execute("INSERT INTO visitors (name, company, contact) VALUES (?, ?, ?)",
                       (name, company, contact))
        connection.commit()
        cursor.close()
        connection.close()
        main_window.load_data()

Conclusion

The Visitor Management System created with PyQt6 and SQLite offers a simple yet functional solution to managing visitor data. The system features an intuitive graphical interface, with a database backend to persist visitor records. Users can easily add, search, edit, and delete records, making this system suitable for many real-world applications.

Check out the complete source code and contribute to the project on GitHub.

Feel free to customize and extend this application based on your needs.

Blog Post: Merging PDF Files Using Python

Srimathi10 — Tue, 25 Feb 2025 12:48:22 +0000

In this tutorial, we'll walk through a Python script that merges multiple PDF files into one. This functionality is helpful in various scenarios, such as combining reports, invoices, or documents into a single file. To achieve this, we'll use the popular Python library PyPDF2, which allows for easy manipulation of PDF files.

If you're interested in the source code for this project, you can find it on GitHub: Merge_pdf GitHub Repository.

Step 1: Install the Required Library
To begin, you need to install the PyPDF2 library. This library simplifies tasks like merging, splitting, and rotating PDF pages. Open your Command Prompt or Terminal and run the following command:

pip install PyPDF2

This will install the necessary dependency for the script. If you see any warning related to the pip version, it's a good idea to update it, although it is not strictly required for the script to work.

Step 2: Writing the Code
Now let's dive into the code that merges the PDF files.

import PyPDF2
import glob
from pathlib import Path

# Create a list of PDF filepaths
filepaths = glob.glob("files/*.pdf")

# Create a PDF merger object
pdf_merger = PyPDF2.PdfMerger()

# Go through each PDF file and append to the merger object
for filepath in filepaths:
    # Append the current PDF file to the merger
    pdf_merger.append(filepath)

# Output the merged PDF
with open("merged.pdf", "wb") as output_pdf:
    pdf_merger.write(output_pdf)

print("PDFs merged successfully into 'merged.pdf'")

Explanation of the Code:

Import Libraries:

PyPDF2: This library is used to manipulate PDF files in Python.
glob: It helps in searching for PDF files in a specified folder.
Path: From the pathlib module, this provides an easy way to handle file paths.

Gather PDF File Paths:

glob.glob("files/*.pdf") finds all PDF files in the files/ directory and stores their paths in the filepaths list.

Merge PDFs:

A PyPDF2.PdfMerger() object is created to merge the PDFs.
For each file in the filepaths list, the append() method is used to add the PDF to the merger.

Output the Merged PDF:

The merged PDF is written to a new file called merged.pdf using the pdf_merger.write(output_pdf) function.

Run the Script:

After running the script, you will see the message PDFs merged successfully into 'merged.pdf'.

Step 3: Running the Script
Once the script is ready, you can execute it from your Command Prompt or Terminal with the following command:

python main.py

If the script runs successfully, you will see the following output:

C:\projects\merge_pdf>python main.py
PDFs merged successfully into 'merged.pdf'

Conclusion:
By following this tutorial, you should now be able to merge multiple PDF files into a single PDF document using Python and PyPDF2. This approach is ideal for combining reports, documents, or invoices with minimal code. The script is simple yet effective for working with multiple PDFs, and you can easily adapt it for other PDF manipulation tasks.

The source code for this project is available on GitHub: Merge_pdf GitHub Repository .

Feel free to modify the script for tasks like splitting PDFs, rotating pages, or extracting text. The possibilities are endless!

Happy coding!

DEV Community: Srimathi10

Utilize Kubernetes for container orchestration

Create and manage Docker containers for application deployment

How to Create and Upload a Python Package to PyPi: A Step-by-Step Guide

Step 1: Setting Up Your Environment

What Are These Packages?

Step 2: Create Your Package Directory

Package Code Example:

Step 3: Create the setup.py File

Step 4: Create a README.md

Step 5: Build the Package

Step 6: Create a PyPi API Token

Step 7: Upload to PyPi

Step 8: Verify Your Package on PyPi

Step 9: Install and Test Your Package

Step 10: Updating Your Package

Conclusion

Blog: Building a Visitor Management System with PyQt6 and SQLite

What is the Visitor Management System?

Setting Up the Environment

Database Design

The PyQt6 User Interface

Menu Bar

Table View

Key Features and Dialogs

Connecting Everything Together

Code Breakdown

Conclusion

Blog Post: Merging PDF Files Using Python

Step 3: Create the `setup.py` File