Forem: Maksudul Haque

Auto Index and Search Django Model Instances with RediSearch (using redis-search-django)

Maksudul Haque — Sun, 21 Aug 2022 14:52:00 +0000

Overview of My Submission

I built an Installable Django Package called redis-search-django as a part of Redis Hackathon on DEV. redis-search-django is a Django package that provides auto indexing and searching capabilities for Django Model instances using RediSearch.

redis-search-django internally uses redis-om-python and redis-py

redis-search-django is Available on Python Package Index (PyPI): https://pypi.org/project/redis-search-django/

You can install it by running: pip install redis-search-django

Features

Management Command to create, update and populate the RediSearch Index.
Auto Index on Model object Create, Update and Delete.
Auto Index on Related Model object Add, Update, Remove and Delete.
Easy to create Document classes (Uses Django Model Form Class like structure).
Index nested models (e.g: OneToOneField, ForeignKey and ManyToManyField).
Search documents using redis-om.
Search Result Pagination.
Search Result Sorting.
RediSearch Result to Django QuerySet.
Faceted Search.

Submission Category:

Wacky Wildcards Or, Microservice Mavens
(Because a Django Package does not fit into other Categories)

Language Used

Python

Link to Code

Django Package Repository:

saadmk11 / redis-search-django

Django package that provides auto indexing and searching capabilities for Django model instances using RediSearch.

redis-search-django

About

A Django package that provides auto indexing and searching capabilities for Django model instances using RediSearch.

Features

Management Command to create, update and populate the RediSearch Index.
Auto Index on Model object Create, Update and Delete.
Auto Index on Related Model object Add, Update, Remove and Delete.
Easy to create Document classes (Uses Django Model Form Class like structure).
Index nested models (e.g: OneToOneField, ForeignKey and ManyToManyField).
Search documents using redis-om.
Search Result Pagination.
Search Result Sorting.
RediSearch Result to Django QuerySet.
Faceted Search.

Requirements

Python: 3.7, 3.8, 3.9, 3.10
Django: 3.2, 4.0, 4.1
redis-om: >= 0.0.27

Redis

Downloading Redis

The latest version of Redis is available from Redis.io. You can also install Redis with your operating system's package manager.

RediSearch and RedisJSON

redis-search-django relies on the RediSearch and RedisJSON Redis modules to support rich queries and embedded models You need these Redis…

View on GitHub

Demo App Repository:
(README file contains the details as per Hackathon Requirements)

saadmk11 / try-redis-search-django

Auto Index and Search Django Model Instances with RediSearch (using `redis-search-django`)

Description

I built an Installable Django Package called redis-search-django as a part of Redis Hackathon on DEV redis-search-django is a package that provides auto indexing and searching capabilities for Django model instances using RediSearch.

This is a Demo App that uses redis-search-django package to Showcase a Product Search Engine with auto indexing and searching.

redis-search-django Documentation: https://github.com/saadmk11/redis-search-django

Features

Management Command to create, update and populate the RediSearch Index.
Auto Index on Model object Create, Update and Delete.
Auto Index on Related Model object Add, Update, Remove and Delete.
Easy to create Document classes (Uses Django Model Form Class like structure).
Index nested models (e.g: OneToOneField, ForeignKey and ManyToManyField).
Search documents using redis-om.
Search Result Pagination.
Search Result Sorting.
RediSearch Result to Django QuerySet.
Faceted Search.

App Architecture Diagram

App Screenshot

How it

…

View on GitHub

Additional Resources / Info

Architecture Diagram

How to use it

Create Search Document from Django Model. (Using redis-search-django)

1. For Django Model:

# models.py

from django.db import models


class Category(models.Model):
    name = models.CharField(max_length=32)
    slug = models.SlugField(max_length=64)

    def __str__(self) -> str:
        return self.name

2. You can create a document class like this:

# documents.py

from redis_search_django.documents import JsonDocument

from .models import Category


class CategoryDocument(JsonDocument):
    class Django:
        model = Category
        fields = ["name", "slug"]

3. Run Django Management Command Index to create the index on Redis (Only need to run once to generate Index Schema on Redis):

python manage.py index

Note: This will also populate the index with existing data from the database

Now category objects will be indexed automatically using Redis on create/update/delete events.

More Complex Examples Can be found here: https://github.com/saadmk11/redis-search-django

Screenshot of the Demo App:

Check out Redis OM, client libraries for working with Redis as a multi-model database.
Use RedisInsight to visualize your data in Redis.
Sign up for a free Redis database.

Visually Review HTML file changes introduced on a Pull Request with Comment Webpage Screenshot GitHub Action

Maksudul Haque — Sun, 21 Nov 2021 14:22:56 +0000

My Workflow

Comment Webpage Screenshot is a GitHub Action that captures screenshots of webpages and HTML files located in the repository, uploads them to an Image Upload Service and comments the screenshots on the pull request that triggered the action.

This action helps maintainers visually review HTML file changes introduced on a Pull Request by adding comments with the screenshots of the latest HTML file changes on the Pull Request

Submission Category:

Maintainer Must-Haves

Yaml File or Link to Code

Here are the links for Comment Webpage Screenshot

GitHub repository:

saadmk11 / comment-webpage-screenshot

A GitHub Action that Helps to Visually Review HTML file changes on a Pull Request by adding comments with the screenshots of the HTML file changes on the PR

Comment Webpage Screenshot

Comment Webpage Screenshot is a GitHub Action that captures screenshots of web pages and HTML files located in the repository uploads them to an Image Upload Service and comments the screenshots on the pull request that triggered the action.

Note: This Action Only Works on Pull Requests.

Workflow inputs

These are the inputs that can be provided on the workflow.

Name	Required	Description	Default
`upload_to`	No	Image Upload Service Name (Options are: `github_branch`, `imgur`) More Details	`github_branch`
`capture_changed_html_files`	No	Enable or Disable Screenshot Capture for Changed HTML Files on the Pull Request (Options are: `yes`, `no`)	`yes`
`capture_html_file_paths`	No	Comma Seperated paths to the HTML files to be captured (Example: `/pages/index.html, about.html`)	`null`
`capture_urls`	No	Comma Seperated URLs to be captured (Example: `https://dev.example.com, https://dev.example.com/about.html`)	`null`
`github_token`	No	`GITHUB_TOKEN` provided by the workflow run or Personal Access Token (PAT)	`github.token`

Example Workflow

…

View on GitHub

Marketplace:
https://github.com/marketplace/actions/comment-webpage-screenshot

Additional Resources / Info

Example: Capture Screenshots for Static HTML Pages built with TailwindCSS

If your repository contains only static files and does not require a server. You can just put the file path of the HTML files you want to capture screenshot of.

In this Example I'll show you how I used saadmk11/comment-website-screenshot GitHub Action to Visually Review Static file Changes.

WorkFlow:

name: Capture Webpage Screenshot

on:
  pull_request:
    types: [opened, synchronize]

jobs:
  build:
    runs-on: ubuntu-latest

    steps:
      - uses: actions/checkout@v2

      - name: Capture Webpage Screenshot
        uses: saadmk11/comment-website-screenshot@v0.5
        with:
          upload_to: github_branch
          # Capture Screenshots of Changed HTML Files
          capture_changed_html_files: yes
          # Comma separated paths to any other HTML File
          capture_html_file_paths: "index.html"

Output Screenshot:

The HTML Template Shown in this Example was Taken from Tailwind UI
Tailwind UI Provides Awesome Pre-Built TailwindCSS Components. Check them out here: https://tailwindui.com/

Example Pull Request: https://github.com/saadmk11/static-page-screenshot-demo/pull/2

Demo Repository:

saadmk11 / static-page-screenshot-demo

static-page-screenshot-demo

Templates Collected from Tailwind UI.

Check it out here: https://tailwindui.com/

View on GitHub

Note

You can also use this for Dynamic Web Applications. See the saadmk11/comment-webpage-screenshot documentation for more examples.

Conclusion

I think this action will be really helpful for Open Source Maintainers to provide quick reviews on UI changes. If anyone is interested please try saadmk11/comment-webpage-screenshot out and leave some feedback :)

GitHub Actions Version Updater, Similar to GitHub's Dependabot, but for GitHub Actions

Maksudul Haque — Thu, 08 Apr 2021 16:42:06 +0000

GitHub Actions Version Updater is GitHub Action that Updates Other GitHub Actions in a Repository and creates a pull request with those updates. It is an automated dependency updater similar to GitHub's Dependabot, but for GitHub Actions.

How Does It Work:

GitHub Actions Version Updater first goes through all the workflows
in a repository and checks for updates for each of the actions used in those workflows.
If an update is found and if that action is not ignored then the workflows are updated
with the latest release of the action being used.
If at least one workflow file is updated then a new branch is created with the changes and pushed to GitHub.
Finally, a pull request is created with the newly created branch.

GitHub repository:

saadmk11 / github-actions-version-updater

A GitHub Action that Updates All GitHub Actions in a Repository and Creates a Pull Request with the Updates

GitHub Actions Version Updater

GitHub Actions Version Updater is a GitHub Action that is used to Update All GitHub Actions in a Repository and create a pull request with the updates (if enabled) It is an automated dependency updater similar to GitHub's Dependabot but for GitHub Actions.

How Does It Work?

GitHub Actions Version Updater first goes through all the workflows in a repository and checks for updates for each of the action used in those workflows.
If an update is found and if that action is not ignored then the workflows are updated with the new version of the action being used.
If at least one workflow file is updated then a new branch is created with the changes and pushed to GitHub. (If enabled)
Finally, a pull request is created with the newly created branch. (If enabled)

Supported Version Fetch Sources

release-tag (default): Uses specific release tag from…

View on GitHub

Marketplace:

https://github.com/marketplace/actions/github-actions-version-updater

Usage:

We recommend running this action on a schedule event or a workflow_dispatch event.

To integrate GitHub Actions Version Updater on your repository, create a YAML file inside .github/workflows/ directory (.github/workflows/updater.yaml) add the following into the file:

name: GitHub Actions Version Updater

# Controls when the action will run. 
on:
  # can be used to run workflow manually
  workflow_dispatch:
  schedule:
    # Automatically run on every Sunday
    - cron:  '0 0 * * 0'

jobs:
  build:
    runs-on: ubuntu-latest

    steps:
      - uses: actions/checkout@v2
        with:
          # Access token with `workflow` scope is required
          token: ${{ secrets.WORKFLOW_SECRET }}

      - name: Run GitHub Actions Version Updater
        uses: saadmk11/github-actions-version-updater@v0.5.6
        with:
          # Access token with `workflow` scope is required
          token: ${{ secrets.WORKFLOW_SECRET }}
          # Do not update these actions (Optional)
          # You need to add JSON array inside a string
          # because GitHub Actions does not yet allow `Lists` as input
          ignore: '["actions/checkout@v2", "actions/cache@v2"]'

Important Note:

GitHub does not allow updating workflow files inside a workflow run. The token generated by GitHub in every workflow (${{secrets.GITHUB_TOKEN}}) does not have permission to update a workflow. That's why you need to create a Personal Access Token
with repo and workflow scope and pass it to the action.

To know more about how to pass a secret to GitHub actions you can Read GitHub Docs

GitHub Actions Version Updater in Action:

Pull Request Created by GitHub Actions Version Updater:

Pull Request File Changes:

Conclusion

I think this will be really helpful for Open Source Maintainers to manage GitHub actions dependencies. If anyone is interested please try GitHub Actions Version Updater out and leave some feedback :)

If you have any questions you can reach out to me on Twitter @saad_mk11

Changelog CI (Commit and/or Comment Auto-generated Changelog to PR using Actions)

Maksudul Haque — Thu, 03 Sep 2020 06:40:33 +0000

My Workflow

I have created my first Open Source GitHub Action called Changelog CI.
This is a GitHub Action that generates changelog, prepends it to CHANGELOG.md file, and commits and/or comments it to the release pull request.

Live Example: Changelog CI's Changelog

Submission Category:

Maintainer Must-Haves

Yaml File or Link to Code

Here are the links for Changelog CI

GitHub repository:

saadmk11 / changelog-ci

Changelog CI is a GitHub Action that enables a project to automatically generate changelogs

What is Changelog CI?

Changelog CI is a GitHub Action that enables a project to automatically generate changelogs.

Changelog CI can be triggered on pull_request, workflow_dispatch and any other events that can provide the required inputs Learn more about events that trigger workflows

The workflow can be configured to perform any (or all) of the following actions:

For pull_request event:
- Generates changelog using Pull Request Titles or Commit Messages made after the last release.
- Prepends the generated changelog to the CHANGELOG.md/CHANGELOG.rst file.
- Then Commits the modified CHANGELOG.md/CHANGELOG.rst file to the release pull request branch.
- Adds a Comment on the release pull request with the generated changelog.
For other events:
- Generate changelog using Pull Request Title or Commit Messages made after the last release.
- Prepends the generated changelog to the CHANGELOG.md/CHANGELOG.rst file.
- Then Creates a Pull Request with the CHANGELOG.md/CHANGELOG.rst file changes.

…

View on GitHub

Marketplace:

https://github.com/marketplace/actions/changelog-ci

Additional Resources / Info

Changelog CI is a new open-source action, as of now, my open-source projects use it.

For example, django-newsfeed and banking-system uses it.
This output was created using changelog-ci CHANGELOG.md

Changelog CI itself uses this Action to generate Changelog.

How Does It Work:

Changelog CI uses python and GitHub API to generate a changelog for a repository.
First, it tries to get the latest release from the repository (If available).
Then, it checks all the pull requests merged after the last release using the GitHub API. After that, it parses the data and generates the changelog. Finally, It writes the generated changelog at the beginning of the CHANGELOG.md (or user-provided filename) file. In addition to that, if a user provides a config (JSON file), Changelog CI parses the user-provided config file and renders the changelog according to users config. Then the changes are committed and/or commented on the release Pull request.

Usage:

To use this Action The pull request title must match with the default regex or the user-provided regex from the config file.

Default title regex: ^(?i)release (title must start with the word "release" (case insensitive))

Default version number regex: This follows SemVer (Semantic Versioning) pattern. e.g. 1.0.0, 1.0, v1.0.1 etc.

For more details on Semantic Versioning pattern go to this link: https://regex101.com/r/Ly7O1x/3/

Note: you can provide your own regex through the config file

Example Workflow Using Changelog CI

name: Changelog CI

# Controls when the action will run. Triggers the workflow on pull request
on:
  pull_request:
    types: [opened, reopened]

jobs:
  build:
    runs-on: ubuntu-latest

    steps:
      # Checks-out your repository
      - uses: actions/checkout@v2

      - name: Run Changelog CI
        uses: saadmk11/changelog-ci@v0.5.0
        with:
          # Optional, you can provide any name for your changelog file.
          # defaults to ``CHANGELOG.md`` if not provided.
          changelog_filename: CHANGELOG.md
          # Optional, only required when you want more customization
          config_file: changelog-ci-config.json
        env:
          # Optional, Only required for ``private`` repositories
          # and required if the changelog comment 
          # option is turned on through the config file
          GITHUB_TOKEN: ${{secrets.GITHUB_TOKEN}}

Changelog CI Badge:

Add this to your README to display the badge:

![Changelog CI Status](https://github.com/<username>/<repo_name>/workflows/Changelog%20CI/badge.svg)

Example Changelog Output using config file:

Learn more about config file for Changelog CI
from the README.md

Version: 0.0.2

Bug Fixes

#53: Keep updating the readme
#54: Again updating the Same Readme file :(

New Features

#68: Update README.md

Documentation Updates

#66: Docs update

Version: 0.0.1

Bug Fixes

#53: Keep updating the readme
#54: Again updating the Same Readme file :(

Documentation Updates

#66: Docs update

Example Changelog Output without using config file:

Version: 0.0.2

#53: Keep updating the readme
#54: Again updating the Same Readme file :(
#55: README update

Version: 0.0.1

#43: It feels like testing never ends :(
#35: Testing again and again
#44: This is again another test, getting tired
#37: This is again another test

Changelog CI in Action (Comment & Commit)

Conclusion

I think this will be really helpful for Open Source Maintainers. If anyone is interested please try Changelog CI out and leave feedback :)

Create a News-Curator and News Subscription App using Django

Maksudul Haque — Wed, 26 Aug 2020 17:31:50 +0000

I have recently released a django package named django-newsfeed.
This makes it really easy to build a news curator and newsletter subscription website.

Today I'm going to show you how to easily create a news curator website or
add a newsfeed subscription service to your existing website.

Requirements:

Django >= 2.2
django-newsfeed
celery
celery-beat
redis

Setup Project:

Lets get started

Create Virtualenv and install requirements:

$ mkvirtualenv example-newsfeed     # you can use virtualenv instead of virtualenvwrapper
$ mkdir django-newsfeed
$ cd django-newsfeed/

$ pip install celery Django django-celery-beat django-newsfeed redis

** You need to have redis installed in your system. Here is a guide

Setup django:

$ django-admin.py startproject example_newsfeed .    # dot (.) is added to create project on current directory
$ python manage.py migrate

Now add newsfeed and celery-beat to installed apps.

INSTALLED_APPS = [
    ...
    'django_celery_beat',
    'newsfeed',
]

Add django-newsfeed urls to project urls.py.

urlpatterns = [
    ...
    path('newsfeed/', include('newsfeed.urls', namespace='newsfeed')),
    ...
]

Create superuser and Run Django Development Server

$ python manage.py createsuperuser
$ python manage.py runserver       # http://127.0.0.1:8000/

Go to Django Admin Page, login and create Posts, Issues and Newsletters.

Now You can navigate to:

latest_issue: newsfeed/
issue_list: newsfeed/issues/
issue_detail: newsfeed/issues/<slug:issue_number>/
newsletter_subscribe: newsfeed/subscribe/
newsletter_subscription_confirm: newsfeed/subscribe/confirm/<uuid:token>/
newsletter_unsubscribe: newsfeed/unsubscribe/

Override Templates to your liking. To learn more about it click here Here is the code for this tutorial. You can see the overridden templates here. It uses bootstrap to style the templates.

Setup Sending Newsletters:

Now that the project is set up we can create celery task to send newsletters.

Configure Celery

Setup celery from here.
Add celery settings for redis to settings.py

# Celery Settings
CELERY_BROKER_URL = 'redis://localhost:6379'
CELERY_RESULT_BACKEND = 'redis://localhost:6379'
CELERY_ACCEPT_CONTENT = ['application/json']
CELERY_TASK_SERIALIZER = 'json'
CELERY_RESULT_SERIALIZER = 'json'
CELERY_TIMEZONE = TIME_ZONE

Add Email settings to settings.py

# Email Settings
EMAIL_HOST = 'test_host'
EMAIL_HOST_USER = 'test_user'
EMAIL_HOST_PASSWORD = 'test_password'
EMAIL_PORT = 587
EMAIL_USE_TLS = True
EMAIL_BACKEND = 'django.core.mail.backends.console.EmailBackend'

** Change this for production server django reference

Create a django app named core

$ python manage.py startapp core

Now add core to installed apps.

INSTALLED_APPS = [
    ...
    'core',
]

Create tasks.py file in the core app directory. Paste this code in the file.

from celery.decorators import task

from newsfeed.models import Newsletter
from newsfeed.utils.send_newsletters import send_email_newsletter


@task(name="send_email_newsletter_task")
def send_email_newsletter_task(newsletters_ids=None, respect_schedule=True):
    newsletters = None

    if newsletters_ids:
        newsletters = Newsletter.objects.filter(
            id__in=newsletters_ids
        )
    send_email_newsletter(
        newsletters=newsletters,
        respect_schedule=respect_schedule
    )

** This will enable you to call the EmailNewsletterSender provided by django-newsletter
in a celery task.

Now you can send newsletters from the django admin page.

Add this code to the celery.py file on your project directory. (celery.py file should be created following the step 3)

app.conf.beat_schedule = {
    'send_email_newsletter': {
        'task': 'send_email_newsletter_task',
        # http://docs.celeryproject.org/en/latest/userguide/periodic-tasks.html
        # run this task every hour
        'schedule': crontab(minute=0, hour='*'),
    }
}

** This will schedule sending newsletters every hour.
Now you can send scheduled newsletters to all the subscribers autometically using this scheduled task.

Add this code to the admin.py file on the core app directory.

from django.contrib import admin, messages

from newsfeed.admin import NewsletterAdmin
from newsfeed.models import Newsletter

from .tasks import send_email_newsletter_task

admin.site.unregister(Newsletter)


@admin.register(Newsletter)
class NewsletterAdmin(NewsletterAdmin):

    def send_newsletters(self, request, queryset):
        newsletter_ids = list(queryset.values_list('id', flat=True))

        send_email_newsletter_task.delay(
            newsletters_ids=newsletter_ids,
            respect_schedule=False
        )
        messages.add_message(
            request,
            messages.SUCCESS,
            'Sending selected newsletters(s) to the subscribers',
        )

** This will override the admin action for sending newsletters to use celery task.

Source Code for this tutorial here: https://github.com/saadmk11/test-django-newsfeed

Video Demo:

You can learn more about all the configuration for django-newsfeed on github.

Checkout the package from here: django-newsfeed

Conclusion:

If you use this package please feel free to provide some feedback on twitter
or on the comment section.
If you have any suggestion or want to contribute to this package
please create an issue
and read the contribution guide.

Feedback and Contribution is always welcome.

How I Use GitHub Actions to Keep My Resume Up to date Using Scheduled Events

Maksudul Haque — Wed, 12 Aug 2020 12:36:31 +0000

GitHub Actions (Scheduled Events)

GitHub Actions lets you run your workflows on a schedule.
If you add the example code below in your GitHub Workflow you will see that your workflow will run every 15 minutes.

on:
  schedule:
    # * is a special character in YAML so you have to quote this string
    - cron:  '*/15 * * * *'

i.e: The shortest interval you can run scheduled workflows is once every 5 minutes.
more details on scheduled events here:
https://docs.github.com/en/actions/reference/events-that-trigger-workflows#scheduled-events

Setup GitHub Actions:

Create a .yaml file here <project_dir>/.github/workflows/update_resume.yaml

paste this code in the created file:

name: Update My Resume

on:
  push:
    branches:
      - master
  schedule:
    - cron:  '0 */15 * * *'

jobs:

  build:
    runs-on: ubuntu-latest

    steps:
      - name: Checkout Code
        uses: actions/checkout@v2

      - name: Setup Python Environment
        uses: actions/setup-python@v2
        with:
          python-version: 3.7

      - name: Install Requirements
        run: pip install -r requirements.txt

      - name: Execute Python script
        run: |
          python scripts/update.py

      - name: setup git config
        run: |
          git config user.name ${{ secrets.USERNAME }}
          git config user.email ${{ secrets.EMAIL }}

      - name: commit changes
        run: |
          chmod +x ./scripts/commit.sh
          ./scripts/commit.sh

Here the workflow will run on push events and also run automatically in every 15 minutes.

We are running the workflow on ubuntu-latest image.

In the first step github will checkout the code

 - name: Checkout Code
   uses: actions/checkout@v2

In the second step github will setup python 3.7

 - name: Setup Python Environment
   uses: actions/setup-python@v2
   with:
     python-version: 3.7

In the third step github will install the requirements using pip
I'm using the requests package on send request to the GitHub API.
If you don't need any external packages you can skip this.

 - name: Install Requirements
   run: pip install -r requirements.txt

In this step github will execute scripts/update.py.
Don't worry we haven't created the python script yet. More on this later.

 - name: Execute Python script
   run: |
     python scripts/update.py

In this step github will setup the git config. you can go to https://github.com/<your_username>/<your_repository_name>/settings/secrets/new to create secrets (USERNAME, EMAIL).
This username and email will be used on the git commit.

 - name: setup git config
   run: |
     git config user.name ${{ secrets.USERNAME }}
     git config user.email ${{ secrets.EMAIL }}

In this step github will commit the changes to your repository.
We will create the /scripts/commit.sh file in the next step.

 - name: commit changes
   run: |
     chmod +x ./scripts/commit.sh
     ./scripts/commit.sh

Create Commit Script:

Create a file here <project_dir>/scripts/commit.sh

paste this code in the created file:

#!/bin/bash

git add . 
git commit -m "Updated Repository data"
git push origin master

This is just a shell script which will push a new commit to your repository.

Create Json File:

this Json file will be updated using the update.py file that we will create later.

Create a file here <project_dir>/repo_data.json

paste this code in the created file:

[
    {
        "full_name": "readthedocs/readthedocs.org",
        "url": "https://github.com/readthedocs/readthedocs.org"
    },
    {
        "full_name": "saadmk11/banking-system",
        "url": "https://github.com/saadmk11/banking-system"
    }
]

Here I adding the open source projects that I have contributed to. We will update this file to
to show the correct number of starts, forks, watchers for each repository and update the description of the repository.

Create Python Script:

Create a file here <project_dir>/scripts/update.py

paste this code in the created file:

import json

import requests


def get_repositories_data(data):
    new_data = []

    for repo in data:

        repo_name = repo['full_name']

        url = f'https://api.github.com/repos/{repo_name}'
        response = requests.get(url)

        response_data = response.json()

        repo.update({
            "short_description": response_data['description'],
            "stars": response_data['stargazers_count'],
            "forks": response_data['forks_count'],
            "watchers": response_data['watchers_count']
        })
        new_data.append(repo)

    return new_data


def update_json_file():
    with open('repo_data.json', 'r') as json_file:
        data = json.load(json_file)
        updated_data = get_repositories_data(data)

    with open('repo_data.json', 'w') as json_file:
        json_file.write(json.dumps(updated_data, indent=4))


if __name__ == '__main__':
    update_json_file()

This script will send GET request to the GitHub API and get the latest updates of the repositories that I listed in the Json file and update the repo_data.json file to show the current number of starts, watchers and forks and update the description.

Create the requirements.txt file here <project_dir>/requirements.txt and add requests==2.24.0 in it.

Create `HTML` and `JS` File to Load The JSON Data:

Create a file here <project_dir>/index.html

Add this code in the created file:

<!DOCTYPE html>

<html lang="en">
    <head>
        <meta charset="utf-8" />
        <title>My Resume</title>
    </head>
    <body>
        <div id="openSourceRepos"></div>
        <script src="main.js"></script>
    </body>
</html>

** This is just to show the example you can style and design your resume any way you like.

Create a file here <project_dir>/main.js

Add this code in the created file:

function getJSON(url, callbackFunction) {
    var xmlhttp = new XMLHttpRequest();
    xmlhttp.onreadystatechange = function() {
        if (xmlhttp.readyState == 4 && xmlhttp.status == 200) {
            try {
                var responseData = JSON.parse(xmlhttp.responseText);
            } catch(error) {
                return;
            }
            callbackFunction(responseData);
        }
    };

    xmlhttp.open("GET", url, true);
    xmlhttp.send();
}


document.addEventListener('DOMContentLoaded', (event) => {
    var container = document.getElementById("openSourceRepos");

    getJSON('repo_data.json', function(data) {
        data.forEach(function (repo) {
            var child = `
                <div>
                  <h2>
                      <a href='${repo.url}'>${repo.full_name}</a>
                  </h2>
                   <p>${repo.short_description}</p>
                   <ul>
                       <li>${repo.stars}</li>
                       <li>${repo.forks}</li>
                       <li>${repo.watchers}</li>
                   </ul>
                </div>
            `;
            container.insertAdjacentHTML('beforeend', child);
        });
    });
});

This JavaScript File will load the repository data from the Json file and display it on the html. Here I have used XMLHttpRequest but you can use Fetch API or JQuery to load the Json File.

After all the steps are done your project repository tree should look like this

project_dir
│   index.html
│   main.js
│   requirements.txt
│   repo_data.json    
│
└───scripts
│   │   commit.sh
│   │   update.py
│   
└───.github
|    |
│    └───workflows
|        |   update_resume.yaml
|

Setup GitHub Pages:

I use GitHub Pages to host my Resume.
You can learn more about How to setup GitHub Pages Here

After your setup is Done. GitHub will run your workflow every 15 minutes and if there is any change in the
repositories listed in the json file the python script will update it and the changed file will be committed
to your repository. So, the repositories you have listed in your resume will always be up to date.

Conclusion

I showed a small thing you can do with schedules on GitHub Actions.
But you can do a lot of more complex things using this.
You can automate many things on your website.
If you read this post and make something using it please feel free to share
with me on twitter or in the comments.

This is my first post! :)