It's been a couple of months since I created PyActon, an open-source tool that allows you to create GitHub Actions using Python. With this tool, you can install and use any Python package or library within your CI/CD pipelines.
The implementation described in this article is live hosted on GitHub.
You can use it with GitHub's official action/cache action to cache your action's dependencies. This is helpful when working with environments that have many or large dependencies that take time to load. This way, you can quickly get TensorFlow running inside your pipelines! We're not going to use it today though as our action is quite light and fast in terms of response.
In this article, we'll create a new action using PyAction that triggers when an issue is opened or reopened. It will read the issue data, use Sighted to analyze the text in the issue form, and finally, display the result as a comment based on the analysis.
Installation
Let's install both pyaction and sighted. They both require you to have pip and Python >= 3.8 installed.
pip install "pyaction[cli" sighted
To get started, we use the init command in pyaction to provide a base template for our action.
pyaction init
🎤 Action name
Sighted Action
🎤 Action's slug
sighted-action
🎤 Short description
Turning your issue content into bionic text
🎤 Author's name
Sadra Yahyapour
🎤 Include workflow testing pipeline
Yes
Change the current directory to the action's path.
cd sighted-action/
Development
We need to interact with the repository issues meaning we need to have access to the issue ID. Our action doesn't have any user-related inputs. Let's start with the action.yml file. I need to add one input and one output.
inputs:
...
issue_number:
description: The id of the issue
required: true
outputs:
bionic_text:
description: The converted bionic text
Leave the rest of the file as it is. Add the moment, we're using sighted==0.0.4. Add it to the requirements.txt file.
...
sighted==0.0.4
Create .github/ISSUE_TEMPLATE/sighted_text.yml file. It contains the structure of the issue template.
name: Sighted Text
description: Using Sighted to convert your input into Markdown bionic text
title: "Sighted: Bionic Text"
body:
- type: textarea
attributes:
label: Text
description: Write or paste your text here
validations:
required: true
- type: dropdown
id: color
attributes:
label: Color
description: Set the color for fixations
options:
- Gray
- Light Gray
- Dark Gray
- Red
- Yellow
- Green
default: 1
- type: dropdown
id: fixation
attributes:
label: Fixation
description: Set the fixation
options:
- 1
- 2
- 3
- 4
- 5
default: 1
- type: dropdown
id: saccade
attributes:
label: Saccade
description: Set the saccade
options:
- 1
- 2
- 3
- 4
- 5
default: 0
Issue template allows you to design a form and force users to fill the form if they want to open any issue on your repository. The above template would create something like this in the issues tab.
We're almost there. All we need to do is to implement the actual action and make it usable by completing the .github/workflows/test.yml pipeline.
Open the main.py file and import the following sighted components.
from string import Template
from pyaction import PyAction
from pyaction.auth import Auth
from pyaction.issues import IssueForm
from sighted import Literal
from sighted.language import PoS
Notice we're importing pyaction.auth.Auth and pyaction.issues.IssueForm. We need the IssueForm class to pass it an Auth object and interact with the issues.
We're going to use LaTeX to colorize text in GitHub's markdown platform. You probably know, there is no way you could colorize a text in your markdown unless you use LaTeX. That's not a common way, but for the sake of experiments, that's fine.
For that matter, we need this const variable defined.
...
COLORS = {
"Gray": "{gray}",
"Light Gray": "{lightgray}",
"Dark Gray": "{lightgray}",
"Red": "{red}",
"Yellow": "{yellow}",
"Green": "{green}",
}
Let's focus on the main function. Consider this one.
...
workflow = PyAction()
@workflow.action()
def my_action(github_token: str, repository: str, issue_number: int) -> None:
auth = Auth(token=github_token)
repo = auth.github.get_repo(repository)
user_input = IssueForm(repo=repo, number=issue_number).render()
language = Literal(
text=user_input["Text"],
fixation=int(user_input["Fixation"]),
saccade=int(user_input["Saccade"]),
ignore_pos=[PoS.PUNCT],
)
color = COLORS[user_input["Color"]]
prefix, postfix = f"$`\color{color}", "`$"
transformed_text = language.transform(
template=Template(f" $`$fix`$${prefix}$unfix{postfix}")
)
workflow.write({"bionic_text": "".join(list(transformed_text))})
It first reads the issue. Serializes that and takes Text, Fixation, Saccade, and Color. Then it creates prefix and postfix based on the color. Finally, the whole bionic transformed content will be returned under the variable name of bionic_text.
Open the .github/workflows/test.yml. Paste the following workflow steps.
name: Testing
on:
issues:
types: [opened, reopened]
jobs:
Test:
runs-on: ubuntu-latest
name: Testing the action
steps:
- name: Checkout
uses: actions/checkout@v2
- name: Create processing comment
uses: peter-evans/create-or-update-comment@v4
id: comment
with:
issue-number: ${{ github.event.issue.number }}
body: Processing..
- name: Running the action
uses: ./
id: sighted
with:
issue_number: ${{ github.event.issue.number }}
- name: Update comment
uses: peter-evans/create-or-update-comment@v4
with:
comment-id: ${{ steps.comment.outputs.comment-id }}
body: ${{ steps.sighted.outputs.bionic_text }}
reactions: rocket
edit-mode: replace
It gets triggered whenever an issue gets opened or reopened. Creates a comment in the issue form. Runs the action. Updates the comment that it just created. Here is the result.
Hopefully, you enjoyed this practice!
Conclusion
In this article, we created a GitHub Action using PyAction that triggers when an issue is opened or reopened, reads the issue data, uses Sighted to analyze and transform the text into bionic text, and displays the result in a comment. We walked through the installation, setup, and development process, including defining inputs and outputs, creating an issue template, implementing the main functionality with Python imports, and setting up a GitHub workflow to automate the process.
