DEV Community: John Enad

How to Learn FastAPI Fast

John Enad — Sat, 26 Aug 2023 17:23:59 +0000

FastAPI is a modern, high-performance web framework for building APIs that run on Python. It has gained a lot of popularity over the past few years. However, it does come with a little bit of learning curve. I am squarely in the middle of this FastAPI Learning Journey and this post aims to share my strategy for learning new programming technologies that have worked well for me in the past. This might help guide beginning software developers who are interested in learning FastAPI.

My first strategy is to “Understand the Basics”. It’s extremely important to first understand the basics before diving into the advanced topics. My plan is to start by reading the official FastAPI documentation (https://fastapi.tiangolo.com/). The documentation is well-structured and covers everything you need to know to get started. You can also take advantage of various online resources such as YouTube, blogs and online forums (https://www.freecodecamp.org/news/search/?query=fastapi and https://www.tutorialspoint.com/fastapi/index.htm)

My second strategy is to “Practice Constantly”. To learn anything fast, you need to practice constantly. Build your own projects and APIs while following tutorials. Put them on your Github. Don’t just practice writing the code but also actually do the testing and debugging of your code. This will not only help you get better at understanding FastAPI, but it also promotes your growth as a developer.

“Take Advantage of FastAPI Libraries”. When I was learning ReactJS, I would use Google the list of common React/JavaScript packages and try them out. I am also doing the same thing as I learn FastAPI since it too has various libraries that can help you reduce the amount of time it takes to write API advanced functionalities. These features can be easily integrated into your project. Take advantage of libraries such as SQLAlchemy, Pydantic and many others.

Finally, “Collaborate with Others”. Collaborating with others can be a great way to learn FastAPI fast. Reach out to other teams in your company that also it. Joining communities such as FastAPI Discord and Slack communities can be helpful. You can also pair program with friends or colleagues that are knowledgeable about it. In addition, if you are into it, contributing to open-source FastAPI projects can give you hands-on experience with the framework.

I believe that with the right approach, anyone can learn FastAPI fast. This blog post has outlined the four tips that I use to learn FastAPI fast. Whether you’re just starting or already have some experience, it is my hope that these tips can help you achieve success faster.

Tidbits: TailwindCSS and Next.js

John Enad — Sun, 09 Jul 2023 02:49:30 +0000

This short journal entry sums up the stuff I've been doing the past week in my spare time. I've been going through a couple of Dr Sahand Ghavidel video course entitled "Mastering Tailwind CSS 3.0 Build Two Dynamic Projects" where he shows how to use Tailwind to partially clone a couple of pages from Tesla and Instagram.

I then proceeded to learn from Brad Traversy from his video course called "Tailwind CSS From Scratch - Learn by Building Projects" where he goes through 5 mini-projects and several projects.

I then started looking into Next.js and read some of the documentation and then decided to just jump in and create a repo so that I can actually start trying it's many exciting new features. Once the repo is set up, I will apply what I've learned from Tailwind to test different layouts, pages and components.

I've created a bunch of repos from this week's learnings at: https://github.com/jenad88

Tidbits: Learning TailwindCSS

John Enad — Sun, 02 Jul 2023 14:17:32 +0000

Tidbits are little bits of news about things I'm working on or learning that I just wanted to chronicle.

The past couple of days and this coming week, My focus has been on learning TailwindCSS. I just recently learned about this amazing CSS framework because in the past year or so, I have been more focused on AWS and back-end work. Any UI features I had worked on used a different Reactstrap-based proprietary framework.

The resources I've used are of course it's documentation, and a few courses from Sahand Ghavidel. He has a handful of project-based courses at Udemy on TailwindCSS. I will continue to learn about TailwindCSS for the next couple of weeks before starting my portfolio project. Heads down for awhile!

These are 2 Github repos I have created thus far based on the Sahad's course:

My Portfolio Journal: Portfolio page up and getting organized

John Enad — Sat, 01 Jul 2023 14:00:00 +0000

As is usually the case when going off to start a new venture, the initial enthusiasm runs high until reality sets in. I'm still starting off so I'm in the "high" phase :D

After having created and customized my Developer Portfolio Site: johnenadFolio, I just wanted a quick way to deploy it. Good thing I found this well-written article by Jonathan Sanchez on how to "Deploy React App to AWS S3 bucket".

Finally with my Developer Portfolio up and running, I set out to organize myself and went ahead to create a free account on Notion. For those not familiar with Notion, it is an amazing product that helps individuals, teams and enterprises get organized, take notes or develop a knowledge and track goals and tasks. It uses AI and you can take advantage of thousands of templates that will enhance the way you work. For me, it's hard to describe it because of the myriad of things that it can do that just makes work easier for its users.

Once that was done, I had to decide on the portfolio project(s) I would work on and after some deliberation, I settled on making an a crude CRM application, a basic Account system and a simple Purchasing system. I hope to just implement maybe a couple of features for each one of them.

Next step, would be to familiarize myself with Notion so I can get more details on my plan together. I'll keep you posted! :)

Tidbits: Awesome React book

John Enad — Tue, 27 Jun 2023 01:42:02 +0000

This is a short post about a book I just started reading and following along. It's called React Application Architecture for Production by Alan Alickovic from packtpub.com

I would highly recommend this book for intermediate web developers who are in the middle of building large-scale applications. It uses Next.js, TypeScript, MSW library for mocking endpoints and covers unit testing with Jest, integration testing with Jest and React Testing Library and Cypress for end-to-end testing.

It uses GitHub Actions (which I haven't tried yet) for CI/CD pipeline.

I hope to apply some of the techniques I learn from this book to my portfolio projects which I plan to start real soon.

Working on my Portfolio Website

John Enad — Sat, 24 Jun 2023 23:09:33 +0000

After I had spent about an hour strategizing about blogging, I concluded that my time and energy would best be served by working on portfolio projects and writing about the various technologies and techniques applied to them as I'm developing them. This way, I end up with working projects which are something tangible and being able to actually share them instead of just writing about whatever random software-related stuff I happened to be dabbling with at the moment.

With that realization, I turned my focus on finally creating my own Portfolio website that serve as the gateway to future projects that I will working on. I figured that the fastest and best way to establish one would be by using whatever open source solution that was already available. I happened to find an amazing portfolio template that I particularly liked called developerFolio. It was created by a Pakistani software developer named Saad Pasta

It has saved me a lot of time because it is easy to setup, change and deploy. Although I haven't deployed it yet, I was able to commit an initial version to my github repository at: https://github.com/jenad88/johnenadFolio

So now, my next steps would be to deploy this website to maybe an S3 bucket and then start planning for projects to work on. The following are some of the possible things I will start really soon.

Hotel booking
Something involving Real Estate
E-Commerce-related modules
E-Learning application
Job Board
Image management application
Fiverr Clone
TaskRabbit clone
Spotify Clone
Youtube Clone

If you don't have a portfolio website and plan to create one, check out developerFolio and you'll have it done in an hour or two.

I'm going to work on deploying this soon. Shoutout and many thanks to Saad!

Beginner Spring Boot Series - Part 3: @Profile and @Beans example

John Enad — Sun, 18 Jun 2023 13:34:23 +0000

With spring beans and profiles, Spring (Boot) gives us a very powerful feature to configure our applications. Spring has the @profile annotation to control which beans get added to the application context. Only beans associated with the active profile are used.

This post is about how I usually use @beans and @profile annotation.

You can check out the sample code at this Github repository: https://github.com/jenad88/enad-spring-1

When a Spring Boot application is started with certain profile(s) activated, the application can react in a certain way based on the activated profile(s).

The way I use profiles, is per environment. So first, I identify the different environments my application will reside. In my case: local, dev, qa, staging, prod

Then for each profile, I create a application.properties file (or .yaml file if you prefer those). The convention is to append the profile name to the filename. For example: application-local.properties or application-prod.properties.

Each of the profile .properties file would then be filled with the configuration that would be used for that profile/environment. In my case, for local:
services.myservice=false
app.message1=Hello World - LOCAL
app.value1=THIS IS LOCAL

and for prod:
services.myservice=true
app.message1=Hello World - PROD
app.value1=THIS IS PROD

I do the same for the rest of the other .properties files...

I then create a Spring Bean which uses those configurations.

public class MyBeanImpl implements MyBean {

    private String message1;
    private String value1;

    public MyBeanImpl(@Value("${app.message1}") String message1, @Value("${app.value1}") String value1) {
        this.message1 = message1;
        this.value1 = value1;
    }

    public String getMessage1() {
        return message1;
    }

    public String getValue1() {
        return value1;
    }

    @Override
    public String doSomething() {
        String result = getClass() + ".doSomething() - " + this.getMessage1() + "=" + this.getValue1();
        return result;
    }
}

Now when Spring Boot starts it will automatically grab the right configuration file based on the profile that is active. Then it loads the configuration properties into the spring beans from that file.

I then create a couple of services called NonProdServiceImpl and ProdServiceImpl which both implement the MyService interface.
In the constructor, it receives the MyBean spring bean. Each of the services is also marked with the @profile annotation. The ProdServiceImpl has @profile("prod"). That directs Spring Boot to use this if the active profile is prod. The NonProdServiceImpl has @profile("!prod"). This tells Spring Boot that if the active profile is not prod, then use this service.

package com.johnenad.enadspring1.service;

import com.johnenad.enadspring1.config.MyBean;
import org.springframework.context.annotation.Profile;
import org.springframework.stereotype.Service;

@Profile("!prod")
@Service
public class NonProdMyServiceImpl implements MyService {

    private MyBean myBean;

    public NonProdMyServiceImpl(MyBean myBean) {
        this.myBean = myBean;
    }

    @Override
    public String doSomething() {
        String result = String.format("NonProdMyServiceImpl: %s=%s", myBean.getMessage1(), myBean.getValue1());
        // do non-production-specific stuff here
        System.out.println(result);
        return result;
    }
}

For the prod version:

package com.johnenad.enadspring1.service;

import com.johnenad.enadspring1.config.MyBean;
import org.springframework.context.annotation.Profile;
import org.springframework.stereotype.Service;

@Profile("prod")
@Service
public class ProdMyServiceImpl implements MyService {

    private MyBean myBean;

    public ProdMyServiceImpl(MyBean myBean) {
        this.myBean = myBean;
    }

    @Override
    public String doSomething() {
        String result = String.format("ProdMyServiceImpl: %s=%s", myBean.getMessage1(), myBean.getValue1());
        // do production-specific stuff here
        System.out.println(result);
        return result;
    }
}

A MyServiceController controller is then created that has a MyService injected (@Autowired) in its constructor. The service that is injected depends on which profile is active.

package com.johnenad.enadspring1.controller.v1;

import com.johnenad.enadspring1.dto.MyServiceResponse;
import com.johnenad.enadspring1.service.MyService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import static com.johnenad.enadspring1.util.DemoUtil.PATH_V1;

@RestController
@RequestMapping(PATH_V1 + "/myservice")
public class MyServiceController implements MyServiceApi {

    private final MyService myService;

    @Autowired
    public MyServiceController(MyService myService) {
        this.myService = myService;
    }

    @Override
    public ResponseEntity<MyServiceResponse> doSomething() {
        try {
            String result = myService.doSomething();

            if (result == null || result.isEmpty()) {
                return new ResponseEntity<>(HttpStatus.NO_CONTENT);
            }
            return new ResponseEntity<>(MyServiceResponse.builder().data(result).build(), HttpStatus.OK);
        } catch (Exception e) {
            return new ResponseEntity<>(HttpStatus.INTERNAL_SERVER_ERROR);
        }
    }
}

How do we tell Spring Boot which profile is the active profile? Just make sure that when you launch your application, we use the -D parameter with the active profile.

Example: -Dspring.profiles.active=prod

When running locally, using IntelliJ IDEA, here is how my configuration looks: (Note the Active profiles field)

If you have a jar file:
java -jar -Dspring.profiles.active=prod enad-spring-1-0.0.1-SNAPSHOT.jar

You can check out the sample code at this Github repository: https://github.com/jenad88/enad-spring-1

Beginner Spring Boot Series - Part 2

John Enad — Mon, 12 Jun 2023 18:00:13 +0000

Resuming our Spring Boot Beginner Series, I am continuing with the Simple Person CRUD example. I figured that it's better to use a newer version of Spring Boot version to 3.1.0. This decision caused has caused changes that would impact the JPA/Hibernate configurations and the OpenAPI setup. There are some nuances there which I'll point out later on. It is important to note that this is just a demo project in fact it employs some bad practices like hard-coded usernames and passwords. This should never be allowed in a real application.

As per my promise in the last post, I've uploaded the updated code to my GitHub repository, accessible here: https://github.com/jenad88/enad-spring-1

The project follows a structure that has been organized into several distinct packages: controller, service, repository, model, and DTO, along with a few others.

The role of the controller code is to serve as the visible interface for users and other APIs. This segment of the code handles incoming requests, performs validations where necessary, and hands it over to the service code for the execution of business processing. Once it retrieves the results from the invoked service, the controller leverages the DTO code to shape the returned response.

Our project's service code forms the backbone of our business logic and processing. It has an understanding of the DTO and model structures. This takes inputs from the controller (along with the configuration/environment) and uses them to execute specific tasks, and upon completion, relays the results back to the controller. Whenever required, it "talks" with databases or other services.

The repository code serves as the project's connection with the database. It is in-charge of data storage and retrieval and is thus integrated with the model structures which I'll explain next.

The model package houses code that mirrors the data in the database tables. For instance, in our simple project, we have a 'Person' class that aligns with the 'Person' table in MySQL. The fields within the 'Person' class map directly to the respective columns in the 'Person' table.

The DTO package hosts the data structures used when invoking controller API methods and when returning data from the API.

A core principle used in our project is the idea of 'Separation of Concerns'. This often used (and over-mentioned) concept concerns code organization. In simple terms, it means that your code should be grouped together based on its functionality. The controller focuses on controlling request flow, the service is dedicated to executing business logic, and the repository looks after data storage and retrieval.

Why is it important? For one, it clarifies the roles and responsibilities of each code grouping and thus helps make the code easier to understand. More importantly, this significantly makes it easier to create and execute unit tests (a potential future topic).

The PersonController class is used to handle HTTP requests related to 'Person' entities. Because it implements the PersonApi interface, it provides the concrete implementation of the methods defined in the PersonApi interface. The PersonController has a dependency on PersonService which is used to perform business process operations related to 'Person' entities.

Below are the methods of the PersonController:

getAll(): Handles HTTP GET requests to fetch all 'Person' entities.

getPersonById(long id): Handles HTTP GET requests for a specific 'Person' entity, identified by its unique 'id'.

createPerson(PersonDTO personDTO): Handles HTTP POST requests to create a new 'Person' entity.

updatePerson(long id, PersonDTO personDTO): Handles HTTP PUT requests to update an existing 'Person' entity. It uses the provided 'id' to identify the 'Person' entity to be updated.

deletePerson(long id): Handles HTTP DELETE requests to remove an existing 'Person' entity.

findByActive(): Handles HTTP GET requests to fetch 'Person' entities marked as 'active'.

Each method returns an instance of ResponseEntity, a class that represents the entire HTTP response, including headers, body, and status. It is used to fully configure the HTTP response.

@RestController
@RequestMapping(PATH_V1 + "/persons")
public class PersonController implements PersonApi {

    private final PersonService personService;

    @Autowired
    public PersonController(PersonService personService) {
        this.personService = personService;
    }

    public ResponseEntity<PersonResponse> getAll() {
        try {

            List<PersonDTO> persons = new ArrayList<>(personService.fetchAll());

            if (persons.isEmpty()) {
                return new ResponseEntity<>(HttpStatus.NO_CONTENT);
            }

            return new ResponseEntity<>(PersonResponse.builder().data(persons).build(), HttpStatus.OK);
        } catch (Exception e) {
            return new ResponseEntity<>(null, HttpStatus.INTERNAL_SERVER_ERROR);
        }
    }

    public ResponseEntity<PersonResponse> getPersonById(long id) {
        Optional<PersonDTO> personOpt = personService.getById(id);

        return personOpt.map(personDTO -> new ResponseEntity<>(PersonResponse.builder().data(personDTO).build(), HttpStatus.OK))
                .orElseGet(() -> new ResponseEntity<>(HttpStatus.NOT_FOUND));
    }

    public ResponseEntity<PersonResponse> createPerson(PersonDTO personDTO) {
        try {
            personDTO.setActive(true);
            PersonDTO newPerson = personService.save(personDTO);
            return new ResponseEntity<>(PersonResponse.builder().data(newPerson).build(), HttpStatus.CREATED);
        } catch (Exception e) {
            return new ResponseEntity<>(null, HttpStatus.INTERNAL_SERVER_ERROR);
        }
    }

    public ResponseEntity<PersonResponse> updatePerson(long id, PersonDTO personDTO) {
        personDTO.setId(id);
        PersonDTO updatedPersonDTO = personService.update(personDTO);
        if (updatedPersonDTO == null) {
            return new ResponseEntity<>(HttpStatus.NOT_FOUND);
        }
        PersonResponse personResponse = PersonResponse.builder().data(updatedPersonDTO).build();

        return new ResponseEntity<>(personResponse, HttpStatus.OK);
    }

    public ResponseEntity<HttpStatus> deletePerson(long id) {
        try {
            personService.delete(id);
            return new ResponseEntity<>(HttpStatus.NO_CONTENT);
        } catch (Exception e) {
            return new ResponseEntity<>(HttpStatus.INTERNAL_SERVER_ERROR);
        }
    }

    public ResponseEntity<PersonResponse> findByActive() {
        try {
            List<PersonDTO> persons = personService.fetchByActive(true);

            if (persons.isEmpty()) {
                return new ResponseEntity<>(HttpStatus.NO_CONTENT);
            }
            return new ResponseEntity<>(PersonResponse.builder().data(persons).build(), HttpStatus.OK);
        } catch (Exception e) {
            return new ResponseEntity<>(HttpStatus.INTERNAL_SERVER_ERROR);
        }
    }

}

The PersonServiceImpl class which lives in the service package is responsible for business logic and can call methods in repository classes. Because it implements the PersonService interface, it provides all the concrete implementation of the methods defined in that interface.

It has a PersonRepository instance which is used to interact with the MySQL database used in the application.

Below are the methods of the PersonServiceImpl

fetchAll(): This method retrieves all 'Person' entities from the repository, converts them to DTOs (Data Transfer Objects), and returns them as a list.

fetchByActive(boolean active): This method retrieves all 'Person' entities with a specific active status from the repository, converts them to DTOs, and returns them as a list.

getById(long id): This method retrieves a 'Person' entity with a specific 'id'. If such an entity exists, it converts it to a DTO and wraps it in an Optional. If no such entity exists, it returns Optional.empty().

update(PersonDTO personDTO): This method updates an existing 'Person' entity. It retrieves the 'Person' entity from the repository, updates its fields, saves the updated entity back to the repository, and returns the updated entity as a DTO. If no such entity exists, it returns null.

add(String firstName, String lastName, boolean active): This method creates a new 'Person' entity, saves it to the repository, and returns the saved entity as a DTO.

delete(long id): This method deletes a 'Person' entity with a specific 'id'. If no such entity exists, it does nothing.

save(PersonDTO personDTO): This method creates a new 'Person' entity from a DTO, saves it to the repository, and returns the saved entity as a DTO.

The class uses PersonDTO.convert() to convert between 'Person' entities and DTOs. This is an example of separation of concerns: the service layer handles the business logic, while the DTOs are used for transferring data between different application layers (in this case, between the service layer and a web layer).

@Service
public class PersonServiceImpl implements PersonService {

    final private PersonRepository personRepository;

    @Autowired
    public PersonServiceImpl(PersonRepository personRepository) {
        this.personRepository = personRepository;
    }

    @Override
    public List<PersonDTO> fetchAll() {
        List<Person> persons = personRepository.findAll();
        return PersonDTO.convert(persons);
    }

    @Override
    public List<PersonDTO> fetchByActive(boolean active) {
        List<Person> persons = personRepository.findByActive(active);
        return PersonDTO.convert(persons);
    }

    @Override
    public Optional<PersonDTO> getById(long id) {
        Optional<Person> personOpt = personRepository.findById(id);
        return personOpt.map(PersonDTO::convert);
    }

    @Override
    public PersonDTO update(PersonDTO personDTO) {
        Optional<Person> p = personRepository.findById(personDTO.getId());
        if (p.isEmpty()) {
            return null;
        }

        Person person = p.get();
        person.setFirstName(personDTO.getFirstName());
        person.setLastName(personDTO.getLastName());
        person.setActive(personDTO.isActive());

        Person updatedPerson = personRepository.save(person);
        return PersonDTO.convert(updatedPerson);
    }

    @Override
    public PersonDTO add(String firstName, String lastName, boolean active) {
        Person person = personRepository.save(new Person(firstName, lastName, active));
        return PersonDTO.convert(person);
    }

    @Override
    public void delete(long id) {
        Optional<Person> person = personRepository.findById(id);
        person.ifPresent(personRepository::delete);
    }

    @Override
    public PersonDTO save(PersonDTO personDTO) {
        Person person = new Person();
        person.setFirstName(personDTO.getFirstName());
        person.setLastName(personDTO.getLastName());
        person.setActive(personDTO.isActive());

        Person savedPerson = personRepository.save(person);
        return PersonDTO.convert(savedPerson);
    }
}

This post is getting a bit on the long side so will stop here. In the next post, I will continue improving this application.

The GitHub repository can be found here: https://github.com/jenad88/enad-spring-1

Day 46-47: Beginner FastAPI Series - Part 3

John Enad — Thu, 08 Jun 2023 11:01:00 +0000

In this post, we'll go into a little more detail with FastAPI which I've heard is great for building APIs in Python. We'll develop a simple and straightforward API, using a 'Person' as our model with three attributes: first_name, last_name, and active. The aim is to understand and apply the techniques and concepts that I've been reading about in the last couple of days.

In part 2 we showed how routes work. This time we're actually going to work with a Person model and create functionality to persist and retrieve data from a database. For this exercise, I've chosen SQLite because its lightweight and because of it's disk-based properties. SqlLite is supposedly the most used database engine in the world because it is embedded in a lot of mobile phones and used in a lot of daily applications as well.

On a side note, I might have some future posts involving PostgreSQL and even MySQL because, why not? It sounds like a exercise. But anyway check out SQLite [here] https://www.sqlitetutorial.net/).

Our tool we're going to be using for interfacing with the SQLite database is SQLAlchemy, a SQL toolkit that provides a unified API for various relational databases. If you installed FastAPI with pip install "fastapi[all]", SQLAlchemy is already part of your setup. but if you opted for FastAPI alone, you would need to install SQLAlchemy separately with pip install sqlalchemy.

I will just point out the significant points of the code. The complete code will be in a Github repository located here: https://github.com/jenad88/enad-project-1

There is a db.py file that contains code that uses SQLAlchemy which is a SQL toolkit and Object-Relational Mapping (ORM) system for Python and sets up a connection with a SQLite database, then defines how sessions are created
and finally, it sets up a Base class for defining the database tables.

from sqlalchemy import create_engine, Column, Integer, String, Boolean
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import sessionmaker

# Create a sqlite engine instance
engine = create_engine("sqlite:///enad-core.db")

# Create SessionLocal class from sessionmaker factory
SessionLocal = sessionmaker(bind=engine, expire_on_commit=False)

# Create a DeclarativeMeta instance
Base = declarative_base()

create_engine is used to set up the connection to the database, and Column, Integer, String, and Boolean are classes used to define the database table structures.

declarative_base is a base class used by all the models while sessionmaker is a factory that creates new Session objects.

The create_engine function initializes a new engine instance for the SQLite database which stores data in a file named enad-core.db. All connections used by SQLAlchemy comes from this engine.

SessionLocal is created from the sessionmaker factory function. I generates new Session objects when called. These objects are then used as a "handle" to the database, allowing database queries.

The declarative_base function is called to create a new Base class. This Base class serves as the base class for all SQLAlchemy models as we will show later.

The start of the application is in the /backend/app folder in a file called main.py

from fastapi import FastAPI
from backend.app.routers import person_routers_v1
from backend.app.db import Base, engine

def create_app():
    app = FastAPI()

    app.include_router(person_routers_v1.router, prefix="/api")

    return app

# Create the database
Base.metadata.create_all(engine)

app = create_app()

The previous code creates a FastAPI application with a set of routes and sets up the SQLite database using SQLAlchemy.

Apart from fastapi being imported, the person_routers_v1 module which contain 'person' routers is also imported. Base and engine are SQLAlchemy classes used for interacting with the database.

The function create_app is a function that defines and returns a FastAPI application instance. It includes the routes from the person_routers_v1 router and has a prefix of "/api". This means that all routes defined in person_routers_v1 will have "/api" added before their route.

The Base.metadata.create_all(engine) line creates all the tables in the database from classes that inherit from Base.

app = create_app() creates an instance of the FastAPI application by calling the create_app function.

The remaining code has then been organized into three folders: models, routers and schemas

In the routers folder we have the person_routers_v1.py file. It contains the CRUD implementation (Create, Retrieve, Update, Delete) API for a 'Person' model using the FastAPI framework and uses SQLAlchemy for database communication.

from fastapi import APIRouter, Depends, HTTPException, status
from backend.app.db import SessionLocal
from sqlalchemy.orm import Session

import backend.app.models.person_models_v1 as person_models_v1
import backend.app.schemas.person_schemas_v1 as person_schemas_v1

def get_session():
    session = SessionLocal()
    try:
        yield session
    finally:
        session.close()


router = APIRouter(
    prefix="/v1/persons",
    tags=["persons"],
    responses={404: {"description": "Not found"}},
)

@router.get("", response_model=person_schemas_v1.PersonListResponse, status_code=status.HTTP_200_OK)
def get_persons(session: Session = Depends(get_session)):

    # get all persons
    persons_list = session.query(person_models_v1.Person).all()

    return {"data": persons_list}

Note: The rest can be found in the repository: https://github.com/jenad88/enad-project-1

The get_session function establishes a connection with the database using SQLAlchemy's SessionLocal and then yields the session for the transaction. After the transaction, the session is closed.

An APIRouter router is initialized with a URL prefix and some metadata for documentation and error handling.

The router decorator is used to associate HTTP request methods (GET, POST, PUT, DELETE) with their respective functions. These functions are responsible for handling CRUD operations on the 'Person' model.

The get_persons function retrieves all Person entries from the database and returns them.

it's getting a bit long so will end here for now.

Beginner Spring Boot Series - Part 1

John Enad — Wed, 07 Jun 2023 01:44:44 +0000

Just as I was wrapping up my second FastAPI course, a thought occurred to me: How would this code look if it were written in Java/Spring Boot? Despite the differences between these two platforms, there are some similarities. So I went ahead and created a Spring Boot equivalent of my "Day 45: Beginner FastAPI Series - Part 2".

Before getting started, Here's the desired route definitions I referred to in the FastAPI Series:

GET /api/persons: Retrieves all persons
GET /api/persons/{id}: Fetches a specific person's details
POST /api/persons/{id}: Creates a new person record
PUT /api/persons/{id}: Updates an existing person's details
DELETE /api/persons/{id}: Removes a single person record

I use IntelliJ IDEA as my Java IDE, (My favorite Java IDE!) and to kick things off, I created a new project, and named it "enad-spring-1".

I managed to capture a couple of screenshots of my configuration selections. I also decided to just use Spring 2.7.12 and Java 17

Very much like what I mentioned in my initial post on FastAPI, what I'm presenting here is a preliminary setup. It's not a finished product, but a starting point designed to speed up our project's momentum. It's like a bunch of placeholder methods that currently return basic strings. However, in subsequent posts, we'll refactor them into full-fledged functions that interacts with the 'Person' entity.

So switching gears, here's the code in the 'PersonController' class within the controller package:

package com.johnenad.enadspring1.controller;

import org.springframework.web.bind.annotation.*;

@RestController
@RequestMapping("/api/persons")
public class PersonController {

    @GetMapping("")
    public String getPersons() {
        return "read persons list";
    }

    @PostMapping("")
    public String createPerson() {
        return "create person item";
    }

    @GetMapping("/{id}")
    public String getPerson(@PathVariable("id") int id) {
        return String.format("read persons item id: %s", id);
    }

    @PutMapping("/{id}")
    public String updatePerson(@PathVariable("id") int id) {
        return String.format("update persons item id: %s", id);
    }

    @DeleteMapping("/{id}")
    public String deletePerson(@PathVariable("id") int id) {
        return String.format("delete persons item id: %s", id);
    }
}

Edit: I've incorporated the 'open-api' dependency in the project's 'pom.xml' file to facilitate OpenAPI integration with Spring Boot.

<dependency>
    <groupId>org.springdoc</groupId>
    <artifactId>springdoc-openapi-ui</artifactId>
    <version>1.7.0</version>
</dependency>

Spring Initializer generates this boilerplate code for our application as the starting point.

@SpringBootApplication
public class EnadSpring1Application {
    public static void main(String[] args) {
        SpringApplication.run(EnadSpring1Application.class, args);
    }
}

Launching the application is simple. Just open the file mentioned above, select Run - Run 'EnadSpring1Application', or use the keyboard shortcut, Shift-F10.

Once the application is up and running, fire up your browser and navigate to http://localhost:8080/api/persons. Voila! The application will respond with the text "read persons list". It's important to note that Spring Boot designates port 8080 as the default localhost port.

Test out the dynamic routes by visiting http://localhost:8080/api/persons/1. The terminal digit '1' in the URL is interpreted as the person's ID. Spring Boot's intuitive routing feature aligns the URL with the pre-established route, replacing {id} with '1'.

Now, let's revisit the 'Edit' segment I mentioned earlier. The 'springdoc-openapi-ui' dependency was added to furnish the application with interactive OpenAPI documentation.

To see this feature firsthand, enter: http://localhost:8080/swagger-ui.html

The interactive documentation allows you to test all the routes in your application. For instance, expand 'GET /api/persons', select the 'Try it out' option followed by the 'Execute' button to invoke the getPersons method, just as you would via your browser.

This marks the beginning of my Spring Boot series and it will be somewhat parallel at times with the FastAPI Python series. It's going to be exciting because we will be able to see both slowly evolve over time.

The next installment of this new Spring Boot series will go deeper into developing our 'Person' entity and making our methods work with it.

Note: In the next post, I will put the code in a public repo at Github

Day 45: Beginner FastAPI Series - Part 2

John Enad — Tue, 06 Jun 2023 04:00:00 +0000

It's time to add the routes I listed in Part 1 to our FastAPI application and associating them with functions. This is just the initial setup to keep this project moving forward and this is far from the final product. At this time, all these methods will simply return a string of text, but they will eventually be modified to perform specific actions on the 'Person' entity.

These routes should be appended to the main.py file in the app folder:

@app.get("/api/persons")
def get_persons():
    return "read persons list"

@app.post("/api/persons")
def create_person():
    return "create person item"

@app.get("/api/persons/{id}")
def get_person(id: int):
    return f"read persons item id: {id}"

@app.put("/api/persons/{id}")
def update_person(id: int):
    return f"update persons item id: {id}"

@app.delete("/api/persons/{id}")
def delete_person(id: int):
    return f"delete persons item id: {id}"

Just in case the application isn't running here is how to run it:

uvicorn app.main:app --host localhost --port 8000 --reload

With these routes implemented, you can turn your browser to http://localhost:8000/api/persons. The application will then respond with the text "read persons list".

The dynamic routes will also work. Try visiting http://localhost:8000/api/persons/1. The number '1' at the end of the URL will be recognized as the person's ID. FastAPI's routing feature will match the URL with the specified route and will replace {id} with '1'.

One of the really cool features of FastAPI is its built-in support for OpenAPI and JSON Schema. What this means is that it will automatically generate API documentation. We don't need to manually create an API documentation!

To see this firsthand, just type http://localhost:8000/docs into your browser's address bar.

The interactive documentation that is displayed can be used to test all the routes in your application. Just expand 'GET /api/persons' and click the 'Try it out' button. Then, click the blue 'Execute' button to call the get_persons method, just like you would from the browser.

I know I'm moving a little bit slower that I wanted but I also need to pace myself as there are other things I'm simultaneously studying at the moment (hint: 2 things and they both start with 'T').

Nevertheless, we have only scratched the surface but have already seen sparks of FastAPI's brilliance. I really like what I'm seeing and think FastAPI is coherent and well-structured.

The next installment of this series will go deeper into developing our 'Person' entity and making our methods work with it.

Note: In the next post, I will put the code in a public repo at Github

Day 43-44: Beginner FastAPI Series - Part 1

John Enad — Sun, 04 Jun 2023 13:21:29 +0000

I've recently come across an amazing web framework for building APIs with Python, and I'm excited to learn it. To document this, I'm starting a new series that chronicles my adventures (and misadventures!) as I slowly get familiar with it.

FastAPI bills itself as a modern, high-performance web framework for building APIs. It compares its speed to NodeJS and Go, and touts itself as one of the fastest Python frameworks around. I poked around its documentation and looked up a examples, and liked what I saw So without a second thought, I decided to dive right in!

I took a quick pause to think about what I was going to build and I aimed for simplicity so I settled on developing a basic CRUD (Create, Read, Update, Delete) project for a Person with just four fields: id, first_name, last_name, and active.

To those who might want to follow along, here are the prerequisites:

Python 3.11 installed.
VSCode installed with a basic understanding of setting up a venv environment.
A fundamental grasp of Python. Some familiarity with FastAPI would be advantageous.
Basic understanding of HTTP and REST.

Next, I mapped out the routes for the API and here's what I came up with:

HTTP METHOD  ROUTE
GET          /api/persons  (Retrieves all persons)
GET          /api/persons/:person_id  (Retrieves a single person)
POST         /api/persons/:person_id  (Creates a new person)
PUT          /api/persons/:person_id  (Updates an existing person)
DELETE       /api/persons/:person_id  (Deletes a single person)

I then created a new folder titled 'enad-project-1' to house the project. Launching VSCode, I initiated Git in a VSCode terminal with the command: 'git init'.

In the root folder, I set up a '.gitignore' file to prevent unnecessary files from being saved in our Git repository. It excludes the following:

.DS_Store
.idea/
__pycache__/
venv/
.env

To set up the Python Virtual Environment (venv), I used VS Code's Command Palette to run 'Python: Create Environment', selecting 'venv'. Upon opening a new terminal, I noticed that the command-line prompt now begins with '(.venv)', signifying the active virtual environment.

Now it's FastAPI time!

Installing FastAPI was quick and easy with the command:

pip install "fastapi[all]"

Next, I created a folder named 'app' and inside, I generated an empty file named '__init__.py' which (as you may or may not know) indicates that 'app' is a Python package.

After that, I created 'main.py', which had the following code to create a FastAPI application:

from fastapi import FastAPI
app = FastAPI()

@app.get("/api/hello")
def root():
    return {"message": "Hello World"}

I ran the application using the command:
uvicorn app.main:app --host localhost --port 8000 --reload'

Then, by navigating to http://localhost:8000/api/hello in a web browser, I was greeted with the ubiquitous "Hello World"!

And off we go to the races! It's the start and I'm going to continue to build on this while learning about FastAPI and Python.