Getting Started with OLA Maps Python package

Ayush — Thu, 11 Jul 2024 14:57:29 +0000

Recently OLA announced their new Maps platform and they're giving it away for free for a year. If you're planning to use it in your project, I've built a new Python package that makes it easy to integrate OLA Maps functionality into your Python projects. Let's explore how to use this package.

Installation

First, install the package:

pip install olamaps

Authentication

Before you can use the OLA Maps API, you need to authenticate. The package supports two methods:

Using an API key:

import os
os.environ["OLAMAPS_API_KEY"] = "your_api_key"

# OR
client = Client(api_key="your_api_key_here")

Using client ID and client secret:

import os
os.environ["OLAMAPS_CLIENT_ID"] = "your_client_id"
os.environ["OLAMAPS_CLIENT_SECRET"] = "your_client_secret"

# OR
client = Client(client_id="your_client_id", client_secret="your_client_secret")

Basic Usage

Here's how to use the main features of the package:

from olamaps import Client

# Initialize the client
client = Client()

# Autocomplete a query
autocomplete_results = client.autocomplete("Kempe")

# Geocode a text address
geocode_results = client.geocode("MG Road, Bangalore")

# Reverse geocode a latitude-longitude pair
reverse_geocode_results = client.reverse_geocode(
    lat="12.9519408",
    lng="77.6381845",
)

# Get directions
directions_results = client.directions(
    origin="12.993103152916301,77.54332622119354",
    destination="12.972006793201695,77.5800850011884",
)

# close the client
client.close()

The package also supports an AsyncClient and context managers. Check out the docs for them here

Conclusion

The olamaps package provides a simple way to integrate OLA Maps functionality into your Python projects. Whether you need to geocode addresses, reverse geocode coordinates, or get directions, this package has you covered.

Find this project on PyPI and on GitHub (Would love some ⭐️)

Remember, this is an unofficial package and is not endorsed by OLA. Always make sure you comply with OLA's terms of service when using their API.

Happy mapping!

FastAPI - Concurrency in Python

Ayush — Sat, 29 Jun 2024 06:18:28 +0000

Recently I delved deep into FastAPI docs and some other resources to understand how each route is processed and what can be done to optimise FastAPI for scale. This is about the learnings I gathered.

A little refresher

Before we go into optimising FastAPI, I'd like to give a short tour on a few technical concepts.

Threads & Processes

Threads share memory space and are easier to create.
Processes have separate memory space and thus require some overhead to create.

Multi-threading & Multi-processing

Multi-threading uses multiple threads within a single process.
Multi-processing utilizes multiple processes, leveraging multiple CPU cores.

Concurrency & Parallelism

Concurrency is managing multiple tasks together. Made possible using event loop.
Parallelism is executing multiple tasks simultaneously. Made possible using multiple CPU-cores.

Python & the GIL

Python's Global Interpreter Lock (GIL) allows only one thread to execute Python bytecode at a time. However, for I/O-bound operations, the GIL is released, allowing other threads to run while waiting for I/O completion. This makes Python particularly effective for I/O-heavy applications.

Quick FYI: In some time, GIL will probably be optional in Python. (PEP 703)

FastAPI

How route handlers are processed

Regular route handlers run in an external threadpool
Async route handlers run in the main thread
FastAPI doesn't affect other (utility) functions

Optimizing FastAPI

Choose based on your task:

I/O tasks with minimal or no CPU work: Use async route handler and await I/O tasks
Non-async I/O tasks: use regular (def) route handler
I/O tasks with significant CPU work: Use regular route handler or async route handler which queues the task for external worker (multi-processing)
High compute tasks: Use multi-processing same as above

The reason I'm suggesting to use regular route handlers for most cases is because we want to keep the main thread available for receiving requests and managing them. If we have any blocking code in main thread (async handlers) it would affect the incoming requests.

Using multiple processes

For containerized environments: Use Docker Swarm/Kubernetes to create workers and use a load balancer
For traditional setups or just Docker: Use Gunicorn (for process management) with Uvicorn (workers)

Some resources I found to be of great help

Building large APIs with FastAPI - PyCon SK
Threading vs multiprocessing in python
https://fastapi.tiangolo.com/async/ (official FastAPI docs, they're amazing)

DEV Community: Ayush