DEV Community: Banjo Obayomi

Building Your First HuggingFace Transformers Tool

Banjo Obayomi — Tue, 16 May 2023 17:33:53 +0000

In this post, we'll walk you through the process of building a simple tool using the Transformers library.

The tool we're building will fetch an image of a cat from the internet each time it is run. We'll be using the Cataas (Cat-As-A-Service) API to achieve this. Let's dive in!

Prerequisites

Before we embark on this exciting journey of building the Cat Fetcher tool, we need to ensure that our development environment is properly set up. This tool relies on several Python packages - requests for making HTTP requests, Pillow for handling images, and transformers for creating the AI tool.

To install these packages, you can use the following command in your terminal:

pip install requests Pillow transformers

Fetching a Random Cat Image

To get started, here is the code that fetches a random cat image from the Cataas API:

import requests
from PIL import Image

image = Image.open(requests.get('https://cataas.com/cat', stream=True).raw)

Creating a Tool

To create a tool that can be used by our system, we first create a class that inherits from the superclass Tool:


from transformers import Tool

class CatImageFetcher(Tool):
    pass

This class needs the following attributes:

name: This is the name of the tool. For consistency, we'll name it cat_fetcher.
description: This will be used to populate the prompt of the agent.
inputs and outputs: These help the interpreter make educated choices about types and allow for a demo to be spawned when we push our tool to the Hub. They are both a list of expected values, which can be text, image, or audio.
A call method: This contains the inference code.

So, our class now looks like this:

from transformers import Tool
from huggingface_hub import list_models

class CatImageFetcher(Tool):
    name = "cat_fetcher"
    description = ("This is a tool that fetches an actual image of a cat online. It takes no input, and returns the image of a cat.")
    inputs = []
    outputs = ["image"]

    def __call__(self):
        return Image.open(requests.get('https://cataas.com/cat', stream=True).raw).resize((256, 256))

Now, we can simply test the tool:

tool = CatImageFetcher()
tool()

Using the Tool with an Agent

To use the tool with an agent, we recommend instantiating the agent with the tools directly:

from transformers.tools import HfAgent

agent = HfAgent("https://api-inference.huggingface.co/models/bigcode/starcoder", additional_tools=[tool])

Then, we can have the agent use it with other tools:

agent.run("Fetch an image of a cat online and caption it for me")

The tool successfully fetches a cat image, and the image captioning tool captions the image. That's it! You've just created your first tool with the Transformers library.

As a final step, we recommend pushing the tool to the Hugging Face Model Hub so others can benefit from it.

tool.push_to_hub("YOUR-TOOL")

Thank you for following along! We're excited to see the creative and useful tools you'll build.

To learn more about building tools check out the official documentation

Building an AWS Well-Architected Chatbot with LangChain

Banjo Obayomi — Thu, 11 May 2023 18:48:15 +0000

If you're familiar with the AWS Well-Architected Framework, you'll know that it offers a set of best practices designed to help you achieve secure, high-performing, resilient, and efficient infrastructure for your applications. But with a vast amount of information available, navigating the framework can be a daunting task.

This is why I decided to develop a chatbot to answer questions related to the framework, offering developers quick, accurate responses complete with supporting document links. If you're interested in how this project started, I encourage you to check out my previous post.

Now, in this follow-up article, I'll guide you through the process of building an enhanced version of the chatbot using the open-source library, LangChain.

LangChain enhances the functionality of large language model (LLM) applications, providing features such as prompt management, chains for call sequences, and data augmented generation. This step-by-step guide will cover:

• Data Collection
• Text Embedding Creation
• Prompt Engineering
• Chat Interface Development

You can try the chatbot here.

And check out the GitHub repo with the code here.

Data Collection: Web Scrapping

To obtain all the necessary links from the Well-Architected Framework, I extracted all the URLs from the sitemaps. The sitemaps provide a list of all links on the page, which allowed me to efficiently create a script to fetch all the text for each page. Here's the Python function I used:

def extract_urls_from_sitemap(sitemap_url):
    response = requests.get(sitemap_url)
    if response.status_code != 200:
        print(f"Failed to fetch sitemap: {response.status_code}")
        return []

    sitemap_content = response.content
    root = ET.fromstring(sitemap_content)

    # Extract the URLs from the sitemap
    urls = [
        elem.text
        for elem in root.iter("{http://www.sitemaps.org/schemas/sitemap/0.9}loc")
    ]

    return urls


 # Site maps for the AWS Well-Architected Framework
    sitemap_url_list = [
        "https://docs.aws.amazon.com/wellarchitected/latest/security-pillar/sitemap.xml",
        "https://docs.aws.amazon.com/wellarchitected/latest/framework/sitemap.xml",
        "https://docs.aws.amazon.com/wellarchitected/latest/operational-excellence-pillar/sitemap.xml",
        "https://docs.aws.amazon.com/wellarchitected/latest/reliability-pillar/sitemap.xml",
        "https://docs.aws.amazon.com/wellarchitected/latest/performance-efficiency-pillar/sitemap.xml",
        "https://docs.aws.amazon.com/wellarchitected/latest/cost-optimization-pillar/sitemap.xml",
        "https://docs.aws.amazon.com/wellarchitected/latest/sustainability-pillar/sitemap.xml",
    ]

    # Get all links from the sitemaps
    full_sitemap_list = []
    for sitemap in sitemap_url_list:
        full_sitemap_list.extend(extract_urls_from_sitemap(sitemap))

Once I compiled the list, I used the LangChain Selenium Document Loader to extract all the text from each page, dividing the text into chunks of 1000 characters. Breaking the text into 1000-character chunks simplifies handling large volumes of data and ensures that the text is in useful digestible segments for the model to process.

def load_html_text(sitemap_urls):
    loader = SeleniumURLLoader(urls=sitemap_urls)
    data = loader.load()

    text_splitter = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=20)
    texts = text_splitter.split_documents(data)

    return texts

Creating Text Embeddings

Next, I generated text embeddings for each of the pages using the OpenAI's embeddings API. Text embeddings are vectors (lists) of floating-point numbers used to measure the relatedness of text strings. They are commonly used for various tasks such as search, clustering, recommendations, anomaly detection, diversity measurement, and classification. Once the embeddings were generated, I used the vector search library Faiss to create an index, enabling rapid text searching for each user query.

def embed_text(texts, save_loc):
    embeddings = OpenAIEmbeddings(openai_api_key=os.environ["OPENAI_API_KEY"])
    docsearch = FAISS.from_documents(texts, embeddings)

    docsearch.save_local(save_loc)

Check out the full ingestion pipeline here.

Building the LLM Chain: Prompt Engineering

With the data ready, it was time to build the LLM chain to respond to user queries. The first step involved creating a PromptTemplate, which is a schema representing a prompt that can be passed to an LLM. This template consisted of a system prompt and two variables: the user's question and the context from the Well-Architected Framework relevant to the question.

TEMPLATE = """You are an AWS Certified Solutions Architect. Your role is to help customers understand best practices on building on AWS. Return your response in markdown, so you can bold and highlight important steps for customers. If the answer cannot be found within the context, write 'I could not find an answer' 

Use the following context from the AWS Well-Architected Framework to answer the user's query. Make sure to read all the context before providing an answer.\nContext:\n{context}\nQuestion: {question}
"""

QA_PROMPT = PromptTemplate(template=TEMPLATE, input_variables=["question", "context"])

Next, I set up the process to use the LLM to respond to user queries. I instanced the OpenAI model using the ChatOpenAI class and set the parameters (Note: you need your own OpenAI API key). Then, I established the embeddings endpoint for user queries and the local vector store from the scraped data. Finally, I set up the ConversationalRetrievalChain, which facilitates the creation of a chatbot using retrieval augmented generation (RAG) by utilizing the documents for its response.

def setup_chain():
    llm = ChatOpenAI(
        temperature=0.7,
        openai_api_key=os.environ["OPENAI_API_KEY"],
        model_name="gpt-3.5-turbo",
    )
    embeddings = OpenAIEmbeddings(openai_api_key=os.environ["OPENAI_API_KEY"])
    vectorstore = FAISS.load_local("local_index", embeddings)

    chain = ConversationalRetrievalChain.from_llm(
        llm, vectorstore.as_retriever(), return_source_documents=True
    )

    return chain

The full code is here

Creating the Chat Interface

The chat interface was developed using Streamlit, a versatile tool for building interactive Python web applications. This code creates a simple interface with a text input for user queries and a "Submit" button to submit the query. When the "Submit" button is clicked, the query, along with the chat history, is sent to the LLM chain, which returns a response along with the referenced documents.

def app() -> None:
    """
    Purpose:
        Controls the app flow
    Args:
        N/A
    Returns:
        N/A
    """

    # Spin up the sidebar
    sidebar()

    with st.container():
        # Load chat history
        for index, chat in enumerate(st.session_state["chat_history"]):
            message_func(chat[0], True)
            message_func(chat[1], False)

            # st.write(chat[0])
            # st.write(chat[1])
            with st.expander("Resources"):
                for doc in st.session_state["docs"][index]:
                    st.write(doc.metadata["source"])
                    st.write(doc.page_content)

        with st.form(key="my_form", clear_on_submit=True):
            query = st.text_input(
                "Query: ",
                key="input",
                value="",
                placeholder="Type your query here...",
                label_visibility="hidden",
            )
            submit_button = st.form_submit_button(label="Submit")
        col1, col2 = st.columns([1, 3.2])
        reset_button = col1.button("Reset Chat History")

    if submit_button:
        with st.spinner("Generating..."):
            result = chain(
                {"question": query, "chat_history": st.session_state["chat_history"]}
            )
            st.session_state["chat_history"].append(
                (result["question"], result["answer"])
            )
            st.session_state["docs"].append(result["source_documents"])
            st.experimental_rerun()  # Add Chat to UI

    if reset_button:
        st.session_state["chat_history"] = []
        st.session_state["docs"] = []
        st.experimental_rerun()

You can find the full code here.

Conclusion

In this guide, I've taken you through the process of building an AWS Well-Architected chatbot leveraging LangChain, the OpenAI GPT model, and Streamlit. We began by gathering data from the AWS Well-Architected Framework, proceeded to create text embeddings, and finally used LangChain to invoke the OpenAI LLM to generate responses to user queries.

You can interact with the chatbot here.

If you're interested in creating your own applications powered by LangChain, I hope this guide has offered useful insights and guidelines. Enjoy coding and exploring the possibilities of language models!

Remember, chatbots are powerful tools for simplifying complex processes and making information more accessible. They can be tailored to meet various needs, and with the right tools like LangChain and OpenAI, creating an intelligent, context-aware chatbot is easier than you might think. Happy bot-building!

About the Author

Banjo is a Senior Developer Advocate at AWS, where he helps builders get excited about using AWS. Banjo is passionate about operationalizing data and has started a podcast, a meetup, and open-source projects around utilizing data. When not building the next big thing, Banjo likes to relax by playing video games, especially JRPGs, and exploring events happening around him.

How I used GPT-3 to Build 1,000 AWS Quiz Questions

Banjo Obayomi — Wed, 22 Feb 2023 16:04:51 +0000

As demand for AWS-certified professionals continues to grow, having a solid understanding of the services and architecture is becoming increasingly essential. However, preparing for certification exams can be challenging, especially when trying to find relevant and engaging study materials.

In this blog post, I'll show you how I leveraged GPT-3 and the AWS Well-Architected Framework to create a significantly improved quiz experience from the one I made in 2020.

This time around, I was able to generate 1,000 scenario-based multiple choice questions, each accompanied by an explanation for the correct answer and additional resources for further study.

Compared to my previous quiz, which was based on a knowledge graph and offered limited question variety, this new approach allowed me to create sophisticated questions that test your understanding of real-world scenarios within each domain of the exam guide.

The release of ChatGPT showed that generative AI is ready, and my vision can finally be implemented.

To accomplish this, I'll walk you through the following

Data Collection
Creating Text Embeddings
Prompt Engineering
Question Generation
Creating the Quiz

You can try out the quiz here

And the GitHub repo with the code here

Data Collection

I started by using Selenium and BeautifulSoup to scrape the HTML page of the Well-Architected Framework, and stored all the text on each page into a CSV. I also extracted the title and URL for each page so they can be referenced later.

Here is some of the code used to gather data for each page.

def get_page_info(url):
    browser.get(url)
    html = browser.page_source
    # Have soup parse the website
    soup = BeautifulSoup(html, "html.parser")

    # Get title
    title = soup.find("title").string

    main_article = soup.find(id="main-col-body")  # main text of article
    # Get text sections
    text_sections = main_article.findAll("p")
    text_list = []

    for list_item in text_sections:
        text_list.append(list_item.text)

    # Get info in tables
    tables = main_article.findAll("table")

    for table in tables:
        # Add all ths and tds
        tds = table.findAll("td")
        ths = table.findAll("th")

        for th in ths:
            text_list.append(th.text)

        for td in tds:
            text_list.append(td.text)

    json_obj = {}
    json_obj["url"] = url
    json_obj["title"] = title
    json_obj["sections"] = text_list

    return json_obj

Data Cleaning

After the raw data is collected, I did some light data cleanup to normalize text and to split up any sections over 5,000 tokens as their model has an upper limit of tokens it can process. I also removed text that had less than 13 tokens, as there was bunch of text that just had service names such as "Amazon S3" and no context around what it does.

Creating Text Embeddings

Next, I created text embeddings for each of the pages using
OpenAI's embeddings API.

Text embeddings measure the relatedness of text strings. Embeddings are commonly used for:

Search (where results are ranked by relevance to a query string)
Clustering (where text strings are grouped by similarity)
Recommendations (where items with related text strings are recommended)
Anomaly detection (where outliers with little relatedness are identified)
Diversity measurement (where similarity distributions are analyzed)
Classification (where text strings are classified by their most similar label)

An embedding is a vector (list) of floating point numbers. The distance between two vectors measures their relatedness. Small distances suggest high relatedness and large distances suggest low relatedness.

This OpenAI Notebook provides a full end to end example of creating text embeddings

Here is an example of how the text looks like as an embedding, an list of 1536 numbers that represent the text.

With text embeddings we can now do a Search of all the text based on an input query. By asking Designing VPC architectures with security components we get a list of the documents that has text which is relevant to the query.

Prompt Engineering

Prompt engineering is about designing prompts that elicit the most relevant and desired response from a Large Language Model (LLM) such as GPT-3.

Crafting these prompts is an art, that many are still figuring out but a rule of thumb is the more detailed the prompt, the better the desired outcome.

I first started out with a simple prompt

Generate a multiple choice question that can appear on a AWS Certified Solutions Architect - Associate Exam

The responses varied in quality without any context, here's an example of one.

'Q1. Which of the following is a feature of Amazon EC2?
A. Automated scaling
B. Automated backups
C. Automated patching
D. Automated deployment

Answer: A. Automated scaling. Explanation: Amazon EC2 provides automated scaling, which allows users to scale their compute resources up or down based on their application needs.

Here is where prompt engineering can shine. I need to "overfit" my prompt so I can get the desired outcome of a question that is derived from the study material.

For this quiz, I want the questions to be about the specific testing areas for the test, and then inject the relevant content, a random scenario and have the data be returned in a JSON format so it can be used in different applications.

Question Generation

To construct my prompt, I made up around 20 different scenarios like A healthcare company wants to store and process sensitive patient information in the cloud. and then did a text embedding search on a topic that will show up on the exam such as Determining when to federate a directory service with IAM roles and then injected the text from the retrieved documents to make a robust prompt.

Generate a scenario-based multiple-choice question for the AWS Certified Solutions Architect Associate Exam using the provided scenario, context, and knowledge area. 

The response must be returned in the specified JSON format with nothing else. 

There should be one correct answer and 3 incorrect answers. The incorrect answers should be response options that a candidate with incomplete knowledge or skill might choose. 

Provide an explanation for the answer to each question as well. The question must be about a scenario, and not a simple definition question such as What type of storage is Amazon S3. 

The answers must also be action-oriented and not just the name of a service.

Scenario: A healthcare company wants to store and process sensitive patient information in the cloud."

Context:
Require identities to dynamically acquire temporary credentials. For workforce identities, use AWS IAM Identity Center (successor to AWS Single Sign-On)....

Knowledge Area: Determining when to federate a directory service with IAM roles

JSON Format: {"question": "","answer_choices": [{"answer": "","is_correct": "","explanation": ""},{"answer": "","is_correct": "","explanation": ""},{"answer": "","is_correct": "","explanation": ""},{"answer": "","is_correct": "","explanation": ""}]}

Using OpenAI's Completions API, with the prompt, I was able to use a Python script to iterate through all 189 domains on the exam guide with the example scenarios to generate 1,000 questions.

Here is an example question

Which of the following is the best practice for granting consumers access to a healthcare company's AWS resources, while storing and processing sensitive patient information in the cloud?

A. Federate with AWS IAM roles to access AWS accounts
B. Use Amazon Cognito identity pools and assign them a set of temporary, limited privilege credentials to access AWS resources
C. Grant consumers access to AWS resources using IAM users with long-term access keys
D. Grant consumers access to AWS resources using AWS Single Sign-On

And each question provides explanations, and link to the reference material.

Pitfalls

Not every question generated by GPT-3 was perfect. Sometimes the JSON did not have a question, or there were two answers or none at all despite the prompt saying "There should be one correct answer and 3 incorrect answers." This required me to manually review and correct the data. There could also be a chance that some of the questions may even be wrong, but by having the explanation paired with the documentation allows us a way to verify the information.

Creating the Quiz

I developed this quiz using my go-to tool for building web applications with Python, Streamlit. Streamlit allows builders to easily create interactive web apps that provide instant feedback on user responses. The quiz data is loaded from a JSON file and rendered using interactive widgets, making it simple for users to interact with the quiz. Additionally, I included links to documentation for each question, allowing developers to further explore the topics covered in the quiz.

Conclusion

In this blog post, I shared how I used GPT-3 and the AWS Well-Architected Framework to generate 1,000 scenario-based multiple choice questions for AWS certification exams.

I covered the entire process, from data collection to quiz creation, and provided insights into the challenges I faced along the way.

You can check out the quiz here, and use it as a study aid for your own AWS certification journey.

If you're interested in building your GPT-3 powered applications, I hope this post has provided you with some helpful tips and guidance.

My Developer Advocacy Flywheel

Banjo Obayomi — Tue, 20 Sep 2022 02:41:32 +0000

Wow it's been one year since I've started full time as A Developer Advocate at AWS!!!

Banjo Obayomi

@banjtheman

Hey friends, I'm excited to announce that today is my Day 1 as a Senior Developer Advocate at @awscloud #LetsGoBuild

14:24 PM - 20 Sep 2021

I've always thought of myself as a "Developer Advocate" due to my innate excitement of building content for developers to learn.

Now that I've been officially working in this role for a year, I wanted to share my experience and provide my framework for sourcing ideas to create fun experiences to help developers learn.

What is Developer Advocate

Developer Advocates are many things depending on the company's goals. They can be storytellers, community managers, documentation writers, and much more. At the heart of it, the focus is on providing support for a developer community to thrive.

At AWS my role as a developer advocate has allowed me engage the community through various mediums such as Twitter Spaces, blog posts and conferences. With many different AWS products, I often get asked, "how do you come up with content ideas to help developers?

Content Generation Flywheel

The Amazon Flywheel is a scared document that highlights how by creating a virtuous cycle focused on customers, Amazon was able to grow and offer new products.

Similarly when it comes to creating content for developers to consume we can take the same approach by focusing on the community and working backwards to identify a cycle that can constantly produce content geared for the community.

The three pillars of my Content Generation Flywheel are...

Collaboration
Content
Community

This post will dive deep into how this pillars enable me to build experiences to help developers learn.

Collaboration

At AWS, there are many "two pizza" teams working on a variety of projects. Often times teams want to be able to reach a developer audience but do not have the right mechanisms in place to create content for technical audiences.

This is where I come in, to craft an experience that resonates with developers. For this I create a document outlining our strategy with the relevant data points. When we are in alignment, the content creation can begin.

Content

This is where I would build the actual content such as a blog post, a lineup for a Twitter Space, or a workshop. The collaboration session helps provide the blueprint for the content, which enables me to enter a flow state to build out the necessary components needed to create a fun learning experience for the audience.

Community

When the content is ready to be delivered, I will provide ways to market the content based on the medium and then collect feedback from the community through mechanisms such surveys or live questions.

Community feedback enables me to collect data to measure how effective the content resonates with the audience. This data is then used to help inform the collaboration phrase, which kicks off another cycle...

Conclusion

The Developer Advocate job is always changing. This post introduced my Content Generation Framework which gives me mechanism to align my advocacy work with my north star of "Help Builders Win."

As I start off my next year at AWS, my goals will be to scale my efforts to create more opportunities for builders to learn and have fun!!

Follow Banjo on Twitter at @banjtheman for more useful tips and tricks about building on AWS. And of course there are many roles open in Developer Relations at AWS

How I became a Developer Advocate at AWS

Banjo Obayomi — Tue, 07 Jun 2022 01:37:19 +0000

Being a Developer Advocate is a fuzzy role that is different at every company. From the outside the emphasis of the role centered around speaking at conferences and providing content to their audience. As a passionate Meetup speaker and blog writer the role was highly aligned with what I did for fun on my own time. Becoming a Developer Advocate was really about "Following my fun".

In the post I will walk through my journey of how I grew as a builder that led me to become a Developer Advocate at AWS.

My First App

My interest in video games led me to take on a traditional software engineering path by studying computer science in college.

Initially classes were tough and I didn't really get software engineering. That changed when I took a 3 week 1 credit course over my Junior year winter break about Ruby on Rails. In this class I built a "Real Life Achievement" (RLA) Tracker, that allowed users to record accomplishments and share them on social media. While the app was simple the process of setting up the database, the Application Programming Interface (API), integrating social features and deploying to Heroku ignited my passion for building applications.

While I graduated and started my first job as a software engineer, I would still tinker with RLA to learn new skills. This led me to learning about Phonegap which was a way to build iOS and Android Apps with just JavaScript,CSS, and HTML. Launching my first app was exhilarating, being able to think of an idea and use code to bring it into the world was just an awesome process.

While I really enjoyed how I built my app, I wanted to share with others so that can be inspired to build as well. This led me to seek opportunities to find a venue to share my story.

The Meetup Circuit

I was able to find the DC Tech Meetup Group through Meetup which held gatherings for builders which focused on networking, startups, and tech. I attended one of the events and was instantly hooked.

The raw excitement of the speakers and the energy from the attendees made me feel like I found my long lost tribe. I was currently building another app called Mealscope which was social platform for finding friends nearby to go out and eat, and knew the meetup would be the perfect venue to highlight what I was building.

Going on stage was such an amazing moment. From walking through how I got the idea, to explaining the tech I used to build, and answering audience questions. This experience solidified my desire to help builders win.

From there I would seek out other Meetups to attend to learn from the community, answer questions on Stack Overflow, and attend conferences. I was going to at least 2 Meetups a week and applied to speak at different conferences every month. I even started my own Meetup group and podcast to provide others the opportunity to share content. However, this lifestyle came to abrupt end in March 2020...

Covid

During the pandemic all in person events stopped, and Meetups and conferences were all going virtual. While the community adapted for while, zoom fatigue eventually set in and the events became less engaging. With no outlet to the community, and just writing code isolated at home led me to reevaluate what I would want to do with my career.

This is when I started to research "Developer Advocates" and found out that their work aligns with what I enjoy doing, helping builders win with their product. From there I started to prepare for interviews and was able to land a role at AWS.

// Detect dark theme var iframe = document.getElementById('tweet-1439958707388010496-992'); if (document.body.className.includes('dark-theme')) { iframe.src = "https://platform.twitter.com/embed/Tweet.html?id=1439958707388010496&theme=dark" }

Conclusion

The Amazon Leadership Principle of "Learn and be Curious" embodies the path I took to becoming a Developer Advocate. I've learned many different languages, frameworks, and tools over the years and have been able to create content to enable builders to develop solutions. While every path is different, I believe the guiding philosophy to becoming a developer advocate is to demonstrate how you "Help Builders Win".

Follow Banjo on Twitter at @banjtheman for more useful tips and tricks about building on AWS. And of course there are many roles open in Developer Relations at AWS

Building DevDaoStory: A Dynamic Visual Novel

Banjo Obayomi — Tue, 01 Mar 2022 22:26:40 +0000

Composability is the general ability to reuse the components of a system to develop applications. For example Legos are the building blocks for many type of different structures that can be created.

In web3 world text based NFTs which are just list of words which are akin to Lego blocks that allow the community to build applications around these composable parts.

This post will walk through how I built DevDaoStory a dynamic visual novel based on the DevDao NFT your wallet holds. I will highlight how I built the following sections

Front End using server side rendering
Utilizing OpenSea API for Identity
Generating a unique game with the Ren'py Engine

Front end

The user interface is a website built using HTML, Bootstrap, JavaScript, jinja2 and JQuery. I find it simplest to build using primitives instead of being locked into a framework like React for simple interfaces.

Since I'm leveraging jinja2 for server side rending, the application is hosted on AWS Lambda and API Gateway which provides one million events for free to use each month which provides a cost-effective way to host the application.

There are only two pages for this app, the home page and the select your Dev page. Here is a snippet of code for rendering Devs in the user's wallet.

{% for dev in devs %}
<div class="col-md-5 offset-md-1">

    <div class="card mb-3" style="max-width: 540px;">
        <h3 class="card-title mt-3 mx-auto dark-text">Dev #{{dev['id']}}</h3>
        <div class="row g-0">
            <div class="col-md-5">
                <div class="card-body">

                    <ul class="list-group list-group-flush">
                        <li class="list-group-item">Os: {{dev['os']}}</li>
                        <li class="list-group-item">Text Editor: {{dev['textEditor']}}</li>
                        <li class="list-group-item">Language: {{dev['language']}}</li>
                        <li class="list-group-item">Vibe: {{dev['vibe']}}</li>
                        <li class="list-group-item">Location: {{dev['location']}}</li>
                        <li class="list-group-item">Mind: {{dev['mind']}}</li>
                        <li class="list-group-item">Industry: {{dev['industry']}}</li>
                        <li class="list-group-item">Clothing: {{dev['clothing']}}</li>
                        <li class="list-group-item">Background: {{dev['background']}}</li>

                    </ul>
                </div>
            </div>  
...

The next section will focus on how to build mechanisms to get identity details from a user.

Identity

In order to know what Devs, a user has connect to their wallet I utilized the ethers.js library to provide a way for users to sign a "Login" message with their MetaMask Wallet.

async function connectWallet() {

    if (window.ethereum) {
        try {
            const accounts = await window.ethereum.request({ method: 'eth_requestAccounts' });
            console.log("accounts")
            console.log(accounts)

            walletProvider = new ethers.providers.Web3Provider(window.ethereum)
            walletSigner = walletProvider.getSigner(); 
            const base_message = "Login to DevDaoStory"
            const signature = await walletSigner.signMessage(base_message)
            console.log(signature)

            login_info = {}
            login_info["address"] = accounts[0]
            login_info["signature"] = signature
            login_info["message"] = base_message

            var login_info_string = JSON.stringify(login_info)

This code provides users a way to allow the application to read their public key, so their Devs can be verified.

Once the User accepts a POST request is sent to the server to gather the details of the user


            $.ajax({
                type: "POST",
                url: "/web3_login",
                dataType: "json",
                data: login_info_string,
                contentType: "application/json",
                success: function(data) {
                    console.log("login finished")
                    console.log(data)
                    ...

                },
                error: function(xhr, textStatus, thrownError, data) {
                    alert("Error: " + thrownError);
                    $("body").css("opacity", "1");
                    $("#load_spinner").toggle();

                }
            })

The message can be verified leveraging the web3 python module.

from web3 import Web3
from eth_account.messages import encode_defunct


def verify_signature(address, signature, message, w3):
    """
    Purpose:
        Verify user signed the message
    Args:
        address - address of user
        signature - the signature from user
        message - message to check
    Returns:
        boolean - True if verify, false if not
    """
    encoded_message = encode_defunct(text=message)
    pub_key = w3.eth.account.recover_message(encoded_message, signature=signature)

    logging.info(pub_key)

    # make sure same case
    if w3.toChecksumAddress(pub_key.lower()) == w3.toChecksumAddress(address.lower()):
        return True
    else:
        return False


...

@application.route("/web3_login", methods=["POST"])
def web3_login():
    """
    Purpose:
        login
    Args:
        N/A
    Returns:
        login object
    """

    jsonResp = {}
    data = request.data

    try:
        login_info = json.loads(data.decode("utf-8"))

        logging.info(login_info)

        address = w3.toChecksumAddress(str(login_info["address"]).lower())
        message = str(login_info["message"])
        signature = str(login_info["signature"])
        valid = web3_utils.verify_signature(address, signature, message, w3)
...

For more information on setting up your python web3 environment check out the docs

OpenSea API

Once the message has been verified we can now use the OpenSea API to get the Devs for the user.


def get_opensea_assets(userAddress: str, contract: str):
    """
    Purpose:
        Get assets from opensea
    Args:s
        userAddress: user to get
        contract: contract to get
    Returns:
        json_obj - Opensea assets
    """

    API_KEY = os.environ["OPENSEA_API"]

    HEADERS = {"x-api-key": API_KEY, "Accept": "application/json"}

    url = "https://api.opensea.io/api/v1/assets"

    querystring = {
        "owner": userAddress,
        "order_direction": "desc",
        "offset": "0",
        "limit": "20",
        "asset_contract_address": contract,
    }

    json_obj = requests.get(url, params=querystring, headers=HEADERS).json()

    return json_obj["assets"]

assets = web3_utils.get_opensea_assets(address, DEVS_CONTRACT)

The API call will get all the information about the item, including the tokenid. By building upon the pixel-avatars project we can now get an image, and the data that defines your Dev, so it can be rendered on the front end.

The next section will focus on how the actual game was built, now that all the setup is complete.

Ren'py Game Generation

Ren'Py is an open-source visual novel engine used by thousands of creators from around the world. It provides a scripting language that allow users to build interactive stories with words, images, and sounds.

For Ren'py to work for DevDaoStory I created a custom docker image with a modified version of Ren'py to compile only the web version of the game. I also leverage AWS Lambda to provide an endpoint to run the docker image with the necessary data to generate the story.

Once the game is compiled, it is uploaded to an S3 bucket for users to play. Here is sample code highlight the process

def main():
    """
    Purpose:
        Main driver
    Args:
        N/A
    Returns:
        N/A
    """

    test_dev = {
        "id": "2",
        "os": "Windows 95",
        "textEditor": "Emacs",
        "clothing": "Pink Hoodie",
        "language": "C",
        "industry": "Traveling Consultant",
        "location": "London",
        "mind": "Concrete",
        "vibe": "Optimist",
        "background": "Blue",
    }

    wallet = "0x00000000000"

    logging.info("Building Dynamic Game")
    gen_game_script(test_dev, wallet)
    build_renpy_game("/tmp/stories/devdaostory/")
    upload_to_s3_bucket("dev2")
    logging.info("Done and done")

Once the game is uploaded to s3, the UI renders an iframe with the game so users can begin the story with their Dev.

Conclusion

DevDaoStory was fun to build, and provides a use case for building an application for a community leveraging NFTs. The game is also playable without a Dev in your wallet to ensure other builders can be inspired by the story. You can play here: https://www.devdaostory.com/

If you want to make your own story, or update the existing one, you can checkout the github repo.

Follow Banjo on Twitter at @banjtheman and @developer_dao for more useful tips and tricks about building web3 applications.

Addressing 3 criticisms of web3

Banjo Obayomi — Tue, 08 Feb 2022 21:46:58 +0000

Web3 is an architecture and set of patterns for building distributed systems. Some of those patterns are implemented by different infrastructure components at different layers of the stack. Web3 will not solve society's problem similar to how AI did not solve our problems, but offers a new way to build applications. This post will touch on 3 common criticisms I hear when developing Web3 applications.

Anti Network Effects

The early adopters that get in early need to sell their tokens to new comers at higher prices to make a profit. Not everyone wants to do that so they will make their own coin which sometimes will be a scam.

zerohedge

@zerohedge

'Squid Game' Crypto-Scam Exposed, COIN Crashes 100% After Explosive Gains zerohedge.com/crypto/squid-g…

17:34 PM - 01 Nov 2021

These anti patterns of jumping to coin to coin are not a sustainable roadmap for building applications. The desire to get in early and for coins to moon is for speculation and not builders. Builders are focused on protocols and services that provide value to their customers and will focus their energy in building systems. Just how their are scams and fraud in web2, moving to a new paradigm does not remove societal problems. The builders will continue to build and scammers will continue to scam, what we can do as a community is educate how to detect scams and protect your assets. I reckon a Gmail style "filter" will emerge that can automatically block out illegitimate projects in the near future.

"Decentralization"

A key concept for web3 is having decentralized protocols to build with. While not having to solely rely on a 3rd party, you give up the aspect of responsibility. If your AWS account gets hacked and you get a massive bill, they can waive the fee for you and you can upgrade your account security. But if an NFT gets stolen or wallet comprised your are out of luck... in theory. Centralized services are already here in the in web3 space such as OpenSea and Coinbase. These entities already take the onus responsibility in certain use cases such as a "stolen" NFT.

Nikita

@nikitabier

If centralized marketplaces can flag & block “stolen” NFTs—effectively delegitimizing the ledger—then what’s the point of the blockchain?

The end state of decentralized protocols will likely be the same system we have today: banks reversing transactions they deem illegitimate.

06:41 AM - 04 Jan 2022

Guard rails must be in place for developers to want to build. The centralized services will be offering guard rails which will also improve developer experience. Think of services such as Steam and Netflix that provide a centralized experience for games and movies. As much as we may hawk about decentralized, when something goes wrong we want to blame someone and having central players gives us the confidence to build.

What data goes on chain?

"If you ask 10 developers to architect a system that leverages blockchain, you will get 10 different responses on how to build the system" - Aaron Levie CEO Box

Storing data on chain is expansive and is not better than using stand SQL databases of "web2". So this begs the question why should we even us blockchain then?

Blockchains provide a new way to build networks that combines the publicly-owned network effects of web1 with the advanced functionality of web2.

nader dabit (🧱, 🚀) | sha.eth | nader.sol

@dabit3

People will point to blockchain technology & argue its inefficiencies when compared to traditional high throughput databases.

The real comparison should be between highly inefficient & expensive intermediaries like banks, lawyers, art brokers, governments, & stock exchanges.

04:14 AM - 05 Feb 2022

This allows blockchains to act as public goods rather than private entities. In terms of what should be stored...

The least amount of information possible, in the most efficient way possible, should be stored on the blockchain

Blockchains at is core is about developing a system of trust. In the end a human must verify the data on chain. Sentiment such as "code is law" fall apart as soon as bugs or errors are introduced. Having a way for a human to verify the hash of data provides a mechanism for humans to understand data stored on chain for applications.

Conclusion

We are still early... and we are "flying the airplane while building it". It is important to remember that web3 does not solve societal problems and centralization is not inherently bad. Its up to use the builders to architect systems that humans can trust and develop applications we enjoy using.

DC Fire and EMS Data Visualizer

Banjo Obayomi — Tue, 11 Jan 2022 15:17:23 +0000

Overview of My Submission

This application uses MongoDB time series collections to highlight the DC Fire and EMS call volume between August 2014 through August 2015. The data is visualized using Streamlit and provides an interface for users to select different days to view. The app is hosted here to try out.

Submission Category:

Prime Time

Link to Code

banjtheman / dcfireems_mongo

Visualzing DCFireEMS call data with MongoDB

DC Fire and EMS Data Visualizer

This project uses Streamlit to display the DC Fire and EMS call volume between August 2014 through August 2015. The data is being stored in a a MongoDB time series collection. This project was built for the MongoDB Atlas Hackathon]

Try out the demo

View on GitHub

Additional Resources / Info

The data was collected during the
2021 National Day of Civic Hacking from Code for America by the Code for DC Group. Streamlit was used to build the visualization.

How I built a Full Stack Web3 App on the Cloud

Banjo Obayomi — Mon, 03 Jan 2022 23:04:38 +0000

As a builder, I am always curious about how to develop applications with emerging technology. A technology that has captured my attention recently has been non fungible tokens (NFTs). An NFT is a unique digital item that is stored on a blockchain. A common use case is to store digital art as an NFT that can be sold to collectors. I’ve always fostered the idea that code is art. With the resurgent demand for NFTs it provided the perfect opportunity to build a product that can embed code as a art. Thus GitGallery was born, a website that allows you to mint your GitHub commits as an NFT. This post will dive deep on how I built GitGallery highlighting

Smart Contract Development
Backend API
User Interface
Application Deployment

Overview

To provide a scalable, cost effective process for minting NFTs I leveraged Polygon which is a protocol and framework that provides reduced fees needed to run Ethereum based applications.

In addition, the entire web application is deployed on Amazon Web Services (AWS). By leveraging AWS, I was able to create a serverless application that responds to events rather than wasting compute sitting idly if deployed onto a server. With AWS Lambda and API Gateway one million events are free to use each month which provides a cost-effective way to host the application. The following sections will detail the tools and processes I used to develop the smart contract, the backend API (Application Programming Interface) and the user interface.

Smart Contract

The smart contract I developed provides the ability to create a unique token named GitNFT which is linked to a GitHub commit. The code was developed using the Solidity programming language. I was able to import code developed by OpenZeppelin a firm that provides secure code for blockchain applications. The code implements the NFT standard known as ERC (Ethereum Request for Comment) 721 which provides the functionality to deploy the smart contract to the blockchain and mint NFTs.

pragma solidity ^0.8.0;

import "./ERC721Tradable.sol";

/**
 * @title GitNFT
 * GitNFT - a contract for code GitNFTs.
 */
contract GitNFT is ERC721Tradable {
    uint256 public nextTokenId;
    address public admin;

    constructor(address _proxyRegistryAddress)
        public
        ERC721Tradable("GitNFT", "GitNFT", _proxyRegistryAddress)
    {
        admin = msg.sender;
    }

    // only our wallet should be able to mint
    function mint(address to) external onlyOwner {
        _safeMint(to, nextTokenId);
        nextTokenId++;
    }

    function baseTokenURI() public pure override returns (string memory) {
        return "https://www.gitgallery.com/tokenid/";
    }
}

Once the code is written the next step is to deploy the contract to the Polygon blockchain.

I used the deployment software Truffle with the Ethereum API Infura to compile my contract code and deploy the artifacts to the Polygon blockchain. Here is a code used to deploy the contract to the Polygon Blockchain

const NFT = artifacts.require("GitNFT");
const proxyRegistryAddress = process.env.OWNER_ADDRESS


module.exports = async function (deployer, _network, accounts) {
  await deployer.deploy(NFT,proxyRegistryAddress, {gas: 5000000});
  const nft = await NFT.deployed();
};

This transaction required the Polygon token MATIC to pay for the contract fees, which in total cost about 1 cent. Compiling the code also produces an Application Binary Interface (ABI) which is a JavaScript Object Notation (JSON) file that allows for other applications to interact with the contract.

Backend API

I used Python to develop the business logic needed for GitGallery and used the Flask framework to encode the API endpoints. The 4 major endpoints needed for the application are login, verify, mint, and get items.

Login

By leveraging Auth0 a platform designed to make it easy to login via 3rd party authentication, I created an endpoint that allows users to login via their GitHub account. The code stores the logged in user details via cookies in the current web browser session, to track state from each request. When a user logs out, the browser session clears all cookies.

Verify

To verify a GitHub commit, users enter in the URL of their GitHub commit. By using the GitHub GraphQL API, I created a query that could verify if the user created the commit ID for the given project. Here is the GraphQL query used to verify the author of the commit.

{
  repository(owner: "OWNER", name: "NAME") {
    object(expression: "COMMIT_ID") {
      ... on Commit {
        author{
          name
          user{
            login
          }
        }
      }
    }
  }
}

Mint

Once a commit is verified, the user can mint the commit as an NFT. By using the ABI and the python Ethereum library web3.py the code executes the mint function of the NFT contract. Here is the code used to mint the GitNFT

def web3_mint(userAddress: str):
    """
    Purpose:
        mint a token for user on blockchain
    Args:
        userAddress - the user to mint for
    Returns:
        hash - txn of mint
        tokenid - token minted
    """

    nonce = w3.eth.get_transaction_count(PUBLIC_KEY)

    # Create the contract function
    mint_txn = CODE_NFT.functions.mint(userAddress).buildTransaction(
        {
            "chainId": CHAIN_ID,
            "gas": 10000000,
            "gasPrice": w3.toWei("1", "gwei"),
            "nonce": nonce,
        }
    )

    signed_txn = w3.eth.account.sign_transaction(mint_txn, private_key=PRIVATE_KEY)

    w3.eth.send_raw_transaction(signed_txn.rawTransaction)
    hash = w3.toHex(w3.keccak(signed_txn.rawTransaction))
    receipt = w3.eth.wait_for_transaction_receipt(hash)  
    hex_tokenid = receipt["logs"][0]["topics"][3].hex()  # this is token id in hex

    # convert from hex to decmial
    tokenid = int(hex_tokenid, 16)
    logging.info(f"Got tokenid: {tokenid}")
return hash, tokenid

The fee for calling the contract is paid from MATIC I allocated for the project. Since the minting cost is less then a fraction of a penny the process is virtually free and more importantly has no costs to the user. Each minted NFT produces a JSON file with the commit metadata. The metadata is stored in Amazon S3 and DynamoDB.

Get Items

To display Items for a particular user the code creates a DynamoDB query using the selected user as the partition key. The JSON in S3 is used for external platforms such as OpenSea which is a marketplace for NFTs. There is a particular format needed for the data to show correctly in external applications which is handled by S3, while data on GitGallery is rendered from DynamoDB.

Deployment

To deploy the code to the web, I leveraged the Serverless framework. Serverless allows me to create a YAML (YAML Ain't Markup Language) file that specifies all infrastructure and security needed to deploy the Flask application as a docker image. Serverless will deploy the docker image on AWS Lambda with the endpoints mapping to API Gateway, with the necessary Identity and Access Management (IAM) roles to access services such as S3 and DynamoDB.

User Interface

The user interface is a website built using HTML, Bootstrap, JavaScript, jinja2 and JQuery. These tools allowed me to create a user interface that leverages server-side rendering to allow for dynamic routes such as www.gitgallery.com/gallery/{USER_NAME}/minted

@application.route("/gallery/<user>/minted")
def minted(user):
    """
    Purpose:
        load gallery page
    Args:
        N/A
    Returns:
        html - gallery html
    """
    if "profile" in session:
        curr_user = session["profile"]
    else:
        curr_user = None

    # check if user exists...

    userdata = users.get_item(Key={"username": user})
    if not "Item" in userdata:
        logging.error(f"No such user {user}")
        return redirect(f"/")

    user_metadata = userdata["Item"]

    # get minted items
    minted_items = get_minted_items(user)

    return render_template(
        "gallery.html",
        userinfo=curr_user,
        minted_items=minted_items,
        user=user,
        user_metadata=user_metadata,
    )

In addition, I utilized the ethers.js library to provide a way for users to sign their GitHub commits using their MetaMask Wallet. The MetaMask wallet provides users an interface to interact with the Ethereum blockchain. The following is the front end code used to mint tokens

async function safe_mint(data) {
                    // console.log("safe mint called")

                    let userAddress = ""
                    try {
                        userAddress = await walletSigner.getAddress()

                    } catch (error) {
                        alert("Metamask not detected")
                        console.log(error)
                        return
                    }

                    let username = data["username"]
                    let ver_url = data["verify_url"]
                    let ver_date = data["status_json"]["date"]

                    // Commint
                    const base_message = "Signed on GitGallery\n\n" + username + " " + ver_date + "\n " + ver_url
                    const signature = await walletSigner.signMessage(base_message)

                    var mintObj = {}
                    mintObj["verify_json"] = data
                    mintObj["signature"] = signature
                    mintObj["userAddress"] = userAddress

                    var mintString = JSON.stringify(mintObj)

                    $("body").css("opacity", ".3");
                    $("#load_spinner").toggle();

                    $.ajax({
                        type: "POST",
                        url: "/mint_token",
                        dataType: "json",
                        data: mintString,
                        contentType: "application/json",
                        success: function (data) {
                            console.log("mint returned")
                            console.log(data)

                            $("#load_spinner").toggle();
                            $("body").css("opacity", "1");


                            //check for error
                            if ('error' in data) {
                                alert(data["error"]);
                                return -1
                            }

                            alert("Mint Successful")

                            //passed? reload page?
                            location.reload()
                        },
                        error: function (xhr, textStatus, thrownError, data) {
                            alert("Error: " + thrownError);
                            $("body").css("opacity", "1");
                            $("#load_spinner").toggle();

                        }
                    })


                }

Conclusion

Connecting all the dots results in a full stack NFT application with a simple workflow. A user signs in using their GitHub credentials. The user enters in a URL for a GitHub Commit. The system verifies the commit for the user. The user then signs the commit with MetaMask. Finally, the GitHub commit is minted as an NFT and stored in the user’s MetaMask wallet. This workflow allows for the creation of an NFT in less than 30 seconds for free.

If you itching to build your own NFT project, I've created a hands on workshop that focusing on leveraging these tools to launch your own smart contract.

Using GitHub Actions to answer questions about Pull Requests

Banjo Obayomi — Wed, 10 Nov 2021 17:27:34 +0000

Comment for #34

github-actions[bot] commented on Nov 10, 2021

PR FAQ

How long was PR open?

The PR was open for 0 days, 0 hours, 0 minutes, 4 seconds

Who contributed to the PR?

The following users contributed to the PR
banjtheman

What files changed in the PR?

The following files changed in the PR
templates/prfaq-template.md

How many lines of code changed in the PR?

+5 -5 lines of code changed

View on GitHub

The Pull Request FAQs (PRFAQs) is a mechanism to automatically capture relevant data points on a finished Pull Request. The PRFAQs currently answers the following questions.

How long was PR open?
Who contributed to the PR?
What files changed in the PR?
How many lines of code changed in the PR?

By leveraging existing GitHub Actions I was able to build a workflow to answer the questions.

My Workflow

The following highlights how this workflow works.

When a pull request is closed, the workflow is started.
The workflow downloads the repo using the GitHub Action actions/checkout@v2
The workflow uses the GitHub GraphQL API using the template query to get data on the pull request using the GitHub Action helaili/github-graphql-action@2.0.1
The workflow saves the output as a JSON file
The workflow uses the jannekem/run-python-script-action@v1 to parse the JSON file to set answers to the questions as environment variables
The workflow uses the chuhlomin/render-template@v1.2 to set the answers into the PRFAQs template
The workflow uses the peter-evans/create-or-update-comment@v1 to post the answers as a comment on the Pull Request

Submission Category: Maintainer Must-Haves

While Maintainers can find this information by scrolling through each Pull Request the PRFAQ workflow consolidates the effort into a single comment and provides vital information not found directly such as how long the PR was open for.

Yaml File and Link to Code

Here is the GitHub Repo

banjtheman / prfaq_action

Create a PRFAQ for merged pull requests

Here is the Workflow Yaml

name: PRFAQ

# only trigger on pull request closed events
on:
  pull_request:
    types: [closed]
env:
  PR_NUMBER: ${{ github.event.pull_request.number }}

jobs:
  get_pr_stats:
    runs-on: ubuntu-latest
    steps:
      - name: Checkout repository
        uses: actions/checkout@v2
      - name: GitHub GraphQL Action
        uses: helaili/github-graphql-action@2.0.1
        env:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
        with:
          query: queries/pr_stats.yaml
          logLevel: debug
          outputFile: pr_stats.json
          pr_num: ${{ env.PR_NUMBER }}
      - name: Set env variables
        uses: jannekem/run-python-script-action@v1
        with:
          script: |
            import json
            import datetime

            with open("pr_stats.json", "r") as pr_file:
                pr_stats = json.load(pr_file)

                # Get Time Open
                created_at = pr_stats["data"]["repository"]["pullRequest"]["createdAt"]
                merged_at = pr_stats["data"]["repository"]["pullRequest"]["closedAt"]

                created_at_timesamp = datetime.datetime.strptime(created_at, "%Y-%m-%dT%H:%M:%SZ")
                merged_at_timestamp = datetime.datetime.strptime(merged_at, "%Y-%m-%dT%H:%M:%SZ")
                timestamp_diff = merged_at_timestamp - created_at_timesamp

                days, seconds = timestamp_diff.days, timestamp_diff.seconds
                hours = days * 24 + seconds // 3600
                minutes = (seconds % 3600) // 60
                seconds = seconds % 60

                timestamp_open = f" {days} days, {hours} hours, {minutes} minutes, {seconds} seconds"
                print(timestamp_open)
                set_env("PR_OPEN", timestamp_open)

                # Get participants
                participants = pr_stats["data"]["repository"]["pullRequest"]["participants"][
                    "edges"
                ]
                participants_string = ""
                for participant in participants:
                    participants_string += participant["node"]["login"] + "  "

                print(participants_string)
                set_env("PR_USERS", participants_string)

                # Lines of code changed
                additions = pr_stats["data"]["repository"]["pullRequest"]["additions"]
                deletions = pr_stats["data"]["repository"]["pullRequest"]["deletions"]
                content_changed = f"+{additions} -{deletions} lines of code"
                print(content_changed)
                set_env("PR_LOC", content_changed)

                # Files that changed
                files = pr_stats["data"]["repository"]["pullRequest"]["files"]["edges"]
                files_string = ""
                for file_path in files:
                    files_string += file_path["node"]["path"] + "  "
                print(files_string)
                set_env("PR_FILES", files_string)
      - name: Render template
        id: template
        uses: chuhlomin/render-template@v1.2
        with:
          template: templates/prfaq-template.md
          vars: |
            pr_open: ${{ env.PR_OPEN }}
            pr_users: ${{ env.PR_USERS }}
            pr_loc: ${{ env.PR_LOC }}
            pr_files: ${{ env.PR_FILES }}
      - name: Create comment
        uses: peter-evans/create-or-update-comment@v1
        with:
          issue-number: ${{ env.PR_NUMBER }}
          body: ${{ steps.template.outputs.result }}

Additional Resources / Info

These are all the Actions I used to build the workflow

What other questions should this workflow answer? Leave your suggestions in the comments below.

Ideal GitHub Pull Request Labels?

Banjo Obayomi — Thu, 04 Jun 2020 18:34:07 +0000

Im currently working on a GitHub bot that uses a machine learning model that can read info from a pull request (via graphql) and automatically tag the PRs with labels like author_confidence (high/low), pr_complexity (high/low), stackoverflow_tag (python , aws, etc...)

What other types of label information would add value to a PR?

DataOps Podcast: Structuring Unstructured Data

Banjo Obayomi — Wed, 03 Jun 2020 22:03:12 +0000

Join @banjtheman and @victori_ousg, as they have a conversation about Structuring Unstructured Data with @NNData_Corp
https://www.nndata.com/

https://anchor.fm/dataops/episodes/DataOps-Podcast-Structuring-Unstructured-Data-eenv18/a-a2b3qb3