
#### Import *** could not be resolved Pylance(reportMissingImports)

While working on Python projects with Docker or just simply any Python project, you may sometimes run into a warning indicating missing imports in `Visual Studio Code`.

<div class="img-blog">
	<img src="/assets/images/blog/vs-code-missing-imports/could-not-be-resolved.png" alt="import-could-not-be-resolved">
</div>

You're quite sure you've installed these packages already before... 🤔

#### What could be happening here? 

Sometimes it's because the wrong environment is being used. This could happen when the IDE is closed, and opened again. Sometimes the setting defaults back to the Global system Python, where the package has not been installed.

In cases like this, you may try updating the currently used Python interpreter at the bottom part of the screen to the one where the missing package had been installed. 

For example:

<div class="img-blog">
	<img src="/assets/images/blog/vs-code-missing-imports/change-interpreter.png" alt="change-interpreter">
</div>

Hope this helped! :smile: :thumbsup:


A simple solution to resolve warnings with Pylance(reportMissingImports) missing imports

Missing imports Pylance(reportMissingImports)


#### Application container runs before the database is ready

Recently, I've started building a new project with [Django](https://www.djangoproject.com/) in conjunction with docker. I am using `docker-compose` to manage two services namely, the django application and the database (postgresql). I ran into an issue where sometimes the django application container runs before the database is ready. This causes an error where the django application is unable to connect to the database as seen below:

```bash
kalender-api-web-1  |     connection = Database.connect(**conn_params)
kalender-api-web-1  |   File "/usr/local/lib/python3.8/site-packages/psycopg2/__init__.py", line 122, in connect
kalender-api-web-1  |     conn = _connect(dsn, connection_factory=connection_factory, **kwasync)
kalender-api-web-1  | django.db.utils.OperationalError: connection to server at "db" (172.29.0.2), port 5432 failed: FATAL:  the database system is starting up
kalender-api-web-1  |
kalender-api-db-1   | 2022-03-31 13:26:42.168 UTC [25] LOG:  database system was not properly shut down; automatic recovery in progress
kalender-api-db-1   | 2022-03-31 13:26:42.175 UTC [25] LOG:  redo starts at 0/17737E0
kalender-api-db-1   | 2022-03-31 13:26:42.175 UTC [25] LOG:  invalid record length at 0/1773818: wanted 24, got 0
kalender-api-db-1   | 2022-03-31 13:26:42.175 UTC [25] LOG:  redo done at 0/17737E0 system usage: CPU: user: 0.00 s, system: 0.00 s, elapsed: 0.00 s
kalender-api-db-1   | 2022-03-31 13:26:42.212 UTC [1] LOG:  database system is ready to accept connections

```

Although this issue happens intermittently, restarting docker-compose everytime this happens can get quite tedious especially if you're working on the application on a day to day basis. 🥵

So, is there anything we can do to tell the django application to wait for the database? 🤔

#### Solution

After some research, I found that `docker-compose` actually supports healthchecks. A healthcheck is essentially a way to validate if a service is running. We are able to check if a specific container is healthy given some condition. We achieve this by using `depends_on` in conjunction with `healthcheck` as follows:

```yaml
version: '3.9'

services:
  web:
    build: .
    volumes:
      - .:/code
    ports:
      - '8000:8000'
    depends_on:
      db:
        condition: service_healthy
    restart: always
  db:
    image: postgres
    environment:
      - POSTGRES_DB=postgres
      - POSTGRES_USER=postgres
      - POSTGRES_PASSWORD=postgres
    volumes:
      - pgdata:/var/lib/postgresql/data
    ports:
      - '5432:5432'
    healthcheck:
      test: ['CMD-SHELL', 'pg_isready']
      interval: 10s
      timeout: 5s
      retries: 5
volumes:
  pgdata:
```

In the example above, the healthcheck property has a condition to check if the `service_healthy`. We are testing for the condition "pg_isready" and if the database is ready, that's the only time the django application container starts running.

I really hope this short article will be of help to anyone who encounters a similar issue. :smile: :thumbsup:

#### Sources:

- [https://stackoverflow.com/questions/31746182/docker-compose-wait-for-container-x-before-starting-y](https://stackoverflow.com/questions/31746182/docker-compose-wait-for-container-x-before-starting-y)
- [https://github.com/peter-evans/docker-compose-healthcheck](https://github.com/peter-evans/docker-compose-healthcheck)


An article that describes a solution for raise conditions when running an application with a database in docker

Wait for database to finish before running application in docker-compose


Recently I've been working on a simple api that uses [Django Rest Framework](https://www.django-rest-framework.org/). Instead of using integer ids as the primary key identifier, UUIDs are used. The advantage of this approach is to prevent enumeration attacks where the primary key is easily guessable. In addition to this, using UUIDs also guarantees a unique identifier across all systems.

In Django, we are able to define a path to accept a UUID as follows:

urls.py

```python
from django.urls import path, re_path
from tasks.views import api_root_view, task_view, user_view
from django.conf.urls import url

urlpatterns = [
    path('tasks/<uuid:pk>', task_view.TaskDetail.as_view()),
    ...
]

```

However, I found that the approach above will only work if the UUID supplied matches the specific pattern. This means that supplying an invalid UUID; lets say a UUID that's missing a few characters will always throw a 404 page and will never reach the view.

#### Original

request:

```bash

GET http://localhost:8000/tasks/7cd6fae8-2835-4dac-b44b-53326af162d3

```

response

```json
{
  "success": true,
  "data": {
    "id": "7cd6fae8-2835-4dac-b44b-53326af162d3",
    "title": "Feed the dogs",
    "description": "Remember to feed the dogs at 8AM",
    "deadline": "2021-02-23T16:37:37Z",
    "created_date": "2021-02-27T05:25:35.579628Z",
    "updated_date": "2021-02-27T05:25:35.579688Z",
    "completed": false
  }
}
```

#### Missing few characters

request:

```

GET http://localhost:8000/tasks/7cd6fae8-4dac-b-53326a3

```

response:

```

404 Page not found

```

#### Solution

To solve this problem, we can instead make use of `re_path`, as follows

```python
from django.urls import path, re_path
from tasks.views import api_root_view, task_view, user_view
from django.conf.urls import url

urlpatterns = [
    # accept match any regEx after 'task/'
    re_path(r'^task\/(?P<pk>.+)$', task_view.TaskDetail.as_view()),
]

```

In this example, we can match any regEx after `tasks/` with the `pk`, so that regardless whether the UUID supplied is invalid, the request would still hit the view, and will respond with details not found, instead of a the 404 page.

#### Original

request:

```bash

GET http://localhost:8000/tasks/7cd6fae8-2835-4dac-b44b-53326af162d3

```

response:

```json
{
  "success": true,
  "data": {
    "id": "7cd6fae8-2835-4dac-b44b-53326af162d3",
    "title": "Feed the dogs",
    "description": "Remember to feed the dogs at 8AM",
    "deadline": "2021-02-23T16:37:37Z",
    "created_date": "2021-02-27T05:25:35.579628Z",
    "updated_date": "2021-02-27T05:25:35.579688Z",
    "completed": false
  }
}
```

#### Missing few characters

request:

```bash

GET http://localhost:8000/tasks/7cd6fae8-2835-4dac-b-53326a3

```

response:

```json
{
  "detail": "Not found."
}
```

I hope this article will be of help to anyone who encounters a similar issue. :smile: :thumbsup:


An article that describes a possible fix for 404 page not found in urls when using UUIDs as the primary key identifier

Django urls UUID 404 page not found


#### Boto3: Unable to locate credentials

Recently I've been working on a Dockerized Python application that connects to AWS resources using the [boto3](https://pypi.org/project/boto3) library. I stumbled upon an error where the app could not find the aws credentials within the docker container.

```bash

botocore.exceptions.NoCredentialsError: Unable to locate credentials

```

Later on, I realized that the problem lies in the fact that the docker is unable locate the credentials from the `.aws` folder. As much as docker is concerned, there are no credentials to be found within the running container.

#### Solution

The solution I've found to is add the configuration as follows:

If you are using `docker run`:

```bash

 docker run -v ~/.aws/:/root/.aws:ro your_image -e AWS_PROFILE=default

```

If you are using a `docker-compose.yml` file,

```yaml
version: '3'

services:
  service-name:
    image: docker-image-name:latest
    environment:
      - AWS_PROFILE=default
    volumes:
      - ~/.aws/:/root/.aws:ro
```

#### Explanation:

`~/.aws/:/root/.aws:ro` is a volume definition that mounts the `.aws` folder of your local machine to the root of our docker container. `:ro` stands for a readonly volume, and we must make the volume readonly so that we are sure the credentials cannot be modified.

We set our `environment` as `AWS_PROFILE=default` so that boto3 will know to read the configuration for the `default` environment. For multiple environments you can configure `AWS_PROFILE=<your environment here>`

I hope this article will be of help to anyone who encounters a similar issue. :smile: :thumbsup:


An article that describes the fix for boto3: botocore.exceptions.NoCredentialsError Unable to locate credentials with Docker images.

AWS: boto3 "Unable to locate credentials" with Docker


The advent of technology has produced many different programming languages that developers can use. From the low level languages such as C, C++, and Assembly Language, to the more high level languages such as Ruby and Python, indeed, technology has reached new heights.

<div class="img-blog-right">
	<img src="/assets/images/blog/python-logo.png">
</div>

One of the emerging programming languages in modern day is Python. It has gained its popularity for being simple yet at the same time very expressive. It is simple in the sense that the code resembles how humans think, which makes it very human understandable. It is expressive in the sense that it enables developers to write fewer lines of code for tasks that require more code in other languages. For these reasons, Python has been adopted as a language commonly used to build simple yet powerful scripts. As a matter of fact, it has become one of the staple tools in the field of data science; used to perform complex tasks such as data cleaning, machine learning, and even building neural networks.

However, one of the underrated capabilities that not everyone sees, is how Python can be used to create simple and powerful APIs. Using libraries such as Python Django, Python Flask, one can develop simple back-ends fewer lines of code compared to other languages. The simple yet expressive nature of Python make it one of the few ideal languages for microservice architectures.

#### Python Falcon

<div class="img-blog">
	<img src="/assets/images/blog/falcon.jpg">
</div>

In today's article, we will be talking about an emerging framework for building simple APIs. We will be going through how to set up a simple API with Create, Read, Update, and Delete functionalities using the [Python Falcon](https://falconframework.org/#sectionAbout) framework.

What is Falcon?

Falcon is a minimalist microframework designed to support the demanding needs of large scale microservices. It is fast and reliable because it compiles with Cython when available. Based on benchmarking tests, Falcon is able to outperform some of the famous microframeworks such as Bottle, Flask, and Werkzeug.

The speed up is just insane. For large scale microservices with high traffic, Falcon is the way to go. :raised_hands: [Read more](https://falconframework.org/#sectionBenchmarks)

#### Setting up

Falcon's architecture follows certain concepts from the REST architectural style. Important to both REST and the falcon framework is the concept of "resource". A resource is simply everything the system would need that can be accessed by a url.

Behind this is a "resource controller" which is controls how the resources behave. It is in charge of orchestrating the requested action and composing a valid result.

Below is an example of a resource controller:

```python
class ProductResource(object):

	def on_get(self, req, resp):

		try:
			logger.info("Performing get all products...")

			resp.body = ujson.dumps({'products': products})
			resp.status = falcon.HTTP_200

		except Exception as e:

			logger.error(e, exc_info=True)

			resp.body = ujson.dumps({"error": e})
			resp.status = falcon.HTTP_502


	def on_get_product(self, req, resp, product_id):

		try:
			logger.info("Performing get product...")

			product = [p for p in products if str(p['id']) == str(product_id)]

			if product == []:

				resp.body = ujson.dumps({'error': 'product not found.'})
				resp.status = falcon.HTTP_404

			else:

				resp.body = ujson.dumps({'products': product[0]})
				resp.status = falcon.HTTP_200



		except Exception as e:

			logger.error(e, exc_info=True)

			resp.body = ujson.dumps({"error": e})
			resp.status = falcon.HTTP_502


	def on_post(self, req, resp):

		try:
			logger.info("Performing post request...")

			body = req.context['request']

			product = {
				'id': body['id'],
				'name': body['name'],
				'stock' : body['stock'],
				'price' : body['price']
			}

			products.append(product)

			resp.body = ujson.dumps({
				'products': product,
				'status': 'CREATED OK'
			})


			resp.status = falcon.HTTP_200

		except Exception as e:

			logger.error(e, exc_info=True)

			resp.body = ujson.dumps({"error": "connection error"})
			resp.status = falcon.HTTP_502


	def on_put_product(self, req, resp, product_id):

		try:
			logger.info("Performing put request...")

			body = req.context['request']

			product = [p for p in products if str(p['id']) == str(product_id)]

			if product == []:

				resp.body = ujson.dumps({'error': 'product not found.'})
				resp.status = falcon.HTTP_404

			else:

				product[0]['name'] = body['name']
				product[0]['stock'] = body['stock']
				product[0]['price'] = body['price']

				resp.body = ujson.dumps({
					'products': product,
					'status': 'UPDATED OK'
				})

				resp.status = falcon.HTTP_200

		except Exception as e:

			logger.error(e, exc_info=True)

			resp.body = ujson.dumps({"error": e})
			resp.status = falcon.HTTP_502

	def on_delete_product(self, req, resp, product_id):

		try:
			logger.info("Performing delete request...")

			product = [p for p in products if str(p['id']) == str(product_id)]

			if product == []:

				resp.body = ujson.dumps({'error': 'product not found.'})
				resp.status = falcon.HTTP_404

			else:

				products.remove(product[0])

				resp.body = ujson.dumps({
					'products': product,
					'status': 'DELETED OK'
				})

			resp.status = falcon.HTTP_200

		except Exception as e:

			logger.error(e, exc_info=True)

			resp.body = ujson.dumps({"error": e})
			resp.status = falcon.HTTP_502

```

The code above shows different functions that correspond to certain HTTP methods for a products API. For example: `on_get_product`, `on_post_product`, `on_put_product`, `on_delete_product`, etc., are functions that implement business logic for creating, reading, updating, and deleting products.

Once the resource controller has been configured, we can then define a file called `app.py`, which will instantiate our product resource controller.

```python
import falcon
import json_utils
from decouple import config
from product_resource import ProductResource


# Declare Falcon Middleware
# RequireJSON will always make sure the application data is in JSON format
# JSONtranslator will translate the stream data from falcon into JSON format
api = falcon.API(middleware=[
			json_utils.RequireJSON(),
			json_utils.JSONtranslator(),
		])

# we define our resource here
product = ProductResource()

api.add_route('/products', product)
api.add_route('/products/{product_id}', product, suffix="product")

```

Note that we can define routes as needed using the `add_route` function.

Lastly, for the API to function efficiently, we must add two middlewares:

`RequireJSON()` and `JSONtranslator`, these middlewares are used to process our json objects. Since Falcon processes request and response data as a stream of bytes, there is a need to perform some serialization to ensure that the data being sent and being serialized in json format; this is handled by `JSONtranslator`. On the otherhand, we must also validate that the request being accepted is in json format; this is handled by `RequireJSON()`

```python
import json
import falcon
import datetime
import decimal

# Middle ware classes for processing json objects


# This will read the stream from the request, then it will decode this data into json format
# If it cannot decode, it will return an TypeError

class JSONtranslator:
    def process_request(self, req, resp):
        """
        req.stream corresponds to the WSGI wsgi.input environ variable,
        and allows you to read bytes from the request body.
        See also: PEP 3333
        """
        if req.content_length in (None, 0):
            return

        body = req.stream.read()

        if not body:
            raise falcon.HTTPBadRequest(
                'Empty request body. A valid JSON document is required.'
            )
        try:
            # You can access the request data using req.context['request']
            req.context['request'] = json.loads(body.decode('utf-8'))

        except (ValueError, UnicodeDecodeError):
            raise falcon.HTTPError(
                falcon.HTTP_753,
                'Malformed JSON. Could not decode the request body.'
                'The JSON was incorrect or not encoded as UTF-8.'
            )

    def process_response(self, req, resp, resource, req_succeeded):
        if 'response' not in resp.context:
            return

        resp.body = json.dumps(
            resp.context['response'],
            default=json_serializer
        )

    def json_serializer(obj):
        if isinstance(obj, datetime.datetime):
            return str(obj)
        elif isinstance(obj, decimal.Decimal):
            return str(obj)

        raise TypeError('Cannot serialize {!r} (type {})'.format(obj, type(obj)))


class RequireJSON(object):

    def process_request(self, req, resp):
        if not req.client_accepts_json:
            raise falcon.HTTPNotAcceptable(
                'This API only supports responses encoded as JSON.',
                href='http://docs.examples.com/api/json')

        if req.method in ('POST', 'PUT'):
            if 'application/json' not in req.content_type:
                raise falcon.HTTPUnsupportedMediaType(
                    'This API only supports requests encoded as JSON.',
                    href='http://docs.examples.com/api/json')
```

There you have it. You have just completed setting up your Falcon API. :clap: :clap: :clap:

#### Wrapping up

Python Falcon is a simple framework that boasts to be blazing fast and highly reliable. It is also easily extensible which makes it one of the ideal choices for large scale microservices.

For more details, you may visit my sample project. [https://github.com/eddrichjanzzen/python-falcon-sample](https://github.com/eddrichjanzzen/python-falcon-sample)


A short article about implementing API using Python Falcon Micro Framework.

Python

Missing imports Pylance(reportMissingImports)
tech python

Wait for database to finish before running application in docker-compose
tech django python

Django urls UUID 404 page not found
python tech

AWS: boto3 "Unable to locate credentials" with Docker
tech aws python

Implementing simple API using Python Falcon
python tech

Python

Wait for database to finish before running application in docker-composetechdjangopython

Django urls UUID 404 page not foundpythontech

AWS: boto3 "Unable to locate credentials" with Dockertechawspython

Implementing simple API using Python Falconpythontech

Wait for database to finish before running application in docker-compose
tech django python

Django urls UUID 404 page not found
python tech

AWS: boto3 "Unable to locate credentials" with Docker
tech aws python

Implementing simple API using Python Falcon
python tech