Forem: Prakhar Kaushik

Github Action for Auto Publishing My Articles from Hugo blog to Medium

Prakhar Kaushik — Tue, 01 Sep 2020 18:11:14 +0000

My Workflow

Name: hugo-to-medium

Submission Category:

DIY Deployments

Yaml File or Link to Code

pr4k / hugo-to-medium

Github action to directly post from hugo to medium

hugo-to-medium

Github action to directly post from hugo to medium This is created for those who are always importing their own hugo blog to medium.It uses Medium's API to directly upload the post from hugo to medium

Usage

It uses commit message to identify which post to publish on medium Simply while making a commit include at last PUBLISH <Your-post-name>.md

Example:

git commit -m "Added: post PUBLISH: my-arch-setup.md

Creating main.yml

A sample main.yml can be

on: [push]

jobs:
  hugo_to_medium_job:
    runs-on: ubuntu-latest
    name: hugo-to-medium
    steps:
      # To use this repository's private action, you must check out the repository
      - uses: actions/checkout@v2
        with:
          ref: master
      - name: Hugo To medium Action step 
        uses: pr4k/Hugo-to-Medium@master # Uses an action in the root directory
        id: hello
        env:
          APP_ID: ${{secrets.APP_ID}}
          ACCESS_TOKEN: ${{secrets.ACCESS_TOKEN}}
          APP_SECRET: ${{secrets.APP_SECRET}}
          BLOG_DIR: ${{secrets.BLOG_DIR}}
      #

paste this to .github/workflow/main.yml

APP_ID: This is your medium Developer APP id…

View on GitHub

Market Place

Additional Resources / Info

[Note:] # (Be sure to link to any open source projects that are using your workflow!)

How I Use My Terminal as a Webcam

Prakhar Kaushik — Sun, 30 Aug 2020 09:55:36 +0000

Te-We is a project which focuses on using a webcam just with a terminal. Powered by Python we will be creating a terminal stream of webcam.
One day I was going through my system to find a webcam application but was not able to find one because I use Debian Linux and I added each and every software manually, so I never downloaded anything for the webcam.
So I thought why not make something with a terminal for this, I came across a project which was an Image to Ascii Project and I thought why not combine the video stream with a similar project and hence TE-WE was developed

This whole thing is an Ascii Art of a video stream from the webcam.
If you find it interesting, you can find the whole unscripted programming video of it at

So getting back to the code part. Let's start with it.

Step 1

Create an Ascii Image using an actual image

Step 2

Replace the Ascii Image with a video stream frame and print them one over the other to get the effect of a continuous frame.
Done!!

Let's Discuss everything in Detail, Our first aim would be to convert

to an Ascii Image like

Once it's Done all that's left is to create a video stream as a source for frames to the program.

Let's see the code first

Let me explain everything here. For now ignore the line 10–12, remaining part is simple, convert the whole RGB image to black and white image so that we can actually get the intensity of each pixel.
Then based on the intensity of each pixel we will find a suitable character for each pixel and create an image out of it.
But the problem is that its still black and white, so the next part would be to get the approx ANSI color for each pixel hence we will find the colored image printed.
Let's see the code to get RGB to ANSI, It was taken from a library

torrycrass / image-to-ansi

A Python based Image to ANSI converter

Here is the code, It's pretty simple and actually just based on some mathematical solution.
So with this, we will get the ANSI color code from RGB and them we just need to get the ANSI color for each pixel, and here the line 10–12 will come into action
We are using their RGB value for each pixel and saving the ANSI color code separately before converting the image to black and white.
And done, our first part is done.

Step 2

Adding a video stream is simple and can be found anywhere, as it's just using opencv to get the frames from video and printing it on screen.
So here we are done.

Final Demo

Feedback

Do leave feedback on the project, If you want to check out the source code. Here it is

pr4k / Te-We

Te-We is a Terminal Webcam Client which can be used to use your webcam using terminal

Locate: A Recursive Search Tool - RUST

Prakhar Kaushik — Mon, 23 Mar 2020 07:13:02 +0000

How many times have you gone through files to find some string or origin of a function

Locate is a tool written in Rust which goes through each file recursively and gives exact location of the query string in the files.

Its blazing fast, as its written in Rust, and can recursively walk the directories.

Motivation

Okay so I wanted to learn Rust and I think the best way to learn a new language is by creating a project,
I always used search function in VS code to find origin of a function or places where the function is used.

If working with large projects it sometimes becomes difficult to exactly locate all the points where a function is used, ofcourse one can follow the imports to trace back to origin of function but having a tool can be handy sometimes.

Note:- As this is my first project in Rust, so its a possibility that I have done certain things differently than it should be

So lets start

Create A New Package:

For starting a new package we do cargo new, as this is a binary program so

cargo new locate --bin

This creates a folder structure like

.
├── Cargo.toml
└── src
    └── main.rs

1 directory, 2 files

Packages We Need:

fstream = "0.1.2"
walkdir = "2.3.1"
argparse = "0.2.2"
colored = "1.9"

fstream: It will be used to read file
walkdir: This will be used to iterate over all the folders and files
argparse: Its a simple argparser to parse arguments
colored: Will be used to colorize the terminal output

Add these to your cargo.toml:

Now our cargo.toml will look something like

[package]
name = "locate"
version = "0.1.0"
authors = ["Prakhar <b118038@iiit-bh.ac.in>"]
description = "A tool to search all the occurrences of a string in all the files in directory"
readme = "README.md"
repository = "https://github.com/pr4k/locate"
license-file = "LICENSE"
keywords = ["cli","search","rust"]
edition = "2020"

# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

[dependencies]
fstream = "0.1.2"
walkdir = "2.3.1"
argparse = "0.2.2"
colored = "1.9"

Main Code:

Our basic workflow will be first we will take path and query from user.
Then we need a function to iterate over all the folders in the path and check whether the query string is present in any file ,
If so the path of file will be passed to another function where the exact location of query string will be located.

Walking directory is easy as we will be using walkdir for that.

**Code for checking dir:**

fn check_dir(path: &str, query: &str) {
    let mut total_files_scanned = 0;
    for (fl_no, e) in WalkDir::new(path)
        .into_iter()
        .filter_map(|e| e.ok())
        .enumerate()
    {
        if e.metadata().unwrap().is_file() {
            match fstream::contains(e.path(), query) {
                Some(b) => {
                    if b {
                        check_file(e.path(), query);
                    }
                }
                None => println!("Error in walking Dir"),
            }
        }
        total_files_scanned = fl_no;
    }

    println!(
        "Total Scanned files {}",
        total_files_scanned.to_string().bold()
    );
}

We create a new Walkdir on the path given and apply a filter to silence the permission error.

Next we check if the iter is a file then we are using fstrem to check whther the query string is in the file or not.

Once we get the file having query, its passed to another function which locates the exact line number.

**Code for Checking file:**

fn check_file(file_path: &Path, query: &str) {
    println!(
        "In file {}\n",
        file_path.display().to_string().magenta().italic()
    );
    match fstream::read_lines(file_path) {
        Some(s) => {
            for (pos, s) in s.iter().enumerate() {
                if s.contains(query) {
                    print!("{}", "Line ".green().bold());
                    print!("{0: <6} ", pos.to_string().cyan());
                    println!("=> {}", s.trim().blue());
                }
            }
        }
        None => println!("Error in reading File"),
    }
    println!("");
}

Its simple, we are reading the whole file line by line and as it returns a string vector, we can easily iterate over each line and check if the query string is present or not.

If present we are simply printing it, There is formatting for print, like .green(), .bold() etc which is done with the help of colored crate we imported earlier.

That's all, we have code for both part, reading file and finding file.

What's left is to parse arguments from command line. The library argparser is inspired by argparse in python.

**Code for Argparse:**

fn main() {
    let mut path = ".".to_string();
    let mut query = "query".to_string();
    {
        let mut ap = ArgumentParser::new();
        ap.set_description("Recursive string locater in files");
        ap.refer(&mut path)
            .add_option(&["-p", "--path"], Store, "Path to folder");
        ap.refer(&mut query)
            .add_option(&["-q", "--query"], Store, "Query string to find")
            .required();
        ap.parse_args_or_exit();
    }
    println!(
        "Searching '{}' in {}\n",
        query.green().bold(),
        path.italic()
    );
    check_dir(&path, &query);
}

It is also pretty simple, we are creating two mutable varibale (Variable in rust are by default immutable), then we will be creating a new Argpaser object, set its description and create our options. The best thing is, it automatically generates the help message using our description for each option.

Done, Lets try it !!

Type cargo build You will find a binary created in target/debug,
You can run it directly by cargo run or using the binary you just created.

DEMO

Here is the source code

pr4k / locate

A Recursive Search tool in Rust

Key Features • Usage • Test Run • Demo • Installation • To-Do • License

A recursive Search Tool written in Rust

How many times have you gone through files in search of a string, or finding origin of a function.

Locate is a tool written in Rust which goes through each file and gives exact location of the string in the file.

Key Features

Works on Windows, MacOS and Linux
Blazing Fast
Finds String Deep Inside Directory Structure

Installation

# Clone the repo
git clone https://github.com/pr4k/locate
# Build the project
cargo build --release

It will create a binary in target/release, copy it to /usr/bin and you are good to go.

Or simply do

cargo install locate

Give it a Test Run

Don't want to clone the project, No worries!!

Go to the releases and downlaod the latest release, copy it to /usr/bin that's all.

Usage

➜  ~

…

View on GitHub

drop a start if you like it!!
Also if you don't want to do all this, you can install it directly using
cargo install locate

or checkout at cargo@locate

Thanks for Reading
Happy Coding

How I use Stackoverflow from Terminal - Go

Prakhar Kaushik — Sun, 22 Mar 2020 18:12:42 +0000

Around a month ago I came across a project howdoi created in python. And honestly it was amazing, finding solution of basic problems without opening browser was a life saver, so I thought of creating one for myself. As one of my major goal was speed ,so I went with Go lang.

So today, let me show you how to use Stackoverflow using just a terminal.

Create Go Environment

I won't go in details about how to install Go or how the directory structure should look. You can find everything on the official page and the docs.

Official Installation Docs

What All We Need to Create

A scraper to get the posts using search query
A scraper to get the contents for each question
A UI to display the solution

Get Result for Search Query

A general Stackoverflow search url looks somthing like

https://stackoverflow.com/search?q=how+to+add+2+numbers

This makes it easy for us to get the result as what we need to change everytime is just the part after search?q=

After getting the content of page our next job is to get content from correct elements to get Title, Description, Link to Post and Up Votes.
For that first we need to create a Struct to store these data.

type post struct {
    title       string
    link        string
    upvotes     string
    description string
}

for getting content of page we will be using GoQuery Library

So the code snippet for getting the data from search is

res, err := goquery.NewDocument(fmt.Sprintf("https://stackoverflow.com/search?q=%s", strings.ReplaceAll(query, " ", "+")))
    if err != nil {
        log.Fatal(err)
    }

The question is stored in div with class question-summary So we will iterate on each element with this class and get required details from the div.

Class for

post link is .result-link
question description is .excerpt
upvotes count is .vote-count-post
title is same as link tag, all we need is to get the text for a tag

After getting all content we will store the data in list of posts struct

The final source code for getting the data will look something like

func searchPost(query string) []post {
    res, err := goquery.NewDocument(fmt.Sprintf("https://stackoverflow.com/search?q=%s", strings.ReplaceAll(query, " ", "+")))
    if err != nil {
        log.Fatal(err)
    }

    var items []post
    res.Find(".question-summary").Each(func(index int, item *goquery.Selection) {
        linkTag := item.Find(".result-link").Find("a")
        link, _ := linkTag.Attr("href")
        title := strings.TrimFunc(linkTag.Text(), func(r rune) bool {
            return !unicode.IsLetter(r) && !unicode.IsNumber(r)
        })
        description := item.Find(".excerpt").Text()
        upvotes := item.Find(".vote-count-post").Text()
        //fmt.Println(link)
        if true || (strings.HasPrefix(title, "Q:") && index < 4) {
            items = append(items, post{title, link, upvotes, description})
            index++
        }
    })
    return items

After this we are done with getting the content of search page and storing in our array.
Next part will be getting content for each question and storing it in another array

Get Each Post Content

We have url for each post stored in the array from previous section, our next job is to go on each of these links and get content for that page and store it in another array.

So the stackoverflow page for answer has 2 parts , A question section and a list of solutions. We will get each solution and store it in another array and return the answers along with the accepted answer
This will be same as previous part.
Struct we will be using for this part will be

type solution struct {
    description string
    upvotes     string
}

So the class for question is .question and for accepted answer it is accepted-answer

After this remaining answers will be scraped using the relative div from accepted answer div

code for getting the question content is


    var answers []solution
    question := res.Find(".question").Find(".post-layout")
    answers = append(answers, solution{strings.Trim(question.Find(".post-text").Text(), "\n"), question.Find(".js-vote-count").Text()})

code for getting the accepted answer is


    acceptedContainer := res.Find(".accepted-answer").Find(".post-layout")
    acceptedAnswer := solution{strings.Trim(acceptedContainer.Find(".post-text").Text(), "\n"), acceptedContainer.Find(".js-vote-count").Text()}

and finally for getting remaining answers

if (acceptedAnswer != solution{}) {
        res.Find(".accepted-answer").NextAll().Each(func(index int, item *goquery.Selection) {

            if item.Find(".post-text").Text() != "" {
                answers = append(answers, solution{strings.Trim(item.Find(".post-text").Text(), "\n"), item.Find(".js-vote-count").Text()})
            }
        })
    } else {
        res.Find(".post-layout").Each(func(index int, item *goquery.Selection) {

            if item.Find(".post-text").Text() != "" {
                answers = append(answers, solution{strings.Trim(item.Find(".post-text").Text(), "\n"), item.Find(".js-vote-count").Text()})
            }
        })
    }

So after combining everything we will get

func getPost(node post) (solution, []solution) {
    urlString := fmt.Sprintf("https://stackoverflow.com/%s", node.link)
    res, err := goquery.NewDocument(urlString)
    if err != nil {
        log.Fatal(err)
    }

    var answers []solution
    question := res.Find(".question").Find(".post-layout")
    answers = append(answers, solution{strings.Trim(question.Find(".post-text").Text(), "\n"), question.Find(".js-vote-count").Text()})

    acceptedContainer := res.Find(".accepted-answer").Find(".post-layout")
    acceptedAnswer := solution{strings.Trim(acceptedContainer.Find(".post-text").Text(), "\n"), acceptedContainer.Find(".js-vote-count").Text()}

    if (acceptedAnswer != solution{}) {
        res.Find(".accepted-answer").NextAll().Each(func(index int, item *goquery.Selection) {

            if item.Find(".post-text").Text() != "" {
                answers = append(answers, solution{strings.Trim(item.Find(".post-text").Text(), "\n"), item.Find(".js-vote-count").Text()})
            }
        })
    } else {
        res.Find(".post-layout").Each(func(index int, item *goquery.Selection) {

            if item.Find(".post-text").Text() != "" {
                answers = append(answers, solution{strings.Trim(item.Find(".post-text").Text(), "\n"), item.Find(".js-vote-count").Text()})
            }
        })
    }

    return acceptedAnswer, answers
}

Build the UI

So we have Everything we need, Question list from search page and then solution for each post , Now we need to display the content in a UI.
what we will be trying to obtain is 2 parts, one for question and other one for the question description.

So the library we will be using is termui.
Our UI will have 3 sections , one for question list, other for question description and the last for the possible solution and we will display 2 sections at a time
Now I won't cover the whole library as we only need some parts of it.

So for creating a box with paragraph inside we have a widget already provided in the library, but the problem with it is we can't scroll it , so for that we will create our own paragraph widget.

The source code for the widget is

For struct

type Paragraph struct {
    Block
    Text      string
    TextStyle Style
    WrapText  bool
    start     int
    end       int
}

and the remaining code base


func NewParagraph() *Paragraph {
    return &Paragraph{
        Block:     *NewBlock(),
        TextStyle: Theme.Paragraph.Text,
        WrapText:  true,
    }
}

func (self *Paragraph) Draw(buf *Buffer) {
    self.Block.Draw(buf)

    cells := ParseStyles(self.Text, self.TextStyle)
    if self.WrapText {
        cells = WrapCells(cells, uint(self.Inner.Dx()))
    }

    rows := SplitCells(cells, '\n')
    if self.end-self.start <= len(rows) {
        if self.end > len(rows) {
            self.end = len(rows)
            self.start = self.end - 40
        }

        if self.start <= 0 {
            self.start = 0
            self.end = 40
        }
        rows = rows[self.start:self.end]
    }
    for y, row := range rows {
        if y+self.Inner.Min.Y >= self.Inner.Max.Y {
            break
        }
        row = TrimCells(row, self.Inner.Dx())
        for _, cx := range BuildCellWithXArray(row) {
            x, cell := cx.X, cx.Cell

            buf.SetCell(cell, image.Pt(x, y).Add(self.Inner.Min))
        }
    }
}

Now explaining the whole code will be an another article, but to give you people a gist, it basically takes the style we specified and create cells, then it takes the whole text and breaks it into lines and then iterating on each line , drawing it into the cell we specified above, and placing it at the correct position.

The part which is important is

    if self.end-self.start <= len(rows) {
        if self.end > len(rows) {
            self.end = len(rows)
            self.start = self.end - 40
        }

        if self.start <= 0 {
            self.start = 0
            self.end = 40
        }
        rows = rows[self.start:self.end]
    }

This part handles the content scrolling, what this is doing is we provide 2 values one is start and other one is end. Then it uses those values to slice the array, so that we draw only a part of the whole content on screen.This start and end value will change on each key press so the content will look like its scrolling.

So the rest of the part is pretty straight forward, we will be using this newly created widget and create 3 boxes with different content.
I won't display the code of this part here as it will make the post unnecessarily long, instead I will explain the flow.
So we will first create 3 paragraphs

Example code :

    quesBox := NewParagraph()

    quesBox.Title = "Question Description"
    quesBox.SetRect(width/2, 4, width, height-4)
    quesBox.start = 0
    quesBox.end = 44
    quesBox.WrapText = true
    quesBox.BorderStyle.Fg = ui.ColorYellow

And then the only task would be to render correct box on correct key press.
So termui provides few functions like Render to render particular element and a whole keyboard binding to refer each key.
Example code:

uiEvents := ui.PollEvents()
    for {
        e := <-uiEvents
        switch e.ID {
        case "q", "<C-c>":
            return

So this handles the closing of Ui if someone presses q or ctrl-c, we can add other cases to render correct Box on key press.

So the final thing will work something like

You can find the whole source code at:-

Forem: Prakhar Kaushik

Github Action for Auto Publishing My Articles from Hugo blog to Medium

My Workflow

Submission Category:

Yaml File or Link to Code

pr4k / hugo-to-medium

Github action to directly post from hugo to medium

hugo-to-medium

Usage

Example:

Creating main.yml

Additional Resources / Info

How I Use My Terminal as a Webcam

Step 1

Step 2

torrycrass / image-to-ansi

A Python based Image to ANSI converter

Step 2

Final Demo

Feedback

pr4k / Te-We

Te-We is a Terminal Webcam Client which can be used to use your webcam using terminal

Locate: A Recursive Search Tool - RUST

Motivation

Create A New Package:

Packages We Need:

Main Code:

Code for checking dir:

Code for Checking file:

Code for Argparse:

DEMO

pr4k / locate

A Recursive Search tool in Rust

Key Features

Installation

Give it a Test Run

Usage

How I use Stackoverflow from Terminal - Go

Create Go Environment

What All We Need to Create

Get Result for Search Query

Get Each Post Content

Build the UI

pr4k / howto

Terminal client for stack overflow

**Code for checking dir:**

**Code for Checking file:**

**Code for Argparse:**