Author: techworkshop

Handling File Uploads in Different Python Frameworks

Learn how to handle file uploads in popular Python frameworks like Flask, Django, FastAPI, and Frappe. Step-by-step guide with examples. Perfect for developers!

To handle file uploads from an HTML form in your Python Frameworks, you typically handle them differently depending on the web framework you’re using (e.g., Flask, Django, FastAPI, Frappe, etc.).

Note: HTML form must include enctype="multipart/form-data".

In this article, we learn how to handle file uploads in some common Python web frameworks:

Using Flask

Design an HTML form with file field as follows,

<form action="/upload" method="post" enctype="multipart/form-data">
  <input type="file" name="myfile">
  <input type="submit">
</form>

You can get the uploaded file from the myfile field as follows,

from flask import Flask, request

app = Flask(__name__)

@app.route('/upload', methods=['POST'])
def upload_file():
    uploaded_file = request.files['myfile']
    if uploaded_file.filename != '':
        uploaded_file.save(f"./uploads/{uploaded_file.filename}")
    return "File uploaded successfully!"

Using Django

In Django, HTML form is exactly same. But, you have to add csrf_token to each form.

<form method="post" enctype="multipart/form-data">
  {% csrf_token %}
  <input type="file" name="myfile">
  <input type="submit">
</form>

You can get the file from the myfile field as follows,

from django.core.files.storage import FileSystemStorage
from django.http import HttpResponse

def upload_file(request):
    if request.method == 'POST' and request.FILES['myfile']:
        uploaded_file = request.FILES['myfile']
        fs = FileSystemStorage()
        fs.save(uploaded_file.name, uploaded_file)
        return HttpResponse('File uploaded!')
    return HttpResponse('Upload form')

Get book to learn basics of python from https://amzn.to/3FIs9cW

Using FastAPI

The HTML design file is same as the Django HTML file with csrf_token.

Backend code to get the uploaded file is as follows,

from fastapi import FastAPI, File, UploadFile
from fastapi.responses import HTMLResponse

app = FastAPI()

@app.post("/upload/")
async def upload_file(file: UploadFile = File(...)):
    contents = await file.read()
    with open(f"./uploads/{file.filename}", "wb") as f:
        f.write(contents)
    return {"filename": file.filename}

Using Frappe

In Frappe, when you submit a file from an HTML form, you can handle file uploads using its built-in frappe.utils.file_manager.save_file() method. The HTML design file for Frappe is as follows,

<form method="POST" enctype="multipart/form-data" action="/api/method/my_app.api.upload_file">
  <input type="file" name="file">
  <input type="submit" value="Upload">
</form>

In Frappe backend, you have to create whitelisted method for handling file upload as follows,

import frappe
from frappe.utils.file_manager import save_file
from frappe import _

@frappe.whitelist(allow_guest=True)  # or remove `allow_guest=True` if auth is needed
def upload_file():
    # Access the uploaded file from the request
    uploaded_file = frappe.request.files.get('file')
    
    if not uploaded_file:
        frappe.throw(_("No file uploaded"))

    # Save the file using Frappe's file manager
    saved_file = save_file(
        filename=uploaded_file.filename,
        content=uploaded_file.stream.read(),
        dt=None,  # You can pass doctype here if you want to attach it
        dn=None   # and document name
    )

    return {
        "message": "File uploaded successfully",
        "file_url": saved_file.file_url,
        "file_name": saved_file.file_name
    }

Conclusion

In above post, we learned file uploads using four different Python backed frameworks. We learned that different framework have different ways to handle file uploads.

Disclaimer: This post contains affiliate links. If you use these links to buy something, I may earn a commission at no extra cost to you.

Develop Contact Form using Livewire in Laravel

Learn how to create a responsive contact form using Livewire in Laravel. Step-by-step tutorial with validation, form submission, and real-time updates.

Developing a Contact form using Livewire in Laravel is straightforward and involves a very few key steps.

In this post, we will learn to develop contact form using Livewire component in Laravel. Follow the below steps:

Step 1: Install Livewire

To create any Livewire form, you must have Livewire installed over Laravel project. If you haven’t installed Livewire yet, you can do so via Composer:

composer require livewire/livewire

It will install Livewire package to you Laravel project.

Step 2: Create a Livewire Component

Now, we need to create a Livewire component for contact form. You can generate a Livewire component using Artisan command as follows:

php artisan make:livewire ContactForm

This will create 2 files as follows:

  • A Livewire component file at app/Http/Livewire/ContactForm.php
  • A Blade view at resources/views/livewire/contact-form.blade.php

Your contact form component is now ready to be used. But, we haven’t added any logic or any design to this component. So, if you add this component to any file, it will display blank page.

Step 3: Define the Livewire Component Logic

Open app/Http/Livewire/ContactForm.php and add all contact form related logic to the file as follows:

namespace App\Http\Livewire;

use Livewire\Component;
use App\Models\Contact;
use Illuminate\Validation\Rule;

class ContactForm extends Component
{
    public $name, $email, $message;

    protected $rules = [
        'name' => 'required|min:3',
        'email' => 'required|email',
        'message' => 'required|min:5',
    ];

    public function submit()
    {
        $this->validate();

        // Save data
        Contact::create([
            'name' => $this->name,
            'email' => $this->email,
            'message' => $this->message,
        ]);

        // Reset the form
        $this->reset(['name', 'email', 'message']);

        session()->flash('success', 'Your message has been sent!');
    }

    public function render()
    {
        return view('livewire.contact-form');
    }
}

Step 4: Create the Livewire Blade View

Open resources/views/livewire/contact-form.blade.php and update the HTML form as per your requirement. I have added my blade file design as follows:

<div>
    @if (session()->has('success'))
        <div class="p-3 mb-4 text-green-600 bg-green-200 border border-green-600 rounded">
            {{ session('success') }}
        </div>
    @endif

    <form wire:submit.prevent="submit">
        <div class="mb-4">
            <label for="name" class="block font-bold">Name:</label>
            <input type="text" id="name" wire:model="name" class="w-full p-2 border rounded">
            @error('name') <span class="text-red-600">{{ $message }}</span> @enderror
        </div>

        <div class="mb-4">
            <label for="email" class="block font-bold">Email:</label>
            <input type="email" id="email" wire:model="email" class="w-full p-2 border rounded">
            @error('email') <span class="text-red-600">{{ $message }}</span> @enderror
        </div>

        <div class="mb-4">
            <label for="message" class="block font-bold">Message:</label>
            <textarea id="message" wire:model="message" class="w-full p-2 border rounded"></textarea>
            @error('message') <span class="text-red-600">{{ $message }}</span> @enderror
        </div>

        <button type="submit" class="px-4 py-2 text-white bg-blue-600 rounded">Send</button>
    </form>
</div>

I have added some additional features like displaying success message and added error message display elements to each fields.

Step 5: Add Livewire to a Page

Now it is ready to be included to any page. You can include this component using @livewire directive provided by Livewire package. Include this Livewire component in your Blade view (e.g., resources/views/contact.blade.php):

@extends('layouts.app')

@section('content')
    <div class="container mx-auto p-4">
        <h1 class="text-xl font-bold">Contact Us</h1>
        @livewire('contact-form')
    </div>
@endsection

Still it is not visible to the page. Because, Livewire scripts and styles are missing.

Step 6: Include Livewire Scripts

You have to add Livewire scripts and styles to the layout, where you want to display any Livewire Component. You can add Livewire scripts and styles to the layout using their directives @livewireScripts and @livewireStyles respectively.

Add Livewire scripts in your layouts/app.blade.php file before the closing </body> tag of the layout file:

@livewireScripts
</body>
</html>

And add the Livewire styles in <head> tag of the layout file:

@livewireStyles

Note: If you have multiple layouts and these layouts are used to display Livewire Compoment pages, then you have to add Livewire scripts and styles in all of these layouts.

Step 7: Run Migrations and Serve the App

In component file, we have added a code to save contact form details to the database. So, If you don’t have contacts table already, create a migration for the contacts table:

php artisan make:migration create_contacts_table

Open the migration file (database/migrations/xxxx_xx_xx_xxxxxx_create_contacts_table.php) and add the necessary fields as follows:

public function up()
{
    Schema::create('contacts', function (Blueprint $table) {
        $table->id();
        $table->string('name');
        $table->string('email');
        $table->text('message');
        $table->timestamps();
    });
}

public function down(): void
{
    Schema::dropIfExists('contacts');
}

Run the migration:

php artisan migrate

It will create the contacts table into the project database. Now, create a model for this migration:

php artisan make:model Contact

It will create contact model file app/models/Contact.php. Open this model file and update it as follows,

<?php

namespace App\Models;

use Illuminate\Database\Eloquent\Factories\HasFactory;
use Illuminate\Database\Eloquent\Model;

class Contact extends Model
{
    use HasFactory;

    protected $fillable = [
        'name',
        'email',
        'message',
    ];
}

Finally, start your Laravel development server:

php artisan serve

Now, visit http://127.0.0.1:8000/contact, and you should see your Livewire-powered Contact Form working dynamically!

Additional Features You Can Add

  • Real-time validation: Add wire:model.blur="name" to inputs.
  • Loading indicators: Use wire:loading to show a spinner while submitting.

Get Row Level Difference Between Two Tables in MySQL

Learn how to compare two MySQL tables row-by-row using JOINs and dynamic SQL to identify field-level differences efficiently.

To check row level differences between two records from two different tables in MySQL, where you want to see which fields have changed, follow these steps:

Using JOIN with CASE to Identify Row Level Differences in MySQL

You can compare each column individually to check row level difference and mark which ones have changed using this MySQL query.

SELECT
a.id,
CASE WHEN a.column1 = b.column1 THEN 'No Change' ELSE 'Changed' END AS column1_diff,
CASE WHEN a.column2 = b.column2 THEN 'No Change' ELSE 'Changed' END AS column2_diff,
CASE WHEN a.column3 = b.column3 THEN 'No Change' ELSE 'Changed' END AS column3_diff
FROM table1 a
JOIN table2 b ON a.id = b.id;

You can add as many columns as you want.

What this does:

  • Compares each field individually.
  • Marks "Changed" if different, otherwise "No Change".

Want to learn more about MySQL? Get MySQL book from https://amzn.to/45JXmH0

Dynamic Query for Large Tables

If you have many columns and don’t want to manually compare each, you can generate a query dynamically using MySQL Information Schema:

SELECT CONCAT(
'SELECT id, ',
GROUP_CONCAT(
'CASE WHEN t1.', COLUMN_NAME, ' <> t2.', COLUMN_NAME,
' THEN "', COLUMN_NAME, ' changed" ELSE "No Change" END AS ', COLUMN_NAME SEPARATOR ', '
),
' FROM table1 t1 JOIN table2 t2 ON t1.id = t2.id'
) AS query_text
FROM INFORMATION_SCHEMA.COLUMNS
WHERE TABLE_NAME = 'table1' AND COLUMN_NAME != 'id';

This will generate a query that automatically checks differences for all columns. Execute the generated query and you will get the differences, where all cells are marked with "Changed" or "No Change".

Conclusion

These queries can help you identify difference between two tables cell by cell. It can be useful in many ways and reduce your so much time to identify a small difference in large data.

Do you stuck with any such problem? You can write me in the comments.

Disclaimer: This post contains affiliate links. If you use these links to buy something, I may earn a commission at no extra cost to you.

Top 7 Lightweight Linux Distros for Old PCs (2025)

Looking for the best Linux distro for an old PCs? Discover 7 lightweight Linux distributions perfect for reviving aging hardware in 2025.

Lightweight linux distros are popular due to number of benefits it offers. But, which could be the best choice for your old PC and run smoother with your old PC configuration?

In this blog, we’ll discuss various aspects of lightweight distros, some of the top lightwight linux distros and use cases and applications, which can help you to choose best for your old PC.

Why Use a Lightweight Linux Distro?

Lightweight linux distros offers flexibility, efficiency and versatility with minimum resources. Here are few points to consider,

Performance benefits for old hardware

These distributions are often used for reviving older hardware or make your older PC live again because it provides very good performance even on older hardwares.

Power efficiency and minimal resource usage

These distributions require very less resources like they can run on 512MB of RAM on Pentium II processor. Their power consumption is also very low compared to modern distros.

In this blog, we will discuss top 7 lightweight distros for old PCs in 2025. Here is the overview of these distros.

Puppy Linux

Puppy Linux is a unique family of Linux distributions specifically meant for the personal computers created by Barry Kauler in 2003.

It has some unique advantages as follows,

  1. Ready to use: all commonly used tools are already included. So, you can start right after installing it.
  2. Ease of use: lots of helps & hints are included to make it easy to use for even a beginner.
  3. Relatively small size: It will take typically 500 MB or less.
  4. Fast and versatile.
  5. Customisable within minutes: You can make all your customizations and save them as remasters. So, whenever you want to reset your PC, you can use that remaster with all your configurations intact.
  6. Different flavours: It is optimised to support both older & newer computers.
  7. Variety: It has hundreds of derivatives called them as “puplets”, one of which will surely meet your needs.

You can download and try the Puppy Linux from https://puppylinux-woof-ce.github.io/index.html

What to upgrade your Old PC? Install SSD for the better performance: https://amzn.to/45eWAl8

Lubuntu

Lubuntu is a fast and lightweight operating system built on Linux system with a clean and easy-to-use UI/UX. It required very low hardware resources, because it uses the minimal desktop LXDE/LXQT, and a selection of light applications. Lubuntu was founded by Mario Behling and has been grown for many years by Julien Lavergne.

You can use Lubuntu operating system for the your latest systems as well as for lower resource computers and older systems.

You can download Lubuntu from https://lubuntu.net/

Linux Lite

Linux Lite is free operating system for everyone. It is easy to use, and suitable for beginner users Linux as it offers a lot of beginner friendly documentation. Due to it’s low requirement of resources, it is also famous amongs the people who want a lightweight environment that is also fully functional. This distribution is easy to set up and use. It provides a great balance of speed, user friendliness, features and stability. Linux Lite was created to make the transition from Windows to a linux based operating system, as smooth as possible.

To install Linux Lite operating system, download the copy from https://www.linuxliteos.com/download.php

antiX

antiX is a fast, lightweight and easy to install systemd-free linux distribution. It is based on Debian Stable for Intel-AMD x86 compatible systems. antiX offers users an environment suitable for old as well as new computers. So don’t throw away that old computer yet!

The goal of antiX is to provide a lightweight, but fully functional and flexible free operating system, which can be useful for both beginners and experienced users of Linux. It can run on any old PC with as low as 256MB RAM with pre-configured swap. 512MB RAM is the recommended minimum requirement for antiX and installation to hard drive requires a minimum 7.0GB hard disk space.

antiX is available in 64 bit (computers built in the last 10 years) or 32 bit (very old computers or newer machines but be aware that a lot of software no longer provides 32 bit versions).

Download the different flavours of antiX from https://antixlinux.com/download/

Bodhi Linux

Bodhi Linux 7.0.0 is the lightweight Linux Distribution built on top of Ubuntu LTS (22.04) featuring the Moksha Desktop. It is known for minimalism, resource efficiency, and user choice. The team behind Bodhi Linux works to make the distribution as lean as possible and believes that the end-user should be able to choose the applications that they want rather than have a bunch of pre-installed applications that are unnecessary or unwanted.

The minimum system requirements are as follows,

  • 32bit, 500MHz Processor (including Non-PAE)
  • 512MB of RAM
  • 5GB of drive space

And recommended system requirements are as follows,

  • 64bit, 1.0GHz processor
  • 768MB of RAM
  • 10GB of drive space

Download the Bodhi Linux with Moksha Desktop from https://www.bodhilinux.com/download/

Budget DELL laptop under 30k. https://amzn.to/4k5yFJN

MX Linux

MX Linux has different flavours for different type of requirements.

  • MX Linux – KDE, which provides wide range of advanced applications and require high resources. It can run on newer 64-bit computers.
  • MX Linux – XFCE, which requires mid-weight resource, but it can run on older PCs as well as newer 64-bit computers.
  • MX Linux – Fluxbox, which reauires light weight resources and can run on any older PC as well as newer computers.

The MX Linux – Fluxbox can provide high speed performance using low resources. It is lightweight and fully functional system that has many unique features:

  • Extended hardware support by virtue of low graphical requirements.
  • Restricted base default package set gives the user easy control over components.
  • Many unique apps ease and enliven user experience.
  • Native dock and icon management tools join the tint2 panel for desktop customization.

Download various MX Linux flavours from https://mxlinux.org/download-links/

Tiny Core Linux

Tiny Core is designed to run from a RAM copy created at boot time. Besides being fast, this protects system files from changes and ensures a pristine system on every reboot.

Very Small. It required 10MB of RAM, which is 1/400 to 1/100 the size. So, It is flexible enough to be stored and run from usb sticks, a full CD, or even embedded devices.

Linux. Tiny Core uses the Linux Kernel and a set of command-line (text interface) tools including busybox.

A GUI Desktop. Tiny Core has a flexible and fully-customizable Graphical User Interface Desktop. You can also quickly install and try out a variety of other desktops and interfaces.

Unusually Stable. Tiny Core uses program ‘extensions’ to avoid damage to the system files. These extensions are re-prepared at each reboot … and they are prepared fast.

Unusually Fast. Unlike most operating systems, the Tiny Core can run completely from RAM. Tiny Core can run in 48 megabytes of RAM … or less.

Internet ready. Tiny Core almost always finds your network card right away. You’ll be adding applications and tools after an unusually quick boot.

Available even smaller. Linophiles that get things done without a GUI can get the MicroCore, a version of Tiny Core without X that is under 7 MB.

An open source community. Tiny Core is under active community development, led by a team of really dedicated people.

Download the most lightweight and fast Linux Distro from http://www.tinycorelinux.net/downloads.html

Final Thoughts + My Recommendation

We have discussed top 7 lightweight linux distros, you can use for your older PC to make them alive again. All of them are unique with their different set of advantages and it is difficult to choose anyone randomly. So, my suggestion is to check all the linux distros and their recommonded requirements to run. Compare these requirements with your computer requirement and choose accordingly. I installed Bodhi Linux for my 10 years old laptop and it is running very smoothly.

Frequently Asked Questions (FAQ)

What is the lightest Linux distro for old PCs?

Tiny Core Linux is one of the lightest Linux distros, with an ISO under 20MB and minimal system requirements.

Can I use Linux on a PC with 1GB RAM?

Yes, distros like Puppy Linux, antiX, and Lubuntu are designed to run smoothly on systems with as little as 512MB–1GB of RAM.

Is Linux better than Windows for old PCs?

Yes, Linux is often more efficient and secure for older hardware compared to Windows, especially when using lightweight distros.

Disclaimer: This post contains affiliate links. If you use these links to buy something, I may earn a commission at no extra cost to you.

Install the Laravel Filament Panel Builder

Learn to install and set up Laravel Filament, a tool for creating customizable admin panels and CRUD applications. This guide covers requirements, installation steps, and user creation. Follow this concise tutorial to get started with Filament in your Laravel project quickly and efficiently.

Laravel Filament is a powerful tool designed to create Admin panels and manage content in Laravel applications. It provides a highly customizable and developer-friendly interface for creating CRUD applications, dashboards, and various business-related applications. Filament is known for its flexibility and ease of use, allowing developers to scaffold forms, tables and pages quickly without writing a lot of boilerplate code.

This article describes the installation process filament panel over laravel with most of the possible configations and steps.

Requirements

Install and configure the following components, before running any filament command.

  • PHP v8.1+
  • Laravel v10.0+
  • Livewire v3.0+ (Filament composer command will install this package automatically. So, no need to install this package separately.)

Install Laravel Filament Panel

To install the filament panel over laravel, run the following command at the root of the project folder,

composer require filament/filament:"^3.2" -W

This command will install the base package of filament. This will also install livewire package, which is in the requirements.

php artisan filament:install --panels

This command will install the filament panel after some information required to install the panels. It will ask the following questions,

What is the ID?

On the basis of this ID, it will create the panel provide for the filament panel and also register this panel provider.

For Example:
If ID is admin, it will create the panel provide to he following location, app/Providers/Filament/AdminPanelProvider.php

If you encounter an error when accessing your panel, ensure that the service provider is registered in bootstrap/providers.php (for Laravel 11 and above) or config/app.php (for Laravel 10 and below). If it isn’t, you’ll need to add it manually.

Create a User

Next step is creating a user to access this panel. But, before running the create user command, check the following laravel configuration and update the configuration as per the requirements,

  • Add Database credentials to .env file.
  • Run the following command to run the migration. It will create users table into the database.
    php artisan migrate

Run the following command to create a user after checking above requirements,

php artisan make:filament-user

It will ask some basic questions like name, email, password, etc. for creating a user.

After creating a user, run php artisan serve, open http://127.0.0.1:8000/admin in your web browser, sign in using the created user credentials, and start building your app!