Forem: Babak

I am trying to create an ocr for Farsi language which could have a sophisticated results with old Persian texts. Here I've shared a small tool on this journey with you. Please share your thoughts. I'm very interested in to find a team worker on this ;)

Babak — Fri, 12 Sep 2025 16:14:50 +0000

Babak

Sep 12 '25

Farsi Image generator

#pillow #libraqm #gradio #ocr

Comments

2 min read

Farsi Image generator

Babak — Fri, 12 Sep 2025 16:11:04 +0000

During the development of a personal project, I needed to build a script that converts Farsi (Persian) text into an image. To make the process easier — and a bit more fun — I chose the excellent Gradio framework to build a simple interactive interface.

What is Gradio?

Gradio is a popular open-source Python library that makes it easy to create interactive, web-based UIs for machine learning models, APIs, or even plain Python functions. It’s a favorite among data scientists and ML engineers who want to quickly share their work — no HTML, CSS, or JavaScript required.

Gradio also has a new serverless option, Gradio-Lite, which is amazing for quick demos, but unfortunately it’s not suitable for this project.

Installing Gradio

I prefer using uv as my package manager since it’s blazing fast (thanks to Rust under the hood):

uv add gradio

Installing libraqm

Farsi uses a complex script where the shape of each character depends on its position in the word. To render it correctly, we need libraqm, which handles text shaping.

Here’s how to install it:

macOS

Using Homebrew:

brew install libraqm

If you’re using fish shell, you’ll also need to update your PKG_CONFIG_PATH:

set -gx PKG_CONFIG_PATH "(brew --prefix libraqm)/lib/pkgconfig:$PKG_CONFIG_PATH"

Windows

Follow this StackOverflow answer for installation instructions.

Installing Pillow

Once libraqm is set up, install Pillow with:

uv pip install Pillow --no-binary=Pillow

This ensures Pillow is compiled with libraqm support.

Converting Farsi Text to an Image

Now that everything is installed, we can write a simple script that takes:

A font file
Your Farsi text
Image dimensions

Here’s the script:

Run the script, then open your app at:
http://localhost:8007/

Here’s the result 🎉

!! If you find this post helpful or have any thought, please don't be shy and share it here with me.

5 useful tiny Php helper functions

Babak — Fri, 13 May 2022 17:37:58 +0000

Here I am going to introduce five useful Php functions that I usually use in my projects.

Does an array of keys exists in an array? You can check multiple keys existence inside an array.

function array_keys_exists(array $keys, array $arr)
{
    return !array_diff_key(array_flip($keys), $arr);
}

$sample = [1, 2, 3, 4, 5];
array_keys_exists([2, 5], $sample) // Returns True

Delete an item from an array using its value.

function delete_array_item_by_value($array, $value)
{
    if (($key = array_search($value, $array)) !== false) {
        unset($array[$key]);
    }
    return $array;
}

$sample = [1, 2, 3, 4, 5];
delete_array_item_by_value($sample, 4) // $sample = [1, 2, 3, 5];

Want to apply a closure on items of an array? You can use array_func_map

function array_map_recursive($callback, $array)
{
    $func = function ($item) use (&$func, &$callback) {
        return is_array($item) ? array_map($func, $item) : call_user_func($callback, $item);
    };

    return array_map($func, $array);
}

Generate random int with a fixed length

function get_random_int(int $length): int
{
    $res = '';
    for ($i = 0; $i < $length; $i++) {
        $res .= mt_rand(0, 9);
    }
    if ($res[0] == 0) {
        $res = mt_rand(0, 9) . substr($res, 1);
    }
    return (int)$res;
}

get_random_int(4) // Returns 6234

Checks for all parameters are empty or not.

function all_empty()
{
    foreach (func_get_args() as $arg)
        if (empty($arg))
            continue;
        else
            return false;
    return true;
}

all_empty([], [], [3, 4]) // Returns False
all_empty([], [], []) // Returns True

Export Query to compressed CSV file in laravel

Babak — Mon, 28 Feb 2022 15:23:02 +0000

Exporting your database records or a calculated array of data to a CSV file is a very common use case. Here in this article, I'm trying to give you a utility class for achieving this.

What concerns this article covers:

Get data from both chunked queries and arrays
Reduce the size of the output file by compressing it
Be ready for concurrent multiple requests
Delete old files in the folder

Now, let's get our hands dirty.

A utility class for exporting

I going to define a new Utilities namespace in my app folder and add a class of ExportToCSV into it. I expect this class to do two main jobs, One is exporting CSV from a query, and two is from an array of data. I also mentioned that it chunks the query to make it optimized in favor of our memory usage. You can learn more about chunking from this link.

So, our ExportToCSV class is something like below with two public functions:

<?php

namespace App\Utilities;

use Illuminate\Contracts\Database\Query\Builder;

class ExportToCSV
{
    public function exportFromQuery(Builder $query)
    {
        //
    }

    public function exportFromArrayData(array $data)
    {
        //
    }
}

Okay, first things first, let's create a method for query export.

Exporting to CSV file

After creating exportFromQuery() with one $query parameter, let's constrain it to be an instance of Illuminate\Contracts\Database\Query\Builder, this helps us to make sure that it has the chunk() method in it.
So, we need to open a CSV file and start iterating over our data for filling up the file. But where do we open it? Storage is needed and I will add a property for it in our class.

Also, we must specify the header for the CSV file. So, there is another property for our headers.

use Illuminate\Contracts\Filesystem\Filesystem;

class ExportToCSV
{
    protected Filesystem $storage;
    protected mixed $file;
    public array $headers;
    // ...

    public function exportFromQuery(Builder $query, array $headers)
    {
        $this->query = $query;
        $this->headers = $headers;

        $this->storage = $this->storage ?? app('filesystem')->disk(config('filesystems.default'));

        // Write to csv file in append mode(a+)
        $this->file = fopen($this->storage->path($this->fileName), 'a+');
        fputcsv($this->file, $this->header);

        $this->query->chunk($this->chunkSize, function($iterableData){
            foreach ($iterableData as $row) {
                $toArray = json_decode(json_encode($row), true);
                $res     = [];
                foreach ($this->headers as $key => $value) {
                    $res[$key] = data_get($toArray, $key);
                }
                $res = array_filter($res, fn ($item) => !is_array($item));

                fputcsv($this->file, $res);
            }
        });

        fclose($this->file);

        return $this->compressFilesAndGetDownloadStream();
    }
}

The same strategy is applicable for exporting from an array of data, we need to just change the query with a foreach over the requested array.

class ExportToCSV
{
    protected Filesystem $storage;
    protected mixed $file;
    public array $headers;
    // ...

    public function exportFromArrayData(?array $data = [], array $headers)
    {
        $this->data = $data;
        $this->headers = $headers;

        $this->storage = $this->storage ?? app('filesystem')->disk('default');

        // Write to csv file in append mode(a+)
        $this->file = fopen($this->storage->path($this->fileName), 'a+');
        fputcsv($this->file, $this->header);

        foreach ($this->data as $row) {
            $toArray = json_decode(json_encode($row), true);
            $res     = [];
            foreach ($this->headers as $key => $value) {
                $res[$key] = data_get($toArray, $key);
            }
            $res = array_filter($res, fn ($item) => !is_array($item));

            fputcsv($this->file, $res);
        }

        fclose($this->file);

        return $this->compressFilesAndGetDownloadStream();
    }
}

Compressing the output file(s)

Well, by now we have our CSV file with all of the records in it, next step is to compress it which refers to the compressFilesAndGetDownloadStream() method at the end of the above codes. For compressing, we can use the PHP ZipArchive class which you can learn about it from here.

Below we add compressFilesAndGetDownloadStream method to our class.

use Symfony\Component\HttpFoundation\StreamedResponse;
use ZipArchive;
// ...

class ExportToCSV
{
    // ...

    public function compressFilesAndGetDownloadStream()
    {
        $zip = new ZipArchive();
        $zip->open($this->storage->path($this->zipFileName), ZipArchive::CREATE | ZipArchive::OVERWRITE);
        foreach ($this->storage->allFiles() as $filePath) {
            if (strpos('.zip', $filePath)) continue;
            $zip->addFile($this->storage->path($filePath), $filePath);
        }
        $zip->close();

        return $this->storage->download($this->zipFileName);
    }
}

Being ready for multiple requests

Until now, we have covered our two main concerns of exporting from query or data array and compressing the result. It's time to take care of multiple concurrent requests for exporting data and deleting old generated files.

When it comes to speaking of multiple requests, there is a need for separating generated files. We can separate files of each request to a folder with a random name, I call it process ID and after compressing that folder, we can delete it. As we are speaking of concurrency, we should be careful about picking different names at the exactly same time. Using uuid() helps us to prevent duplication in naming files/folders. Refer to here and here

So, let's add a processId property to our class and initialize it in the constructor.

use Illuminate\Support\Str;

class ExportToCSV
{
    protected string $processId;

    public function compressFilesAndGetDownloadStream()
    {
        $this->processId = Str::uuid()->toString();
    }
}

And create a directory for this process before opening the CSV file.

// ...

$this->storage->makeDirectory($this->processId);
// Write to csv file in append mode(a+)
$this->file = fopen($this->storage->path("$this->processId/$this->fileName"), 'a+');

// ...

We also need to make sure that only files in this process's folder are going to be compressed. So, let's update compressing section by adding folder name and removing folder name from the file name by substr($filePath, strlen($this->processId) + 1).

$zip = new ZipArchive();
$zip->open($this->storage->path($this->zipFileName), ZipArchive::CREATE | ZipArchive::OVERWRITE);
foreach ($this->storage->allFiles($this->processId) as $filePath) {
    if (strpos('.zip', $filePath)) continue;
    $zip->addFile($this->storage->path($filePath), substr($filePath, strlen($this->processId) + 1));
}
$zip->close();

After compressing, we need to delete the folder by $this->storage->deleteDirectory($this->processId);

Deleting old files

Well, now it's time to delete old files in our target storage. For this purpose, I added a method that calculates the last modified time of each file and compares it to now. After that, if the modified time is greater than a specified day, it will delete it from the storage.

The oldFilesDueDays property can be configured according to the customer's need and we also have an option here for skipping deletion if the oldFilesDueDays was set to -1.

protected function deleteOldZipFiles()
{
    // Delete old files that longer than x day
    // For not deleting old files, -1 can be set to $oldFilesDueDays
    if ($this->oldFilesDueDays === -1) return;

    foreach ($this->storage->allFiles() as $old_file) {
        $fileCreatedAtDaysDiff = Carbon::now()->diffInDays(Carbon::parse($this->storage->lastModified($old_file)));
        if ($fileCreatedAtDaysDiff > abs($this->oldFilesDueDays)) {
            $this->storage->delete($old_file);
        }
    }
}

The method of deleteOldZipFiles() can be called before or after file compression.

Wrap up

We have covered exporting from a chunked query or a data array into a CSV file. Plus compressing it and deleting the process folder and old files.

The final code of this attempt is as below. I've glued different parts and refactored it to be more readable and customizable.

Dynamic settings in laravel via config function

Babak — Tue, 01 Feb 2022 13:03:48 +0000

Who is this for?

If you have some parameters in your project that may change in the future, you should make them dynamic to change them easily, because your client may decide to update those parameters or you may feel some restriction parameter should be updated in the future.
In this article, I'm gonna show a straightforward method that enables you to dynamically change settings from your database and cache them to not query the database in every run.

Why do we need dynamic settings?

At first, it seems trivial to update a few parameters during the lifetime of a project, you may be requested to just change this value and commit it. Okay, but after a while, the below questions may come to you.

Why do they call me (a programmer) to change a setting?
Why do I need to commit a hard-coded parameter?
I've delivered this project, why do they ask me to work on it?

The problem is these hard-coded parameters must be dynamic to be changed easily, but how?
Is this a good idea to create a new file in the config folder and save these parameters in it to easily change them later? Or binding them to the .env file to not have to do a commit for every change?

Okay, it seems good to have a config file and bind its value to .env, laravel has a basis for this and we can use laravel's helper functions such as config() for retrieving these values. But I don't agree with this solution. You have to deliver this project, and after that, you should not be called for every change in the project. Or, your client may have an operator that doesn't know about the .env file and its confidential parameters, and many other reasons for not storing a dynamic parameter in .env.

So, how to alleviate it?

Storing parameters in Database

We should store a dynamic value in a dynamic area and a database is made for this job. So, we need a table for storing these parameters, this table may have a simple structure like below, we can create a Setting model and migration by running php artisan make:model Setting -m.

setting migration file

class CreateSettingsTable extends Migration
{
    /**
     * Run the migrations.
     *
     * @return void
     */
    public function up()
    {
        Schema::create('settings', function (Blueprint $table) {
            $table->id();
            $table->string('key')->index();
            $table->text('value');
        });
    }

    /**
     * Reverse the migrations.
     *
     * @return void
     */
    public function down()
    {
        Schema::dropIfExists('settings');
    }
}

And for model we have

class Setting extends Model
{
    protected $fillable = [
        'key',
        'value',
    ];

    public $timestamps = false;
}

Up to this point, we don't have any complex structure for storing or retrieving our setting parameters. We can use \App\Models\Setting::updateOrCreate() for updating or creating a setting and \App\Models\Setting::where('key', 'someKey')->first() for retrieving the setting.

Using laravel's config

It would be really great if I could get settings using laravel's config infrastructure, by doing this, one can easily get a value using config('param_name') function.

We can have a settings file in laravel's config folder named settings.php and define every parameter in it with a default initial value (we want to make them dynamic). This file can be something like below

config/settings.php

<?php

return [
    'main' => [
        'param1' => 'default_value_1',
        'param2' => 'default_value_2',
    ],
];

After that, we need to tell laravel to read this file and include its values to laravel's global config object. So, let's define a function in Setting model and call it in AppServiceProvider (Or a dedicated provider).

Setting model

class Setting extends Model
{
    ...

    public static function chargeConfig()
    {
        $settings = collect(require config_path('settings.php'))
            ->each(fn($value, $key) => app('config')->set(['setting.' . $key => $value]));

        return $settings;
    }
}

Now we have defined all values of the config file to Laravel's global config object. So we can reach them via config() function.

Let's call chargeConfig() method from ServiceProvider

AppServiceProvider

namespace App\Providers;

use App\Models\Setting;
use Illuminate\Support\ServiceProvider;

class AppServiceProvider extends ServiceProvider
{
    /**
     * Bootstrap any application services.
     *
     * @return void
     */
    public function boot()
    {
        Setting::chargeConfig();
    }
}

Store setting in database and cache them

These settings should be inserted into the database as we discussed earlier. But, there is a problem in front of us, how we can store these nested arrays into DB?

Fortunately, Arr helper class has a method named dot() which converts a nested array to a dotted one, so we can store an array with its structure into database and change their values in database with ease.

First, we add a new method to the Setting model for caching results of the settings table and we update chargeConfig() method to read from the cache.

use Illuminate\Support\Facades\Cache;
use Illuminate\Support\Collection;

class Setting extends Model
{
    ...

    public static function chargeConfig()
    {
        $settings = Cache::get('db_setting', []);

        if ($settings instanceof Collection) {
            collect($settings)
                ->each(fn ($setting) => app('config')->set(['settings.' . $setting->key => $setting->value]));
        }

        return $settings;
    }

    public static function refreshCache()
    {
        Cache::forget('db_setting');
        Cache::rememberForever('db_setting', fn() => static::query()->get()->toBase());

        return self::chargeConfig();
    }
}

Now, let's define a command for storing/updating settings into database using php artisan make:command LoadSettingsFromFile.

namespace App\Console\Commands;

use \Illuminate\Console\Command;
use \App\Models\Setting;
use \Illuminate\Support\Arr;

class LoadSettingsFromFile extends Command
{
    /**
     * The name and signature of the console command.
     *
     * @var string
     */
    protected $signature = 'settings:load-file';

    /**
     * The console command description.
     *
     * @var string
     */
    protected $description = 'Load settings from file, this command is not overriding db values.';

    /**
     * Execute the console command.
     *
     * @return int
     */
    public function handle()
    {
        $settings = \Arr::dot(require config_path('settings.php'));
        foreach ($settings as $key => $value) {
            Setting::query()
                ->firstOrCreate([
                    'key' => $key,
                ], [
                    'value' => $value,
                ]);
        }

        Setting::refreshCache();

        $this->info('Setting file has been loaded successfully.');

        return Command::SUCCESS;
    }
}

Execute this command by running php artisan settings:load-file and then you have your settings in the database.

Last word

Now, you can update settings in database and after that run settings:load-file command to update the cached values in your application.
This command can be executed after each update in database or on a scheduler or called via your admin panel using \Artisan::call('settings:load-file').

I love to hear from you 😍, so feel free to share your thoughts and critics with me in the comments. 👀