DEV Community: Lody G Mtui

Retrofit Workflow

Lody G Mtui — Sat, 05 Jul 2025 09:52:12 +0000

Retrofit is a type-safe REST client library that is used to consume RESTful Web Services.

Add Dependency
Go to Retrofit, copy the following line implementation 'com.squareup.retrofit2:retrofit:(insert latest version)'
To get the latest version, navigate to Square Github.

Retrofit works with different serialization/deserialization library such as Moshi,Gson etc.In this case, we use Gson.

From the same page, Retrofit, copy this line com.squareup.retrofit2:converter-gson and add the latest version as Retrofit.

Then add the dependencies in the build.gradle.kts as follows:-

dependencies {

    implementation("com.squareup.retrofit2:converter-gson:2.11.0")

    implementation("com.squareup.retrofit2:retrofit:2.11.0")


}

Create Dataclass/Modal class

public class Movie {
    @SerializedName("id")
    @Expose
    private Integer id;

    @SerializedName("overview")
    @Expose
    private String overview;

    @SerializedName("poster_path")
    @Expose
    private String posterPath;

    @SerializedName("release_date")
    @Expose
    private String releaseDate;

    @SerializedName("title")
    @Expose
    private String title;

    @SerializedName("vote_average")
    @Expose
    private Double voteAverage;

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getOverview() {
        return overview;
    }

    public void setOverview(String overview) {
        this.overview = overview;
    }

    public String getPosterPath() {
        return posterPath;
    }

    public void setPosterPath(String posterPath) {
        this.posterPath = posterPath;
    }

    public String getReleaseDate() {
        return releaseDate;
    }

    public void setReleaseDate(String releaseDate) {
        this.releaseDate = releaseDate;
    }

    public String getTitle() {
        return title;
    }

    public void setTitle(String title) {
        this.title = title;
    }

    public Double getVoteAverage() {
        return voteAverage;
    }

    public void setVoteAverage(Double voteAverage) {
        this.voteAverage = voteAverage;
    }
}

Create Interface class

public interface MovieApi {
    @GET("movie/popular")
    Call<Result> getPopularMovies(@Query("api_key") String apiKey);

}

Create Retrofit Instance

public class RetrofitInstance {
    private static Retrofit retrofit = null;
    private final static String BASE_URL ="https://api.themoviedb.org/3/";

    public static MovieApi getApi(){
        if (retrofit == null){
            retrofit = new Retrofit.Builder()
                    .baseUrl(BASE_URL)
                    .addConverterFactory(GsonConverterFactory.create())
                    .build();
        }
        return retrofit.create(MovieApi.class);
    }

}

Create Repository (Optional)

public class MovieRepository {
    private ArrayList<Movie> movies = new ArrayList<>();


    public MovieRepository(Application application) {
        this.application = application;
    }

    public MutableLiveData<List<Movie>> getMutableLiveData(){
        MovieApi movieApi = RetrofitInstance.getApi();

        Call<Result> call = movieApi.
                getPopularMovies(application.getApplicationContext().getString(R.string.api_key));


        call.enqueue(new Callback<Result>() {
            @Override
            public void onResponse(Call<Result> call, Response<Result> response) {
                Result result = response.body();

                if (result != null && result.getResults() != null){
                    movies = (ArrayList<Movie>) result.getResults();
                    mutableLiveData.setValue(movies);
                }
            }

            @Override
            public void onFailure(Call<Result> call, Throwable throwable) {

            }
        });
        return mutableLiveData;
    }
}

Room Database Workflow

Lody G Mtui — Thu, 27 Feb 2025 09:37:54 +0000

ROOM Database is the ORM (Object Relational Mapper) library for Android development.

It is used to map database objects to Java objects.

ROOM provides an abstraction layer over SQLite to allow fluent database access while harnessing the full power of SQLite. i.e., it makes it possible to access a database without the need of writing SQL queries.

Room database has three main components:

Entity
DAO (Data Access Object)
Database

In order to implement Room in the Android development, you need to follow the following workflow:

Add ROOM dependency

Go to https://developer.android.com/jetpack/androidx/releases/room , then copy the following dependency and paste in build.gradle.kts in your Android project in the dependencies section

    val room_version = "2.6.1"

    implementation("androidx.room:room-runtime:$room_version")
    annotationProcessor("androidx.room:room-compiler:$room_version")

The whole sample dependencies are as follows:

  dependencies {
    val room_version = "2.6.1"

    implementation("androidx.room:room-runtime:$room_version")
    annotationProcessor("androidx.room:room-compiler:$room_version")

    implementation(libs.appcompat)
    implementation(libs.material)
    implementation(libs.activity)
    implementation(libs.constraintlayout)
    testImplementation(libs.junit)
    androidTestImplementation(libs.ext.junit)
    androidTestImplementation(libs.espresso.core)
}

Create the Entity

Entity is a class that represents a table within the ROOM database.
Each instance of an entity class corresponds to a single row in that table, with each field in that class representing a column.
It must be annotated with @Entity

package com.example.contactapp;

import androidx.room.ColumnInfo;
import androidx.room.Entity;
import androidx.room.PrimaryKey;

@Entity(tableName = "contact")
public class Contact {
    @PrimaryKey(autoGenerate = true)
    @ColumnInfo(name="contact_id")
    int id;
    @ColumnInfo(name = "first_name")
    String firstName;

    @ColumnInfo(name = "last_name")
    String lastName;

    @ColumnInfo(name="user_mail")
    String email;
}

Create the DAO
DAO is the short form for Data Access Object. It is an interface that defines the set of methods for accessing and manipulating data in the database. It must be annotated with @Dao

  package com.example.contactapp;


import androidx.room.Dao;
import androidx.room.Delete;
import androidx.room.Insert;
import androidx.room.Query;
import androidx.room.Update;

import java.util.List;

@Dao
public interface ContactDao {

    @Query("SELECT * FROM contact")
    List<Contact> getAllContact(Contact contact);

    @Update
    void updateContact(Contact contact);

    @Delete
    void deleteContact(Contact contact);

    @Insert
    void getContact();
}

Create the Room Database Instance
It is the abstract class that extends RoomDatabase and serves as the main access point to the SQLite database and links the DAOs and entities together.It must be annotated with @Database

package com.example.contactapp;

import android.content.Context;

import androidx.room.Database;
import androidx.room.Room;
import androidx.room.RoomDatabase;

@Database(version = 1,entities = {Contact.class})
public abstract class ContactDatabase extends RoomDatabase {
    public abstract ContactDao getContactDao();

    private static ContactDatabase dbInstance;

    public static synchronized ContactDatabase getDbInstance(Context 
   context){
        if (dbInstance != null){
            dbInstance = Room.databaseBuilder(
                    context.getApplicationContext(),
                    ContactDatabase.class,
                    "contact_db"
            ).fallbackToDestructiveMigration().build();
        }
        return dbInstance;
    }
}

Create Repository (Optional)
The repository is the class that manages multiple resources of data.
It acts as an intermediary between data sources and ViewModel in the MVVM architecture.
It gathers data from different sources such as:

REST APIs
Cache
Local database storage
... and then provides the data to the rest of the application.

package com.example.contactapp;

import android.app.Application;
import android.os.Handler;
import android.os.Looper;

import androidx.lifecycle.LiveData;

import java.util.List;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class Repository {
    public final ContactDao contactDao;

    ExecutorService executer;

    Handler handler;

    public Repository(Application application) {
        ContactDatabase contactDatabase = ContactDatabase.getDbInstance(application);

        this.contactDao = contactDatabase.getContactDao();

//        Used for background operations
        executer = Executors.newSingleThreadExecutor();

//        Used for updating UI

        handler = new Handler(Looper.getMainLooper());
    }

    public void updateContact(Contact contact){
        executer.execute(new Runnable() {
            @Override
            public void run() {
                contactDao.updateContact(contact);
            }
        });

    }

    public void deleteContact(Contact contact){
        executer.execute(() -> contactDao.deleteContact(contact));

    }

    public void insertContact(Contact contact){
        executer.execute(new Runnable() {
            @Override
            public void run() {
                contactDao.insertContact(contact);
            }
        });

    }

    public LiveData<List<Contact>> getAllContacts(){
        return contactDao.getAllContact();
    }

}

How to Customize Django Forms using Django Widget Tweaks

Lody G Mtui — Wed, 03 Aug 2022 06:24:40 +0000

Django is the "battery-included" framework as most of the functionalities are already done or automated by the framework itself.
This makes it simpler for the developers to complete their work by the deadlines suggested.

Django has many options that enable the forms to render data from the model using ModelForm class.

But Django forms can be automated by using the following

{{form.as_p}} - render forms as paragraph
{{form.as_table}} - render forms as table
{{form.as_ul}} - render forms as list

But all these automate the Django forms implicitly. For instance, you make the Django form using Model Form and by using form.as_p....

models.py

from django.db import models

class Post(models.Model):
    firstname = models.CharField()
    lastname = models.CharField()
    email = models.EmailField()

    def __str__(self):
        return self.firstname

forms.py

from django import forms
from .models import Post

class PostForm(forms.ModelForm):
    class Meta:
        model = Post
        fields = ['posts', 'caption']

views.py


def getPost(request):
    post = Post.objects.all()
    context = {
        'post':post
    }
    return render(request,'post_form.html',context)

post_form.html

<div class="col-md-4">
  <form class="form" method="post" enctype="multipart/form-data">
     {% csrf_token %}
     <fieldset class="form-group">
       <legend class="text-center mb-4">Upload Post</legend>
       {{form.as_p}}
     </fieldset>

     <button type="submit" class="btn btn-primary">Post</button>
  </form>
</div>

Suppose you want to use your own HTML forms in stead of automating using Django itself.
E.g of HTML form

<form action="">
  <label for="fname">First name:</label><br>
  <input type="text" id="fname" value="John"><br><br>
  <label for="lname">Last name:</label><br>
  <input type="text" id="lname" value="Doe"><br><br>
  <label for="email">Email:</label><br>
  <input type="email" id="email" value="john@gmail.com"><br><br>
  <input type="submit" value="Submit">
</form>

In order to render this form, you need to use a Django package known as Django Tweaks.

pip install django-widget-tweaks

Then, add it to the settings.py

INSTALLED_APPS = [
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',

    #New
    'widget_tweaks'
]

And in the templates, don't forget to load it as follows:-
{% load widget_tweaks %}

The Django Tweaks library includes two options to customize forms i.e.

Use render_field

<form>
   <div class="form-group">
     {% render_field form.firstname class="form-control" 
     placeholder=form.firstname.label type="text" %}
   </div>

   <div class="form-group">
     {% render_field form.lastname class="form-control" 
     placeholder=form.lastname.label type="text" %}
   </div>

   <div class="form-group">
     {% render_field form.email class="form-control" 
     placeholder=form.email.label type="email" %}
   </div>
</form>

Using template filters

In the post_form.html file above, replace form.as_p with the following :-

{% for hidden in form.hidden_fields %}
  {{ hidden }}
{% endfor %}

{% for field in form.visible_fields %}
  <div class="form-group">
    <label for="{{ field.id_for_label }}">{{ field.label }}</label>
    {{ field|add_class:'form-control' }}    
    {% for error in field.errors %}
      <span class="help-block">{{ error }}</span>
    {% endfor %}
  </div>
{% endfor %}

Django tweaks library is essential tool to use to customize HTML forms and it is flexible to any form of your choice.

References

You either 'let', 'var' or keep 'const' in JavaScript

Lody G Mtui — Sun, 12 Jun 2022 07:22:44 +0000

Difference between var, let and const

In JavaScript, variables are assigned using three main keywords/ways which are:-

var
let
const.

But, var has became the old way to declare a variable due to the introduction of JavaScript ES6.

Many features were introduced such as let and const which have became de-facto ways for variable declarations.

Note Variable is the value that occupies space into the computer memory i.e. container that is used to store data.

There is difference between var, let and const in JavaScript. These differences between all these keywords, are based on the following concepts:-

Scope

This refers to the way in which variables are accessed i.e. It's how we determine the accessibility of variables.
In JavaScript, there are three scopes:

Global Scope
Function Scope
Block Scope

Global Scope

This refers to when variables are declared outside the function block and can be accessed anywhere within the program.

var age = 19;
let game = 'fifa';
const pie = 3.14;

function getAll(){
    console.log(age);
    console.log(game);
    console.log(pie);
}
console.log(age);
console.log(game);
console.log(pie);
getAll();

Note:Any of var, let or const are used to declare global variables which can be accessed anywhere in the program.

Function Scope

This refers to when variables are declared inside the function scope and can only be accessed within a function. Also known as local scope.

function getAge(){
    var name = "John";
    console.log(name);
}
// console.log(name); // ReferenceError: name is not defined
getAge();

Note:Only var is function scoped i.e. a variable declared by var in function block can accessed only in function itself and cannot be accessed outside the function i.e. It throws a ReferenceError

Block Scope

This refers to when variables are declared in the block or curly brackets and cannot be accessed outside it. A block can be function or control structures such as if, for, while etc.

function gaming(){
    let name = "John";
    const age = 19;
    console.log(name);
    console.log(age);
}
// console.log(name); // ReferenceError: name is not defined
// console.log(age); // ReferenceError: name is not defined

if(true){
    let name = "Paul";
    console.log(name);
}
// console.log(name);
gaming();

Note:Both let and const are block scoped i.e. a variable declared by let or const in a block can accessed only in the block and cannot be accessed outside the block i.e. It throws a ReferenceError

Hoisting

This refers to the behavior to move up the declarations to the top of the scope before code execution. It's a tendency that allows variables and functions to be used before their declaration i.e. the variables/ functions declarations are moved up to the start of code block before execution regardless where they are declared in the code block.

var allows hoisting

name = "John";
console.log(goal);
var name;

let and const don't allow hoisting

goal = "business";
console.log(goal);
let goal;

goal = "business";
console.log(goal);
const goal;

Declaration & Accessibility

The variables declared using var can be declared without initialization.

var age;
console.log(age); // undefined

Note: The variables declared using var can be accessed without initialization and returns undefined.

Also those using let can be declared without initialization.

let age;
console.log(age); // undefined

Note: The variables declared using let cannot be accessed without initialization and returns error.

And those using const cannot be declared without initialization.

const pie;
console.log(pie); // SyntaxError: Missing initializer in const declaration

Note: The variables declared using const cannot be accessed without initialization as it cannot declared without initialization.

Re-declaration

The variables declared using var can be re-declared and updated.

var age = 19;
var age = 20;
age = 30;

While those using let cannot be re-declared but can be updated.

let game = 'fifa';
game = 'pes';

And const can neither be re-declared nor updated.

const pie = 3.14;
const pie = 2.15; // SyntaxError: Identifier 'pie' has already been declared
pie = 10; // TypeError: Assignment to constant variable.

Summary

Image credit: GeeksforGeeks

How to Consume REST APIs using Python

Lody G Mtui — Thu, 17 Mar 2022 11:29:42 +0000

API

API stands for Application Programming Interface.
API is an interface that acts as communication layer which makes two application talks to each other.

In order to build API, we use REST( there are other ways like GraphQL ) Architecture Style.

REST

REST stands for Representational State Transfer.
REST is an architectural design style that facilitates communication between client and server in the network.

In order to access resources from web services, a request is sent to a specific resource and response is expected.

Resource is any data available in web service.
Request sent is called HTTP request.
HTTP is a protocol which governs how client and server communicate.
HTTP request uses special methods known HTTP methods to tell the API which action is needed to be performed.

HTTP Methods

GET - retrieve an existing resource
POST - create a new resource
PUT - update an existing resource
DELETE - delete a resource
PATCH - partially update an existing resource

Status Codes

Response from server is sent after client making request. This response comes with a code which provides the information about the it's results.

The following are common status codes:-

200 - OK
204 - No Content
400 - Bad Request
404 - Not Found
500 - Internal Server Error

API Endpoints

Referred as public URLs that are used to access resources in web services.

Image Credit:Rapid API

How to Use Python To Consume REST APIs

Userequests library
To start using it, install by using pip i.e. pip install requests

Take example of Quotes from Rapid API.

import requests
url = "https://quotes15.p.rapidapi.com/quotes/random/"
headers = {
    'x-rapidapi-host': "quotes15.p.rapidapi.com",
    'x-rapidapi-key': "b799b564e4mshe9022c63f6e7e49p12a6bbjsndfd08f1175da"
    }
response = requests.request("GET", url, headers=headers)
print(response.text)
print(response.json())

~ Here we start importing requests - a de facto library for consuming API.
~ We assign the endpoint - the actual API to variable url.
~ headers are extra information for each API call you can make. (don't worry - they come with API documentation)
~ Then, we pass the endpoint using request method in
response = requests.request("GET", url, headers=headers)
~ Then you can output using text or json() method.

First-Class Function in Python

Lody G Mtui — Fri, 04 Mar 2022 12:31:17 +0000

Everything in Python is an Object (You heard it here first). Just kidding! Of course, at it's core everything in Python is an object.

Not all languages have this feature, but Python is one of them, together with JavaScript, Ruby etc.
This means, string, int, float, datatypes such as dictionary, list, tuple etc. are all objects.

Object is an entity with attributes and behavior. So, function in Python is treated as object. That's why you can call them as First-class function.

First-Class Function means that functions are treated as values - that you can assign a function into a variable, pass it around etc.

Properties of First-Class Function

you can assign them as variable.
you can pass them to other functions as arguments.
you can return them from other functions as values.
you can store them in data structures.

Lets dive into code examples for each property

1.Assigning function as variable.

def square(num):
    return num*num

# store the function in a variable
result = square
print(result2(3))

2.Pass the function as a parameter to another function.

def morning():
    return "good morning"

def noon():
    return "good afternoon"

def greetings(function):
    greet = function()
    print(greet)

greetings(morning)
greetings(noon)

3.Return function from other functions as values.

def outer_power(num1):
    def inner_power(num2):
        return num1 ** num2
    return inner_power

power = outer_power(4)
print(power(3))

4.Store function in data structures

def plusOne(num):
    return num + 1

def plusTwo(num):
    return num + 2

def plusThree(num):
    return num + 3

list_function = [plusOne,plusTwo,plusThree]

for i in list_function:
    print(i)

print(plusOne)
print(plusTwo)
print(plusThree)