DEV Community: Kacha

30 Days of Go: Pointers and Structs

Kacha — Sun, 24 Apr 2022 21:33:20 +0000

Learning Update

This post covers days 4, 5, and six of my 30 days of Golang journey. I was not able to cover a whole lot because sometimes life gets in the way. What I was able to cover was quite important though. It was the last step I needed before trying to create an application.

These are my notes on Go's pointers and Structs.

Pointers

Go pointers allow you to pass references to values within a program. An example of this would be as follows.

package main

import "fmt"

// This is a regular function in Go
// It has a regular integer argument
func nonPointerFunc(val int) {
    val = 0
}

// This function takes a pointer as an argument
// This is denoted by the *int, this means pval is a pointer to an integer value
func pointerFunc(pval *int) {
    // The * infront of pval dereferences the pointer so that we can work with the
    // value that the pointer references
    *pval = 0
}

func main() {
    // Initialize a value
    x := 1
    // Pass the value to nonPointerFunc
    nonPointerFunc(x)
    // After execution print the value of x and you will find it is 1
    fmt.Println("Value after non pointer function: ", x)

    // Pass a pointer to x into pointerFunc
    // To get a pointer to a function use the syntax &value
    // &x is the pointer for x
    pointerFunc(&x)
    // Print x after the execution and you will get a value of 0
    fmt.Println("Value after pointer function:", x)

    // To see the pointer itself you can print it out this way.
    fmt.Println("Pointer ", &x)
}

To understand pointers better I watched this very helpful video by Junmin Lee. She explains Golang's stack and heap to illustrate how pointers work. These are the takeaways I got based on my understanding:

When you pass an argument into a Go function e.g calling a function from the main function. Go will create a copy of it and that copy is what will be used for computations within the called function. The variable that was passed in from main will remain unchanged.
Passing a pointer of a value into a function will not create a copy of the value. The value referenced by the pointer is what will be modified by the function.
Using pointers is more efficient because it does not create copies of variables. By using pointers we are giving up immutability for efficiency. To understand this better I will do more research and write a blog post on this.

Structs

Structs are typed collections of fields. Go uses structs to group data together to form records.

Creating a struct

type macbook struct {
    model string
    price int
}

// creating a variable with the struct
air = macbook{"M1 air 8gb", 1000}
pro = macbook{model: "M1 pro 32gb", price:2000}
// Fields that have been ommitted will be zero-valued
proMax = macbook{price: 3500}

// struct fields can be accessed with a dot
fmt.Println(pro.model)

// dots can also be used with a struct pointer, the pointer will be automatically
// dereferenced
// Note that structs are mutable so updating the pointer will also update the initial value

sp := &air
fmt.Println(sp.price)

To write more idiomatic Go constructor functions are used to create new structs.

func newMacbook(model string, price int) *macbook {
    m := macbook{model: model, price: price}
    m.price = 1000
    return &m
}

Returning the pointer of a local variable is allowed because it will survive the scope of the function. To use this constructor function we write this line of code.
I need to read more on stack and heap allocation with this type of constructor function.

mini = newMacbook("M1 mini 8gb", 700)
fmt.Println(mini)

Methods

Go allows for methods on struct types. These methods are defined as follows:

type rect struct {
    width, height int
}

// golang methods can have pointer recivers
func (r *rect) area() int {
    return r.width * r.height
}

// golang methods can have value recivers
func (r rect) perim() int {
    return 2*r.width + 2*r.height
}

func main() {
    r := rect{width: 20, height: 10}

    // Go automatically handles conversion between values and pointers for method calls.
    rp := &r
    fmt.Prinln("area: ", rp.area())
}

Pointer receiver types can be used to avoid copying on method calls. They also allow the method to mutate the receiving struct.

What next

I have gone through quite a few basics and now would like to learn by actually building something. The first thing I'm going to do is exercise one from the gophercises website. The exercise is to build a quiz game. The game reads questions and answers from a CSV and allows a user to answer them from the terminal.

I'll be documenting building this over the next few days.

30 Days of Go: Day 2 and 3

Kacha — Wed, 20 Apr 2022 20:41:12 +0000

How it's going

This is my log update for my golang learnings for days two and three. I've been itching to actually start building something. I'm getting pretty close to that point. But before that I'd like to go through functions, methods and structs. Once that's done I'll start going a little in depth with building a few simple toy applications.

Day 2

I got quite a bit done on this day.

Data structures

Arrays

Arrays in Go work like they do in a language like Java. All arrays need a type and size when they are declared.
All values in an initialized array are zero-valued

var array [40]int

// Declare and initialize
array2 := [5]int{1, 3, 4, 5, 6}

// Access an index in the array
fmt.Println(array[20])

// add something to an index in the array
array[10] = 300

// get the size of the array
fmt.Println(len(array))

Golang has 2D arrays. These are composed in the following way

var twoD [4][9]int
for i := 0; i < 4; i++ {
    for j := 0; j < 9; j++ {
 twoD[i][j] = i + 
    }
}

Slices

A slice is a data structure that works like an array with a variable size. It is like an arraylist in Java or a list in python (with the caveat that all items in the slice have to be of the same type).
To initialize a slice Go has a builtin function make

// Create a slice pass the type and initial size to make
sl := make([]string, 3)

// Declaring and initializing a slice
t := []string{"ab", "bc", "cd"}

// Access an item in a slice
fmt.Println(sl[2])

// set an index in a slice
sl[1] = "Hello"

To add more items in a slice use the builtin function append. The append function takes a slice and a value that you would like to add to that slice and returns a new slice

sl = append(sl, "new")

Slices can be copied using the builtin copy function

// Create a new slice with the length of the slice you want to copy
c := make([]string, len(sl))
// copies sl into c
copy(c, sl)

slices support slicing, like python lists

// creates a nes slice from index 1 to 2
newSlice := sl[1:3]
// creates slice from index 0 to 3 (excluding 4)
newSlice = sl[:4]
// slice from index 2 to the last one
newSlice = sl[2:]

slices support multidimensional data structures. The length of the inner slice can be variable.

twoD := make([][]int, 3)
for i := 0; i < 3; i++ {
    innerLen := i + 1
    twoD[i] = make([]int, innerLen)
    for j := 0; j < innerLen; j++ {
 twoD[i][j] = i + j
    }
}

// result = [[0] [1 2] [2 3 4]]

Maps

These are key/value associative data structures like python dicts
Use make to create an empty map

m := make(map[string]int)

// declare and initialize a map
m2 := map[string]int{"foo": 4, "bar": 40}

// set key/value pairs
m["one"] = 2
m["two"] = 3

// get a value with a key
v := m["one"]

// get number of key/value pairs
fmt.Println(len(m))

// To delete a key value pair use builtin function
delete(m, "two")

A second value is returned when getting from a map, value, prs := map[key]. prs will be true if the key is in the map and false if it isn't

_, prs := m["two"]

Blank identifier _ is used when a value is not needed. This is necessary because Go requires that you use every variable that has been declared.

Range

In Go we can use a range to iterate over data structures like arrays, slices, maps and strings

// array, slices
for index, value := range array {
    fmt.Println(value)
}

//map 
for key, value := range exMap {
    fmt.Printf("%s -> %s\n", key, value)
}

// iterate over map keys only
for key := range exMap {
    fmt.Println(key)
}

// iterate over strings
for index, ru := range "Golang" {
    fmt.Println(ru)
}

Day 3

I didn't get through as much today but still interesting things were coverd.

Functions

Functions can have multiple return values. These functions are usually used to return the result and error values from a function
Variadic functions can be called with any number of arguments
Functions are defined in the following way:

// function structure
// function name(arguments) return type {}
func sayHello(name string) string {
    return "Hello " + name 
}
// call the function sayHello("Kacha")

// function with multiple return values
func names() (string, string) {
    return "Scott", "Ramona"
}

// variadic function
func add(nums ...int) {
    total := 0
    for _, num := range nums {
 total += num
    }
    return total
}

Go also supports anonymous functions which can form closures. I do not quite understand closures quite yet so I'll have that in a different blog post.

...

I want to try and blog on each day but that might not be possible so I will blog my progress at least every two or three days.

30 Days of Go: Day 1

Kacha — Mon, 18 Apr 2022 15:46:17 +0000

Introduction

I have decided to take part in a challenge to learn Golang in the next 30 days. I found a Go hackathon and thought this is the perfect opportunity because I have wanted to learn it for a while now. I have decided to split this learning up in a couple of ways. The idea is to build an application for the hackathon. My current app idea is a citizen science API. This API will allow users to upload photos of animals such as birds or insects.

I have split my learnings into the following categories:

Weeks 1 & 2: Learn the syntax and basics of Golang and do the gophercises
Week 3 & 4: Build out the API

Golang syntax

This information is referenced Golang documentation and especially Go by example.

Variables

Golang's variables are explicitly declared like C#, Java
Golang allows multiple variables to be declared in one line
If the type has not been specified go will infer the types from initialized values

var a = "Hello world"
var age int = 8
// When the type has been declared it is used for both variables
var name, game string = "Scott Pilgrim", "vs The world"
// This is allowed because go will infer the types from initialization
var name, age = "Knives Chau", 18

Variables that are declared but not initialized will be zero-valued
All declared but not initialized variables must have a type

var one int
// one = 0
var decision bool
// decision = false
var word string
// word = ''

:= is shorthand for declaring and initializing a variable e.g

num := 50

Constants

Constants in Go work the same as in other languages. A const can be a string, character, bool, or numerical type.

const test string = "Steven Stills"

Numerical constants perform arithmetic with arbitrary precision
A numerical constant has no type until it is given one from a function or is cast to a type

Flow Control

Loops

Go only has for loops and they can be initialized in the following ways:

i := 0
for i <= 4 {
    fmt.Println(i)
    i = i + 1
}

for j := 4; j <=8; j++ {
    fmt.Println(j)
}

infinite loops have no conditions and can be stopped with a break statement

for {
    fmt.Println("The infinite sadness")
    break
}

the continue keyword can be used to go to the next iteration of a loop

for i :=3; i <= 33; i++ {
    if i % 3 == 0 {
 continue
    }
    fmt.Println("Love evans")
}

If else

If else blocks are like most other programming languages
Parenthesis are not needed in the if statement but braces are

if x == 3 {
    fmt.Println("Young Neil")
} else if x > 5 {
    fmt.Println("Neil")
} else {
    fmt.Println("Meh")
}

Go's if block can have a statement before the condition. Any variable declared in the statement can be used in all the branches of the if block.

if x := 4; x < 0 {
    fmt.Println(x)
} else if x > 1 {
    fmt.Println("True")
} else {
    fmt.Println("Do something else")
}

Go has no ternary if statements like javascript x == 2? "Yes": "No"

Switch statements

A switch statement in Go is like other programming languages
The default case is optional
Cases can have multiple expressions
a switch can have no expressions which will make it function like an if statement

switch i {
case 1:
    fmt.Println("One")
case 2:
    fmt.Println("Two")
case 3, 4, 5:
    fmt.Println("Others")
default:
    fmt.Println("Default is optional")
}

// Swtich with no condition
t := 5
switch {
case t < 4:
    fmt.Println("Less than 4")
default:
    fmt.Println("Else")
}

A type switch compares types instead of values
Use this switch to discover an interface's type
Using .(type) does not work outside a type switch

myType := func(i interface{}){
    switch t := i.(type){
    case bool:
 fmt.Println("Im boolean")
    case int:
 fmt.Println("Im integer")
    default:
 fmt.Println("Im anything else")
    }
}

This was a fruitful first day and there's more to come.

Speech to text tool for all: Deepgram x DEV Hackathon

Kacha — Mon, 11 Apr 2022 20:59:31 +0000

Overview of My Submission

My submission for the Deepgram Hackathon is a simple web application that can be used to interact with Deepgram's various features. Upload an audio file and get a transcript for it, remove profanity from the script or just search the audio and much more.

This application is a small tool to make it easier for anyone who want's to interact with Deepgram api's.

Submission Category:

Wacky Wildcards, Accessibility Advocates

Link to Code on GitHub

kachaMukabe / deepgram-for-all

Deepgram-for-all

This project was built for the Deepgram x Dev.to hackathon.

It creates a web app that allows a user to interact with the deepgram api with a web interface created with python and streamlit.

How it works

View on GitHub

Additional Resources / Info

Creating a todo web app in < 112 lines of code with Hasura and Python

Kacha — Tue, 29 Mar 2022 15:30:29 +0000

Introduction

I created this application for the Hashnode Hasura hackathon. I had some trouble thinking of an application to create. I got over my indecision by reading this post. A todo app is a valid application so that is what I made.

Built with

Hasura
Python
Streamlit

Setting up the backend

The backend of the application is developed with Hasura and Postgres. Doing this is really easy by following Hasura's official documentation at this link here. It is really easy to follow along but let's summarize the steps we can take to get our app up and running.

Hasura setup

Create a Hasura account and create a new project
Once the project has been created launch the project console. On the console click on the option to create a Heroku database.
Create the Users table in the launched Hasura console here
Create the Todos table in the Hasura console here
Create the foreign key relationships between the user and the todos here

Connecting our app to Hasura

Once we have our Hasura backend set up we can connect our Streamlit app to it. To do so we will need a GraphQL library to allow us to make GraphQL requests from python. Install the following libraries.

gql: Allows us to create GraphQL queries and mutations and requests from an API
aiohttp: This allows us to create asynchronous methods
dotenv: Allow us to read env files

pip install gql 
pip install aiohttp

Once installed create a main.py file and add the following code:

import streamlit as st
import os
from gql import gql, Client
from gql.transport.aiohttp import AIOHTTPTransport
from dotenv import load_dotenv

load_dotenv()


headers = {'x-hasura-admin-secret': os.environ["HASURA_ADMIN_SECRET"] }
transport = AIOHTTPTransport(url="https://curious-sailfish-33.hasura.app/v1/graphql", headers=headers)
client = Client(transport=transport, fetch_schema_from_transport=True)

First import all the required modules from the libraries we have installed.

Create headers that will be used in all the requests we make. Use a Hasura admin secret that you can get from your Hasura dashboard.

We will use an async transport protocol in our client to interact with our GraphQL endpoint.

CRUD operations

In our main.py we will create four methods to interact with our todos api.

Read Todos

def get_todos():
    query = gql(
        """
        query getTodos {
            todos {
                id
                title
                is_completed
            }
        }
        """
    )
    result = client.execute(query)
    return result["todos"]

# Save all todos into our streamlit session for use in the application
if 'todos' not in st.session_state:
    st.session_state['todos'] = get_todos()

Create a query to get all todos from our database. Save them to our local state to be used in the Streamlit application.

Create Todos

def create_todo(todo):
    query = gql(
        """
        mutation createTodo($title: String!, $user_id: String!) {
            insert_todos_one(object: {title: $title, user_id: $user_id }){
                id
                title
                is_completed
            }
        }
        """
    )
    params = {"title": todo, "user_id": "1"}

    result = client.execute(query, variable_values=params)
    todo = result['insert_todos_one']
    st.session_state.todos.append(todo)
    return result

Create a todo using a todo mutation and save the created todo into our session variable.

Update Todos

def update_todo(todo):
    query = gql(
        """
        mutation updateTodo($id: Int!, $is_completed: Boolean!){
            update_todos(where: {id: {_eq: $id}}, _set: {is_completed: $is_completed}){
                affected_rows
            }
        }
        """
    )
    params = {"id": todo["id"], "is_completed": not todo["is_completed"]}

    result = client.execute(query, variable_values=params)
    return result

Update a todo using an update mutation.

Delete Todos

def delete_todo(todo):
    query = gql(
        """
        mutation deleteTodo($id: Int!){
            delete_todos(where: {id: {_eq: $id}}){
                affected_rows
            }
        }
        """
    )
    params = {"id": todo["id"]}
    result = client.execute(query, variable_values=params)
    st.session_state.todos.remove(todo)
    return result

Finally a method to delete a todo and delete it from our local state as well.

Setting up the frontend

To set up the web application frontend I used the streamlit library . This library turns python scripts into a web application.

Let's set up the web front end:

st.title("My todos")
with st.form(key="my_form", clear_on_submit=True):
    new_todo = st.text_input("Create a todo", value="")
    submit = st.form_submit_button("Create")
    if submit:
        create_todo(new_todo)

todos = st.session_state.todos
not_done = [todo for todo in todos if not todo["is_completed"]]
completed = [todo for todo in todos if todo["is_completed"]]
st.subheader("Not Completed")
for todo in not_done:
    col1, col2 = st.columns([3, 1])
    col1.checkbox(todo["title"], key=todo["id"])
    col2.button("delete", key=todo["id"], on_click=delete_todo, args=(todo, ))
st.subheader("Completed")
for todo in completed:
    st.checkbox(todo["title"], key=todo["id"], value=todo["is_completed"], on_change=update_todo, kwargs={"todo": todo})

Let us go through these lines of code:

st.title("My todos")

This creates a heading on the web page. We then create a form that will allow a user to input a new todo. To do this we use Streamlit's form component.

# Clear on submit clears the input once a user 
with st.form(key="my_form", clear_on_submit=True)
    new_todo = st.text_input("Create a todo", value="")
    submit = st.form_submit_button("Create")
    # when a user submits a todo we call the function create todo
    if submit:
        create_todo(new_todo)

Streamlit allows for state management between each run of the web script. We will save all the todos that we call from our Hasura backend.

todos = st.session_state.todos
# split the todos into done and incomplete
not_done = [todo for todo in todos if not todo["is_completed"]]
completed = [todo for todo in todos if todo["is_completed"]]

The final part to the UI is displaying the todos.

st.subheader("Not Completed")
for todo in not_done:
    # Create a grid with streamlit
    col1, col2 = st.columns([3, 1])
    col1.checkbox(todo["title"], key=todo["id"])
    # A delete button calls the delete_todo method when clicked
    col2.button("delete", key=todo["id"], on_click=delete_todo, args=(todo, ))
st.subheader("Completed")
for todo in completed:
    st.checkbox(todo["title"], key=todo["id"], value=todo["is_completed"], on_change=update_todo, kwargs={"todo": todo})

Putting it all together

Adding all the code snippets for the project:

import streamlit as st
import os
from gql import gql, Client
from gql.transport.aiohttp import AIOHTTPTransport
from dotenv import load_dotenv

load_dotenv()


def get_gql_client(extra_headers=None):
    headers = {'x-hasura-admin-secret': os.environ["HASURA_ADMIN_SECRET"] }
    if extra_headers:
        headers += extra_headers
    transport = AIOHTTPTransport(url="https://curious-sailfish-33.hasura.app/v1/graphql", headers=headers)
    client = Client(transport=transport, fetch_schema_from_transport=True)
    return client

headers = {'x-hasura-admin-secret': os.environ["HASURA_ADMIN_SECRET"] }
transport = AIOHTTPTransport(url="https://curious-sailfish-33.hasura.app/v1/graphql", headers=headers)
client = Client(transport=transport, fetch_schema_from_transport=True)


def get_todos():
    query = gql(
        """
        query getTodos {
            todos {
                id
                title
                is_completed
            }
        }
        """
    )
    result = client.execute(query)
    return result["todos"]


if 'todos' not in st.session_state:
    st.session_state['todos'] = get_todos()


def create_todo(todo):
    query = gql(
        """
        mutation createTodo($title: String!, $user_id: String!) {
            insert_todos_one(object: {title: $title, user_id: $user_id }){
                id
                title
                is_completed
            }
        }
        """
    )
    params = {"title": todo, "user_id": "1"}

    result = client.execute(query, variable_values=params)
    todo = result['insert_todos_one']
    st.session_state.todos.append(todo)
    return result


def update_todo(todo):
    query = gql(
        """
        mutation updateTodo($id: Int!, $is_completed: Boolean!){
            update_todos(where: {id: {_eq: $id}}, _set: {is_completed: $is_completed}){
                affected_rows
            }
        }
        """
    )
    params = {"id": todo["id"], "is_completed": not todo["is_completed"]}

    result = client.execute(query, variable_values=params)
    return result


def delete_todo(todo):
    query = gql(
        """
        mutation deleteTodo($id: Int!){
            delete_todos(where: {id: {_eq: $id}}){
                affected_rows
            }
        }
        """
    )
    params = {"id": todo["id"]}
    result = client.execute(query, variable_values=params)
    st.session_state.todos.remove(todo)
    return result


st.title("My todos")
with st.form(key='my_form', clear_on_submit=True):
    new_todo = st.text_input("Create a todo", value="", key="d")
    submit = st.form_submit_button("Create")
    if submit:
        create_todo(new_todo)

todos = st.session_state.todos
not_done = [todo for todo in todos if not todo["is_completed"]]
completed = [todo for todo in todos if todo["is_completed"]]
st.subheader("Not Completed")
for todo in not_done:
    col1, col2 = st.columns([3, 1])
    col1.checkbox(todo["title"],key=todo["id"], value=todo["is_completed"], on_change=update_todo, args=todo)
    col2.button("Delete", key=todo["id"], on_click=delete_todo, args=(todo, ))
st.subheader("Completed")
for todo in completed:
    st.checkbox(todo["title"],key=todo["id"], value=todo["is_completed"], on_change=update_todo, kwargs={"todo": todo})

Deploy the application

To deploy our application create a requirements.txt file in our folder and add the following:

aiohttp
streamlit
python-dotenv
gql

We then push this repo to Github.

Sign up for an account on Streamlit and link it to your GitHub account. Create a new application and select the repository that was pushed. Streamlit will allow you to pick the branch and the file that the application will run from.

Click on Advanced settings to add our environment variables. This is where we will add the Hasura admin secret.

Once saved hit deploy and viola your application is ready to be used and shared.

What I learned

I learned quite a bit during this hackathon, it was my first time using Hasura. The following are a few things that I learned:

Creating a Hasura GraphQL backend
Connecting a Hasura API to python
Local state in a python Streamlit application
Auth0 for authentication purposes

Things I struggled with

The main thing I struggled with was getting Hasura's authentication with Auth0 to play well with Streamlit. This was more a problem with me trying to fit a triangle peg in a square hole. Streamlit is not a conventional web framework so the concept of a redirect URL does not work with it. I tried to create an API backend authentication using a flask JWT API tutorial here.

I was able to get the sign-up route working fine but logging in was an issue because each JWT I generated was invalid. I'm sure there is something I missed in the documentation but for the life of me, I could not get it to work. I will revisit this and also push the code to my Github page.

Try it out

Find the relevant links below:

Whatsapp chat analyzer web app with Python and Symbl.ai in < 100 lines of code!

Kacha — Thu, 24 Mar 2022 11:41:31 +0000

Creating a Whatsapp Chat analyser web app with Symbl.ai and python in less than 100 lines of code

This application will take an .txt export of a Whatsapp chat. The application will then run conversational analysis on the .txt file. Symbl.ai will then extract information like follow ups, topics and action items.

The application requires the following libraries:

streamlit: This library converts python scripts into web applications.
symbl.ai: This is a conversational A.I library that can get insights from audio and text.

Starting the Streamlit app

Streamlit is a great library I found that can convert python scripts into a web application.

Lets create an application that will accept a whatsapp txt chat file and parse the chat data.

import streamlit as st


chat_file = st.file_uploader("Select chat file")

if chat_file:
    conversation_request = handle_uploaded_file(chat_file)

To handle the file and extract the messages in a format that symbl will understand we need to create a function to do it.

def handle_uploaded_file(file):
    chat = file.read().decode("utf-8")

    # Split each line from the file into a list and strip all whitespace
    lines = chat.splitlines()
    lines = [line.strip() for line in lines]

    messages = []
    cleaned_lines = []

    # If line does not start with a Whatsapp date format [m/d/y, h:m:s am] then append it to the previous line.
    for x in range(len(lines)):
        if lines[x].find("[") == -1:
            cleaned_lines[-1] = f"{cleaned_lines[-1]} {lines[x]}"
            continue
        cleaned_lines.append(lines[x])

    # pares the time, name and message from a line
    for line in cleaned_lines:
        st_dt, en_dt = line.find("["), line.find("]")
        time = line[st_dt:en_dt].replace("[", "")
        name = line[en_dt:].split(":")[0].replace("]", "")
        st_m = line[en_dt:].find(":")
        message = line[en_dt:][st_m:].replace(":", "")

        # Create messages in the format Symbl requires
        messages.append(
            {
            "duration": {"startTime": arrow.get(time, 'M/D/YY, H:mm:ss A').format(), "endTime": arrow.get(time, 'M/D/YY, H:mm:ss A').format()},
            "payload": {"content": message, "contentType": "text/plain"},
            "from": {"name": name, "userId": name},
            }
        )

    return {
        "name": "Chat",
            "confidenceThreshold": 0.6,
            "detectPhrases": True,
            "messages": messages,
    }

Once we have the messages from the handle request file we can analyse it with Symbl.ai

import symbl

...

conversation_object = symbl.Text.process(payload=conversation_request)

Displaying the results

Add some display components using streamlit.

with st.expander("Topics"):
    with st.spinner("Getting topics"):
        topics = symbl.Conversations.get_topics(conversation_id=conversation_id)
    for topic in topics.topics:
        st.write(f"- {topic.text}")

with st.expander("Action Points"):
    with st.spinner("Getting action items"):
        action_items = symbl.Conversations.get_action_items(conversation_id=conversation_id)
    for item in action_items.action_items:
        st.write(f"- {item.text}")

with st.expander("Questions"):
    questions = symbl.Conversations.get_questions(conversation_id=conversation_id)
    for question in questions.questions:
        st.write(f"- {question.text}")

with st.expander("Follow ups"):
    follow_ups = symbl.Conversations.get_follow_ups(conversation_id=conversation_id)
    for follow_up in follow_ups.follow_ups:
        st.write(f"- {follow_up.text}")

The final code file

import streamlit as st
import arrow
import symbl


def handle_uploaded_file(file):
    chat = file.read().decode("utf-8")
    lines = chat.splitlines()
    lines = [l.strip() for l in lines]
    messages = []
    cleaned_lines = []
    for x in range(len(lines)):
        if lines[x].find("[") == -1:
            cleaned_lines[-1] = f"{cleaned_lines[-1]} {lines[x]}"
            continue
    cleaned_lines.append(lines[x])
    for line in cleaned_lines:
        st_dt, en_dt = line.find("["), line.find("]")
        time = line[st_dt:en_dt].replace("[", "")
        name = line[en_dt:].split(":")[0].replace("]", "")
        st_m = line[en_dt:].find(":")
        message = line[en_dt:][st_m:].replace(":", "")
        messages.append(
            {
                "duration": {"startTime": arrow.get(time, 'M/D/YY, H:mm:ss A').format(), "endTime": arrow.get(time, 'M/D/YY, H:mm:ss A').format()},
                "payload": {"content": message, "contentType": "text/plain"},
                "from": {"name": name, "userId": name},
            }
        )
    return {
        "name": "Chat",
            "confidenceThreshold": 0.6,
            "detectPhrases": True,
            "messages": messages,
    }


chat_file = st.file_uploader("Select chat file")

if chat_file:
    conversation_request = handle_uploaded_file(chat_file)
    with st.spinner("Analysing Text"):
        conversation_object = symbl.Text.process(payload=conversation_request)
    conversation_id = conversation_object.get_conversation_id()
    st.write(conversation_id)

    with st.expander("Topics"):
        with st.spinner("Getting topics"):
            topics = symbl.Conversations.get_topics(conversation_id=conversation_id)
        for topic in topics.topics:
            st.write(f"- {topic.text}")

    with st.expander("Action Points"):
        with st.spinner("Getting action items"):
            action_items = symbl.Conversations.get_action_items(conversation_id=conversation_id)
        for item in action_items.action_items:
            st.write(f"- {item.text}")

    with st.expander("Questions"):
        questions = symbl.Conversations.get_questions(conversation_id=conversation_id)
        for question in questions.questions:
            st.write(f"- {question.text}")

    with st.expander("Follow ups"):
        follow_ups = symbl.Conversations.get_follow_ups(conversation_id=conversation_id)
        for follow_up in follow_ups.follow_ups:
            st.write(f"- {follow_up.text}")

Screenshots of our final application

What I learned in February

Kacha — Tue, 08 Mar 2022 16:17:44 +0000

In my quest to catalog my developer journey here are a few things I have learned this month.

React/Javascript

Local development of React applications with an express Api can have CORS errors. To solve this React has an option to serve the frontend on the same port as the backend. This is the proxy option that can be set in the React application's package.json file.

To do this open your react package.json file and add the following option:

    "proxy": "http://localhost:<EXPRESS PORT>"

To read more on this read the React documentation here.

Python

Running a python module or a script has a subtle difference: -m. To run a python module add the "-m" tag.

So if you have a module like this:

hello/
    __init__.py
    __main__.py
    somescript.py

You can run it like this:

python -m <module-name>
python -m hello

As a note the module-name needs to be the name of the module not a string.

Django

Using Sass with Django.

Install the following libraries

pip install lib sass django-compressor django-sass-processor

Add the Django sass processor to your installed apps in your Django settings. Whilst in the settings add the following static files settings.

INSTALLED_APPS = [
    ...,
    'sass_processor',
    ...
]

STATICFILES_FINDERS = [
    'django.contrib.staticfiles.finders.AppDirectoriesFinder',
    'sass_processor.finders.CssFinder',
]

SASS_PROCESSOR_ROOT = os.path.join(BASE_DIR, 'static')

Pick your UI framework e.g. UIKit, Bootstrap, or Materialize. Copy the sass folder into your static files folder.

Create a main.scss file in the static files folder. This file is the primary way that the sass processor will interact with the sass framework.

In the base template add the following sass tags:

<link href="{% sass_src 'main.scss' %}" rel="stylesheet" type="text/css">

Django Deployment

Deploying an app to the Digital Ocean app platform with static files on digital ocean spaces. This will be a separate blog post.

Village Banking App: A MongoDB Submission Post

Kacha — Wed, 12 Jan 2022 08:30:38 +0000

Overview of My Submission

The inspiration

Village Banking is a phenomenon that has gained popularity in my country and most African countries, there is a version of it in the U.S as well with a different name. Most small village banking groups keep track of their finances in whatsapp messages or by one person. What is village banking you ask?

Village banking is a microcredit methodology whereby financial services are administered locally rather than centralized in a formal bank. Village banking has its roots in ancient cultures and was most recently adopted for use by micro-finance institutions (MFIs) as a way to control costs. Definition from wikipedia

The Solution

The solution to people using excel sheets or tracking the village banking money through messages is a web application that can be used on a mobile phone or desktop.

How I built it

This application started its life as a react native application but was then switched to react to reach more people than a mobile app can.
It is a react app with Material UI for the look and feel. On the mongo side it is a MongoDB Realm application using an atlas database, realm functions and realm triggers.

Challenges I went through

I had a couple of challenges:

I haven't developed in react or react native in over a year so I had to dust of some of the rust
I had a couple of issues understanding how roles affect how you can access data in a mongo db collection from a realm application.
Understanding realm sync destructive changes (the documentation was pretty helpful here)
Time is an ever present challenge, switching halfway through to react certainly took some time and doing it during the Christmas break was not ideal.

Accomplishments I'm proud of

I have a working application integrated with MongoDB Realm
I have deployed a version of the application

Things I learned

MongoDB Realm: Almost everything under realm, Authentication, functions, triggers, Schema and values
React native: It was basically like learning react native again after over 2 years of not developing it.
Integrating libraries like Twilio with MongoDB Realm

What's next for village banking

The following is the roadmap for village banking

Adding loan requests for users of village banking groups
Adding profile editing
Complete the sms and email notifications
Develop a mobile application
Writing up bite sized tutorials on MongoDB Realm.

Submission Category:

My submission is in the Action Star category and uses realm functions and triggers.

To view the deployed demo please check this link

Link to Code

kachaMukabe / village-banking

A web based village banking application

Village Banking

This is a web application for village banking Definition from wikipedia.

Demo

Please find link to project here

Features

Create/Join Village Banking groups
Deposit Money
View deposits for the whole group
Sms notifications using Twilio

Lessons Learned

What did you learn while building this project? What challenges did you face and how did you overcome them?

Roadmap

Adding the ability for group users to request for loans on the app
Profile editing
Email notifications as an alternative for sms
Mobile application

View on GitHub

The realm backend code can also be found in the repository in the folder called backend.

Additional Resources / Info

Used Libraries:
React
MongoDB
Twilio

Screenshots

Digital Hackathon initial

Kacha — Sat, 26 Dec 2020 18:28:06 +0000

What I plan to build

I would like to build a WhatsApp chatbot that responds to all your messages with a quote from a movie or Shakespeare.

What I would like to learn by the end of the hackathon

I would like to learn the following things:

Tailwind Css
Venom: An npm library to create WhatsApp chatbots.

This will be in the random roulette category.

Fun Experiments in React Native

Kacha — Thu, 13 Sep 2018 19:27:32 +0000

I recently found out that I could use processing in a react native app and started to play around with it.

Processing is a visual programming language that makes data visualisations, interactive art and more. To find out more about it you can find it at this link.

To start with I created a simple bouncing ball, to do this a new project will have to be created and processing js will need to be installed.

create-react-native-app BouncingBall npm install --save processing-js expo-processing

Next I set up App.js in preparation for the sketch.

Processing has two methods that are necessary for every sketch, setup() and draw(). Setup is where you put all the code needing in setting up the app and draw is the method that is called every frame of your app.

First I set up some variables needed for the ball i.e velocity, position and gravity. These variables will be Vectors which will hold a 2D x and y value.

Finally I added the code that will draw the ball too the screen and handle it's collisions with the edges of the screen.

The end result:

Game of Life with React Native easy grid

Kacha — Fri, 31 Aug 2018 01:25:27 +0000

I have been learning react native over the past month or two and I decided as a way to learn and familiarise myself with it by making some fun little projects.
For my first project I created Conway's Game of Life using react native easy grid and create-react-native-app. First create a CRNA app and install the grid library.
create-react-native-app GameOfLife && cd GameOfLife
npm install react-native-easy-grid
Then in App.js import easy grid and create the following class:

import React from 'react';
import { StyleSheet, View} from 'react-native';
import {Col, Row, Grid} from 'react-native-easy-grid';
export default class App extends React.Component {
  gridNum = 40; // The number of rows and columns in our grid
  constructor(props){
    super(props);
    let newBoard = this.setupBoard() 
    this.state = {
      board: newBoard
    }
  }
  setupBoard = () => {
    // Create a two dimensional array to represent the grid
    let board = new Array(this.gridNum)
    for (i = 0; i < this.gridNum; i++){
      board[i] = new Array(this.gridNum)
    }
    for(x=0; x< this.gridNum; x++){
      for(y=0; y < this.gridNum; y++){
        // Creates a grid square object that holds a random number 
        // between 0 for a dead cell and 1 for alive 
        // n represents the number of neighbours a cell has
        board[x][y] = {
          cell:Math.floor(Math.random()*2),
          n:0
        }
      }
    }
    return board
  }


  render(){
    return(
      <Grid>
        // Code To be Done
      </Grid>
    );
  }
}

The above code sets up the board, then I created two functions:
To check for the number of neighbours each cell has and,
A function to get the next generation of cells.

checkNeighbours = () => {
  let oldBoard = this.state.board
  // Ignores the columns and rows on the outermost edges
  for(x=1; x< this.gridNum-1; x++){
    for(y=1; y < this.gridNum-1; y++){
      \\ For every grid cell check how many neighbours it has
      for(i=-1; i< 2; i++){
        for(j=-1; j < 2; j++){
          oldBoard[x][y].n += oldBoard[(x+i)][(y+j)].cell
        }
      }
      \\ Delete the value of the current cell as it was counted in  
      \\ the above calculation
      oldBoard[x][y].n -= oldBoard[x][y].cell
    }
  }
  this.setState({board: oldBoard})
}
newBoard = () => {
  let oldBoard = this.state.board
  let board = this.setupBoard()
  // Set all new board values to zero
  for(let a = 0; a < this.gridNum; a++){
    for(let b=0; b<this.gridNum;b++){
      board[a][b] = {cell:0, n:0}
    }
  }
  for(x=1; x< this.gridNum-1; x++){
    for(y=1; y < this.gridNum-1; y++){
      if((oldBoard[x][y].cell == 1) && oldBoard[x][y].n < 2){
        board[x][y].cell = 0
      } else if((oldBoard[x][y].cell == 1) && oldBoard[x][y].n > 3){
        board[x][y].cell = 0
      } else if((oldBoard[x][y].cell == 0) && oldBoard[x][y].n == 3)
      {
        board[x][y].cell = 1
      } else if((oldBoard[x][y].cell == 1)&& (oldBoard[x][y].n == 3 
                 || oldBoard[x][y].n == 2)){
        board[x][y].cell = 1
      } else{
        board[x][y].cell = oldBoard[x][y].cell
      }
    }
  }
  this.setState({board: board})
}
For the game of life to update these two functions above must be called continuously. For this I created a helper function called "run" and used setInterval() to have it called every second.
constructor(props){
  ... // Above code skipped for brevity
  setInterval(this.run, 1000);
}
run = () => {
  this.checkNeighbours()
  this.newBoard()
}

Finally I render the grid to the screen.

render(){
  return(
    <Grid>
      {this.state.board.map((row, key)=>{
        return <Col key={key}>{row.map((cell, key)=>{
          return <Row style= 
            // If cell is 1(alive) render a color there
            {{backgroundColor:cell.cell==1?'#00FFFF':'#FFF', 
            margin:1}} key={key}></Row>
        })}</Col>
      })}
    </Grid>
  );
}

I know this could probably be done more elegantly in something like three.js but it was a fun experiment. Here is a link to the Github repository. And the final product (which has been sped up slightly).