Blog

React, Typescript, Jest, Prettier, 2e2 Cypress – setup application boilerplate

Clone this repository to destination folder.

git clone https://github.com/leolanese/react-typescript-jest-prettier-cypresss-husky-boilerplate

Install dependencies.

npm install

Run local environment.

npm start

Available scripts

npm start – run development server with hot reload mode,

npm build – build distributon package,

npm run lint – run lints,

npm run lint:code – run lint for typescript / javascript files,

npm run lint:code:fix – run lint for typescript / javascript files with auto fix option,

npm run lint:style – run lint for style files,

npm run lint:style:fix – run lint for style files with auto fix option,

npm run test:jest – run Jest tests,

npm run test:jest:watch – run Jest tests with watch mode,

npm run test:jest:coverage – run Jest tests and generate coverage report,

npm run test:cypress – run Cypress tests in terminal,

npm run test:cypress:open – open Cypress application.

💯 Thanks!

Now, don’t be an stranger. Let’s stay in touch!

🔘 linkedin: @LeoLanese

🔘 Twitter: @LeoLanese

🔘 Portfolio: www.leolanese.com

🔘 DEV.to: dev.to/leolanese

🔘 Blog: leolanese.com/blog

🔘 Questions / Suggestion / Recommendation: developer@leolanese.com

NestJS guards for Shopify HMAC verification

This module implements Guards which verifies the HMAC signature of incoming requests from Shopify:

ShopifyAuthGuard – verifies the HMAC signature of incoming Auth requests from Shopify as described in the Shopify documentation and will throw an UnauthorizedException if it is invalid.
ShopifyWebhookGuard – verifies the HMAC signature of incoming Webhook requests from Shopify as described in the Shopify documentation and will throw an UnauthorizedException if it is invalid.

Basic usage with all default

First install this module:

npm i -P @e-mage/nestjs-shopify-guards

Then import module into your Nestjs application and configure it with your app secret:

import { ShopifyGuardsModule } from '@e-mage/nestjs-shopify-guards';

@Module({
    imports: [
        ShopifyGuardsModule.register({
            apiSecretKey: 'my_client_secret',
        }),
    ],
    controllers: [AppController],
    providers: [AppService],
})
export class AppModule {}

And use the guards in your controller:

import { ShopifyAuthGuard, ShopifyWebhookGuard } from '@e-mage/nestjs-shopify-guards';

@Controller()
@UseGuards(ShopifyAuthGuard)
export class AppController {

    // Guard will verify the HMAC signature of the request
    // and will throw an UnauthorizedException if it is invalid
    @UseGuards(ShopifyAuthGuard)
    @Get('/auth')
    getHello(): string {
      return this.appService.getHello();
    }
    
    // Guard will verify the HMAC signature of the request
    // and will throw an UnauthorizedException if it is invalid
    @UseGuards(ShopifyWebhookGuard)
    @Post('/webhook')
    postHello(): string {
      return this.appService.getHello();
    }
}

You can also use the guards with custom options

You can change the default hmac header name or the default hmac query parameter name:

import { ShopifyGuardsModule } from '@e-mage/nestjs-shopify-guards';

@Module({
    imports: [
        ShopifyGuardsModule.register({
            apiSecretKey: 'my_client_secret',
            hmacHeaderName: 'X-My-Shopify-Hmac-Sha256',
            hmacQueryParameterName: 'my-hmac',
        }),
    ],
    controllers: [AppController],
    providers: [AppService],
})
export class AppModule {}

Authentication Package with 2FA

Matondo TwoFactorAuth is a package developed to add two-factor authentication (2FA) to Laravel applications. This package offers a comprehensive authentication process, including login, password reset, two-factor authentication, and other essential features. It provides an easy-to-use interface for enabling 2FA, enhancing security without complicating the authentication flow.

The authentication code is sent via email and SMS, with internationalization support for Portuguese and English. The default language of the application is automatically set based on the configuration in config/app.php (locale). By default, the package comes with Bootstrap-based views for the authentication interface, offering a clean and modern design. However, the package is highly customizable, making it easy to modify the visuals if you need to adjust the design to match your application’s theme or branding. This package stands out compared to other popular packages like Laravel Breeze and Bootstrap by providing two-factor authentication, adding an extra layer of security to application access.

Installation

To install the package, use Composer:

composer require matondo/twofactorauth

Service Provider Registration

After installation, register the TwoFactorAuthServiceProvider in the config/app.php file under the providers section:

'providers' => [
    // Other providers
    Matondo\TwoFactorServiceProvider::class,
],

Publishing Package Files

Next, publish the package’s files with the following command:

php artisan vendor:publish --provider="Matondo\TwoFactorServiceProvider"

Models: Models required for two-factor authentication.
Controllers: Controllers to manage authentication logic.
Middleware: Middleware to protect routes requiring 2FA.
Views: Bootstrap-based views necessary for the authentication process.
Routes: A route file containing new routes for two-factor authentication.

The default authentication views can be easily edited if you want to use a different CSS framework or modify the layout. Simply update the published view files to match your design preferences.

Including Routes

Add the following to your routes/web.php file to include the newly published routes:

require base_path('routes/twofactorauth.php');

Running Migrations

Before running the migrations, ensure that your environment variables are set up correctly in the .env file to avoid database errors. This includes configuring the database connection settings.

Also, configure email settings to ensure that emails can be sent during authentication processes, such as during password resets or 2FA code verification. These settings include:

MAIL_MAILER=smtp
MAIL_HOST=smtp.example.com
MAIL_PORT=587
MAIL_USERNAME=your_username
MAIL_PASSWORD=your_password
MAIL_ENCRYPTION=tls

Once configured, run the following command to migrate the necessary tables:

php artisan migrate

Environment Setup for Redis and Queue

To ensure proper functioning of email and message queuing, configure the following Redis settings in your .env file:

REDIS_CLIENT=predis
BROADCAST_DRIVER=log
CACHE_DRIVER=redis
FILESYSTEM_DISK=redis
QUEUE_CONNECTION=redis
SESSION_DRIVER=redis
SESSION_LIFETIME=120

These settings enable Redis to manage queues, sessions, and cache, improving the performance of the 2FA process.

Twilio SMS Configuration

To send SMS-based authentication codes, configure Twilio in your .env file with the following example credentials (replace with your own Twilio credentials from the Twilio console):

TWILIO_SID=your_twilio_sid
TWILIO_TOKEN=your_twilio_token
TWILIO_FROM=your_twilio_phone_number

To obtain the Account SID, Auth Token, and Twilio phone number, visit the Twilio Console: Go to https://console.twilio.com/.

Middleware Registration

Register the TwoFactorVerify middleware in the app/Http/Kernel.php file under the $routeMiddleware array:

protected $routeMiddleware = [
    // Other middlewares
    '2fa' => \App\Http\Middleware\TwoFactorVerify::class,
];

Using Middleware for Protected Routes

Apply the 2fa middleware to routes that require two-factor authentication:

Route::group(['middleware' => '2fa'], function () {
    Route::get('/home', function () {
        // Dashboard content
    });
});

Internationalization Support

The package supports internationalization (i18n), allowing you to set the locale to either English or Brazilian Portuguese. To change the locale, adjust the app.locale setting in the config/app.php file:

'locale' => 'pt_BR', // Default: en

Important: Running Queues

To ensure that emails and messages are processed efficiently, you should run the command:

php artisan queue:work

If you’re in a testing environment, make sure your server is configured to run queues so that notifications are sent promptly.

Accessing the Login

Once all steps are completed, you can access the /login route to initiate the authentication process. After initial login with credentials, the system sends a 2FA code via SMS, which the user must enter to complete the login process, providing an extra layer of security.

Conclusion

Matondo TwoFactorAuth simplifies the process of adding a full authentication flow to your Laravel application, including features like login, password reset, two-factor authentication, and internationalization. The package also provides a Bootstrap-based UI for authentication that can be easily customized if necessary.

License

This project is licensed under the MIT License. See the LICENSE file for more details.

Get in Touch

LinkedIn: matondojoao | WhatsApp: https://api.whatsapp.com/send?phone=244947224896&text=Hello%21+I+am+interested+in+collaborating+on+projects…
. Feel free to reach out for project collaborations, sharing ideas, or any opportunities to connect!

ADVANCED APPLICATION TEMPLATE

DIRECTORY STRUCTURE

common
    config/              contains shared configurations
    mail/                contains view files for e-mails
    models/              contains model classes used in both backend and frontend
    tests/               contains tests for common classes    
console
    config/              contains console configurations
    controllers/         contains console controllers (commands)
    migrations/          contains database migrations
    models/              contains console-specific model classes
    runtime/             contains files generated during runtime
backend
    assets/              contains application assets such as JavaScript and CSS
    config/              contains backend configurations
    controllers/         contains Web controller classes
    models/              contains backend-specific model classes
    runtime/             contains files generated during runtime
    tests/               contains tests for backend application    
    views/               contains view files for the Web application
    web/                 contains the entry script and Web resources
frontend
    assets/              contains application assets such as JavaScript and CSS
    config/              contains frontend configurations
    controllers/         contains Web controller classes
    models/              contains frontend-specific model classes
    runtime/             contains files generated during runtime
    tests/               contains tests for frontend application
    views/               contains view files for the Web application
    web/                 contains the entry script and Web resources
    widgets/             contains frontend widgets
vendor/                  contains dependent 3rd-party packages
environments/            contains environment-based overrides

INSTALLATION:
- cloning this repository or download zip;
- composer install;
- if neccessary: php init;
- in common\comfig\mail-local.php change database settings
- yii migrate;

login for admin:
email:  admin@admin.com
password: admin1

RedUtils

Distributed Lock Implementation With Redis

Note

For reading the idea and the algorithm behind this, please visit https://dzone.com/articles/distributed-lock-implementation-with-redis

Introduction

RedUtils is a distributed lock and using Redis for storing and expiring locks. It has the following features:

Leased-Based Lock: If any clients crash or restarted abnormally, eventually lock will be free.
Safe: Provided that fsync=always on every Redis instance we have safety even if Redis become unavailable after getting lock.
Auto-Refreshing Lock: A lock that is acquired by the client can be held as long as the client is alive, and the connection is OK.

Getting Started

Requirements

Install Redis or use the following command if you have Docker installed

docker run --name some-redis  -e ALLOW_EMPTY_PASSWORD=yes -p 6379:6379 --rm -it redis

Add the following dependency (Java 8 is required)

<dependency>
    <groupId>com.github.siahsang</groupId>
    <artifactId>red-utils</artifactId>
    <version>1.0.4</version>
</dependency>

How to use it?

Getting the lock with the default configuration. Wait for getting the lock if it is acquired by another thread.

RedUtilsLock redUtilsLock = new RedUtilsLockImpl();
redUtilsLock.acquire("lock1", () -> {
    // some operation
});

Try to acquire the lock and return true after executing the operation, otherwise, return false immediately.

RedUtilsLock redUtilsLock = new RedUtilsLockImpl();
boolean getLockSuccessfully = redUtilsLock.tryAcquire("lock1", () -> {
    // some operation
});

You can also provide configuration when initializing RedUtilsLock

RedUtilsConfig redUtilsConfig = new RedUtilsConfig.RedUtilsConfigBuilder()
            .hostAddress("127.0.0.1")
            .port("6379")
            .replicaCount(3)
            .leaseTimeMillis(40_000)
            .build();

RedUtilsLock redUtilsLock = new RedUtilsLockImpl(redUtilsConfig);

To see more examples please see the tests

Running the tests

For running the tests, you should install Docker(test cases use testcontainer for running Redis). After that you can run all tests with:

mvn clean test

Caveats

There are some caveats that you should be aware of:

I assume clocks are synchronized between different nodes.
I assume there aren’t any long thread pause or process pause after getting lock but before using it.
To achieve strong consistency you should enable the option fsync=always on every Redis instance.
In current implementation, locks is not fair; for example, a client may wait a long time to get the lock and at the same time another client get the lock immediately.

Dependencies

Jedis
Slf4j

Create a Certifcate Authority that can be use to issue certificate for domains.

Sometimes you need https on your local machine to test some functionality of your application, like payment system, but some of them require a valid https. Like stripe. And you can’t use localhost to request a certificate from issuer like Let’s Encrypt, so your option is to create a self signed certificate authority (CA). This tool make it easy.

Just clone this repository by run this command:

git clone git@github.com:madeny/lhttps.git` 
from terminal and do the following:

cd lhttps
composer install
php lh create domain.com

If you wish to add your rootCA.pem to your Mac OS trusted certificate, use the a flag --a right after domain.com like so: php lh create domain.com --a

Your domain.com.ssl.key and domain.com.ssl.crt will be in cert/live directory

Just update your nginx config with

ssl_certificate path/to/domain.com.ssl.crt;
ssl_certificate_key path/to/domain.com.ssl.key;

Right now only OSX and Ubuntu are support to create Certificate But only Mac OSX are support to automatically add your Root Certificate Authority (CA) to the Trusted list

Todo Next:

Full support for ubuntu
Support for Windows
Auto deploy certificate for Nginx
Auto deploy certificate for Apache
Auto deploy certificate for Node.js

Large file parser

This project benchmarks how fast we can parse large csv file
in multiple processes by a multi-core cpu.

Problem definition

Transaction data (withdrawal/deposit) of many assets are stored in a large csv file.
We need to process it to find the balance of all assets on a specific date.

Fileformat

The file contain 300 millions records in this format:

timestamp	transaction_type	token	amount
1571967208	DEPOSIT	BTC	0.298660
1571967189	WITHDRAWAL	ETH	0.493839

Install tools

node (v14.7.0)
npm (v6.14.13)
typescript (v4.3.5)
Resiger for a free api key from https://www.cryptocompare.com/, put to .env file

Executing program

Install dependencies

npm install

Compile typescript to js (or use ts-node)

tsc

Get portfolio for all tokens up to now

  node ./dist/index.js ../transactions.csv

Total transactions 30000000
Duration: 9.750s
{
  "BTC": {
    "balance": 1200425.1521680003,
    "USD": 55015436706.85337
  },
  "XRP": {
    "balance": 903332.9813729969,
    "USD": 740100.7116388964
  },
  "ETH": {
    "balance": 901704.2831249977,
    "USD": 2820954798.6280613
  }
}

Get portfolio for specific token

  node ./dist/index.js ../transactions.csv -t BTC

Total transactions 11995939
Duration: 9.386s
{
  "BTC": {
    "balance": 1200425.1521680003,
    "USD": 54904781516.32652
  }
}

Get portfolio before on a date

 node ./dist/index.js ../transactions.csv -d 1972-10-03

Total transactions 485
Duration: 9.144s
{
  "BTC": {
    "balance": 15.849665999999987,
    "USD": 724653.2278830594
  },
  "XRP": {
    "balance": 9.496016999999993,
    "USD": 7.745901066899994
  },
  "ETH": {
    "balance": 28.11622000000001,
    "USD": 87565.15556800003
  }
}

Get portfolio before a date for specific token

 node ./dist/index.js ../transactions.csv -t ETH -d 1972-10-03

Total transactions 129
Duration: 9.435s
{
  "ETH": {
    "balance": 28.11622000000001,
    "USD": 87710.51642540003
  }
}

Discussion

First naive approach

Simply reading and parsing 1GB of data sequentially, seems not to be a good way.
But I still try to implement a version of singleThreadParser.ts for benchmarking.
I am curious on how fast my M2 SSD can be read by node.js. As in my Experiment/01 folder,
my hardware can read 1GB data in 260ms at best. Most importantly, I also want to benchmark how much buffer size (highWaterMark in nodejs) affects the read/write speed. I found that the default nodejs buffer size 16KB makes the read/write 1GB last at 812ms. If I increase buffer size to 4MB, the duration is reduced to 372ms. All the benchmark results
I put in the Experiments if you are interested in.

Another thing this singleThreadParser script helps me, is that it helps me consider whether to use the readline library from nodejs. I had intended to parse the binary buffer
from fileReadStream directly, gave all hard work code just for speed. Measuring help me find that:

String concatenation is 4 seconds slower than buffer.slice(start, end) when reading buffer (1GB data file).
Manually parsing the line (reading buffer search for “\n”) help gaining 100ms
All those minor optimizations are wasted, when we start calling line.split(‘,’) or any operation to do our business processing line by line.

So those little optimizations are not worth sacrificing the tidiness of code.
Finally I just use the readline package, piping from fileReadStream as source to start processing the file.

Processing 1GB of sample data file takes my hardware 23 seconds.

And I also have the correct output to compare, when developing my multithread script.

Minor experiment on cross-process IO

Before implement my main script, I am curious that what is the speed for sending message
from parent process to child process in node.js. We know that processes in node js use different address space, and nodejs somehow make it easy for us to send messages cross-process. The question is, how much the speed is. Answer is ‘slow’. As in my experiment #03 demonstrate, sending a big message from parent to forked process makes the program take 38 seconds for just reading a file, without any useful processing.

File segmentation and process parallel

The business processing logic in this project makes it easy to implement parallel programs. It is just adding and subtracting. We can divide the large file into
multiple segments. Then fork multiple processes, on each CPU core, to process one segment.

Nodejs createReadStream() has the parameters ‘start’ and ‘end’ for us to specify the start and end reading position. We utilize it to let each child process read file stream from ‘start’ to ‘end’ position. Note that this approach is only reasonable when the harddrive has good random access support, such as SSD. If harddrive is magnetic, which is sequential access, although not benchmarking, but I guess the performance is not gained much by this approach.

After each child process finishes a file segment, it sends back the result to the parent process.
Parent process will sum up all the results to produce the final portfolio.

One big challenge here in this approach, is that the segmentation may cut into the transaction line.
1571966685,DEPOSIT,BTC,0.658794 can be splitted to 1571966685,DEPOS and IT,BTC,0.658794 in the previous and next segment. We need to carefully connect last line of segment #1 to the first line of segment #2. And we also need to handle the case when the cut is perfectly cut to the character ‘\n’.

My hardware can parse this same 1GB data in ~9.8 seconds.

A better approach (?)

In production project, I would add column balance into dataset, and use some kind of
data indexing to help query for balance on a specific date quickly. We can use any DBMS such as Sqlite, MySQL, MongoDB, DynamoDB.. they all can create index to timestamp column efficiently, help querying a record on a specific date at speed of O(1). If we want, we can manually create an index by ourselves, using B-tree or similar data structure to access sequential data such as timestamp quickly.
That way we are trading storage cost for speed. Provided that storage cost is cheap nowaday, the gain is worth it.

Storing an accumulated balance column has one drawback. Floating point numbers are inaccurate. Accumulating a long list of floating point numbers may cause precision problems.
And we need to schedule a run for number consolidation sometimes.

Using a dbms or creating an extra index file is out of scope of this project, so I did not implement it here.

FAST Anime VSRR (Video Super-Resolution and Restoration)

This repository is dedicated to enhancing the Super-Resolution (SR) inference process for Anime videos by fully harnessing the potential of your GPU. It is built upon the foundations of Real-CuGAN (https://github.com/bilibili/ailab/blob/main/Real-CUGAN/README_EN.md) and Real-ESRGAN (https://github.com/xinntao/Real-ESRGAN).

I’ve implemented the SR process using TensorRT, incorporating a custom frame division algorithm designed to accelerate it. This algorithm includes a video redundancy jump mechanism, akin to video compression Inter-Prediction, and a momentum mechanism.

Additionally, I’ve employed FFMPEG to decode the video at a reduced frames-per-second (FPS) rate, facilitating faster processing with an almost imperceptible drop in quality. To further optimize performance, I’ve utilized both multiprocessing and multithreading techniques to fully utilize all available computational resources.

For a more detailed understanding of the implementation and algorithms used, I invite you to refer to this presentation slide: https://docs.google.com/presentation/d/1Gxux9MdWxwpnT4nDZln8Ip_MeqalrkBesX34FVupm2A/edit#slide=id.p.

In my 3060Ti Desktop version, it can process in Real-Time on 480P Anime videos input (Real-CUGAN), which means that as soon as you finish watching one Anime video, the second Anime Super-Resolution (SR) video is already processed and ready for you to continue watching with just a simple click..

Currently, this repository supports Real-CUGAN (official) and a shallow Real-ESRGAN (6 blocks Anime Image version RRDB-Net provided by Real-ESRGAN).

My ultimate goal is to directly utilize decode information in Video Codec as in this paper (https://arxiv.org/abs/1603.08968), so I use the word “FAST” at the beginning. Though this repository can already process in real-time, this repository will be continuously maintained and developed.

If you like this repository, you can give me a star (if you are willing). Feel free to report any problem to me.

Visual Improvement (Real-CUGAN)

Before:

After 2X scaling:

Model supported now:

Real-CUGAN: The original model weight provided by BiliBili (from https://github.com/bilibili/ailab/tree/main)
Real-ESRGAN: Using Anime version RRDB with 6 Blocks (full model has 23 blocks) (from https://github.com/xinntao/Real-ESRGAN/blob/master/docs/model_zoo.md#for-anime-images–illustrations)
VCISR: A model I trained with my upcoming paper methods using Anime training datasets (https://github.com/Kiteretsu77/VCISR-official)

Supported Devices and Python Version:

Nvidia GPU with Cuda (Tested: 2060 Super, 3060Ti, 3090Ti, 4090)
Tested on Python 3.10

Installation (Linux – Ubuntu)：

Skip step 3 and 4 if you don’t want tensorrt, but they can increase the speed a lot & save a lot of GPU memory.

Install CUDA. The following is how I install:
- My Nvidia Driver in Ubuntu is installed by Software & Updates of Ubuntu (Nvidia server driver 525), and the cuda version in nvidia-smi is 12.0 in default, which is the driver API.
- Next, I install cuda from the official website (https://developer.nvidia.com/cuda-12-0-0-download-archive?target_os=Linux&target_arch=x86_64&Distribution=Ubuntu&target_version=22.04&target_type=runfile_local). I install 12.0 version because it’s said that the runtime API should be older than driver API cuda (12.0 in nvidia-smi). I use runfile(local) to install because that is the easiest option.
  During the installation, Leave driver installation ([] Driver [] 525.65.01) blank. Avoid dual driver installation.
- After finishing the cuda installation, we need to add their path to the environment
```
    gedit ~/.bashrc
    // Add the following two at the end of the popped up file (The path may be different, please double check)
    export PATH=/usr/local/cuda-12.0/bin${PATH:+:${PATH}}
    export LD_LIBRARY_PATH=/usr/local/cuda-12.0/lib64${LD_LIBRARY_PATH:+:${LD_LIBRARY_PATH}}
    // Save the file and execute the following in the terminal
    source ~/.bashrc
```
- You should be capable to run “nvcc –version” to know that cuda is fully installed.
Install CuDNN. The following is how I install:
- I downloaded it from the official website (https://developer.nvidia.com/rdp/cudnn-download). Usually, Tar version (Linux x86_64 (Tar)) is preferred.
- Then, give the permisions by the following :
```
    cd /usr/local/cuda
    sudo chmod 666 include
```
- Follow https://docs.nvidia.com/deeplearning/cudnn/install-guide/index.html#installlinux-tar to decompress folder and copy file to the desired location
Install tensorrt
- Download tensorrt 8.6 from https://developer.nvidia.com/nvidia-tensorrt-8x-download (12.0 Tar pacakge is preferred)
- Follow https://docs.nvidia.com/deeplearning/tensorrt/install-guide/index.html#installing-tar to install several wheels.
  Step4 of this website is like below (Don’t forget to replace YOUR_USERNAME to your home address):
```
    gedit ~/.bashrc
    // Add the following at the end of the popped up file (The path may be different, please double check)
    export LD_LIBRARY_PATH=/home/YOUR_USERNAME/TensorRT-8.6.1.6/lib${LD_LIBRARY_PATH:+:${LD_LIBRARY_PATH}}
    // Save the file and execute the following in the terminal
    source ~/.bashrc
```
- After finishing these steps, you should be able to “import tensorrt” in python (starts a new window to run this)
Install torch2trt (Don’t directly use pip install torch2trt)
- Follow https://nvidia-ai-iot.github.io/torch2trt/v0.4.0/getting_started.html (I install WITHOUT plugins)\
- After installing it, you should be able to run “import torch2trt” in python (start a new window to run this)
Install basic libraries for python
```
    pip install -r requirements.txt
```
- Install pytorch: please go to https://pytorch.org/get-started/locally/ to install separately based on your needs

Installation (Windows)：

Skip step 3 and 4 if you don’t want tensorrt, but they can increase the speed a lot & save a lot of GPU memory.

Install CUDA (e.g. https://developer.nvidia.com/cuda-downloads?)
Install Cudnn (move bin\ & include\ & lib\ so far is enough)
Install tensorrt (Don’t directly use python install)
- Please strictly Follow https://docs.nvidia.com/deeplearning/tensorrt/install-guide/index.html#installing-zip
- After finishing these steps, you should be able to “import tensorrt” in python (starts a new window to run this)
- Don’t forget to add PATH to environmental variables based on their requirement.
- Step 6 (Visual Studio Verification) in the document is not very needed.
Install torch2trt (Don’t directly use pip install torch2trt)
- Follow https://nvidia-ai-iot.github.io/torch2trt/v0.4.0/getting_started.html (I install Without plugins)
- In some rare cases, you may neeed to “pip install packaging” before executing its commands.
- After installing it, you should be able to run “import torch2trt” in python (start a new window to run this)
Install basic libraries for python
```
    pip install -r requirements.txt
```
- For Pytorch, please go to https://pytorch.org/get-started/locally/ to install seperately for your need

Run (Inference):

Adjust config.py to setup your setting. Usually, just editing Frequently Edited Setting part is enough. Please follow the instructions there.
- Edit process_num, full_model_num, nt to match your GPU’s computation power.
- The input (inp_path) can be a single video input or a folder with a bunch of videos (video format can be various as long as they are supported by ffmpeg); The output is mp4 format in default.
Run
```
     python main.py
```
- The original cunet weight should be automatically downloaded and tensorrt transformed weight should be generated automatically based on the video input height and weight.
- Usually, if this is the first time you transform to a tensorrt weight, it may need to wait for a while for the program to generate tensorrt weight.
- If the input source has any external subtitle, it will also be extracted automatically and sealed back to the processed video at the end.

Future Works:

Debug use without TensorRT && when full_model_num=0
MultiGPU inference support
Provide PSNR && Visual Quality report in README.md
Provide all repositories in English.
Record a video on how to install TensorRT from scratch.

Disclaimer:

The sample image under tensorrt_weight_generator is just for faster implementation, I don’t have a copyright for that one. All rights are reserved to their original owners.
My code is developed from Real-CUGAN github repository (https://github.com/bilibili/ailab/tree/main/Real-CUGAN)