DEV Community: Bamimore-Tomi

Never Going Back

Bamimore-Tomi — Thu, 03 Mar 2022 06:43:54 +0000

Immutable, ledger, distributed, blocks, smart contracts, NFT, hashes, gas, and many other buzz words on the internet relating to the blockchain all point to this phrase "what is done may never be undone."

This standard for anything that'll be called a blockchain must adhere to. It all started in 2008 a white paper on bitcoin was published. The blockchain is a technology that ensures once an event is created, it cannot be uncreated, updated, or replaced.

The big question on my mind is how does this relate to NFTs, smart contracts, cryptocurrency? In the next eight weeks, I'll be going on a ride to understand how this technology works. I am grateful to Zuri and Nestcoin for an opportunity to go on this learning ride.

Building a Telegram Crypto Wallet Management using Python and Fauna

Bamimore-Tomi — Thu, 19 Aug 2021 00:40:30 +0000

Introduction to the Serverless Architecture

Written in connection with the Write with Fauna Program.

The serverless paradigm is a software design style that allows third-party services to host applications.

Servers are present but are abstracted from the app development process.

Serverless computing services are often classified into two categories:

backend-as-a-service (BaaS)
function-as-a-service (FaaS)

Cloud providers are an integral part of the serverless architecture. They take care of all the grunt work for developers so they can concentrate on the essential logic of their applications.

Our application's database layer will be built with Fauna — a serverless database provider. It eliminates layers of app code that were previously used to manually handle data anomalies, security, and scaling, giving you a better development experience and a better app experience for your users.

The Cryptography in Cryptocurrency

“Crypt” - comes from the Greek root “kryptos” , which means "hidden or concealed," and has been used to mean "secret or hidden." Cryptography is an integral part of cryptocurrency. We will be looking at three different methods of cryptography used in cryptocurrency:

Asymmetric Encryption: This type of encryption uses 2 different keys to encrypt data ( public and private key). The public key can be shared publicly, and can be used by anyone to encrypt data. A private key ( secret key ) is only known to the party that generated the key; this is the only key that can be used to decrypt data encrypted by the public key, hence the name, public key encryption. The private key cannot be derived from the public key.

Symmetric Encryption: In contrast to asymmetric encryption, data is encrypted and decrypted using the same cryptographic keys. The keys could be identical or there could be a simple transformation between them. When data encryption and decryption do not take place in the same location, this method of encryption becomes vulnerable. When using symmetric algorithms, the key exchange problem is a significant issue.

Hashing: Hashing is a cryptography technique used to verify the integrity of data. A hashing algorithm takes an arbitrary amount of data and returns a fixed output known as a hash. A minor change in the input data has a significant impact on the output, which is why hashing algorithms can be used to validate data.

Cryptocurrency Wallet

In contrast to physical wallets, which store cash, cryptocurrency wallets do not actually store your crypto assets. Crypto wallets provide the information required to interact with the blockchain, for example; the wallet address, private key, and public key. Your wallet address is an alphanumeric identifier that is generated from your public and private keys. It is your specific location on the blockchain. You can share your wallet address with others to receive crypto assets , but you should never share your private keys with anyone.

Your private keys provide access to your asset on the blockchain: as long as you have the private key associated with your address, you can access your crypto assets from any device.

Building a Wallet Management Application

We will be working on a wallet management application for the Tron blockchain. In this demonstration, we will be building it on Telegram.

Requirements

Fauna
Python
Python-telegram-bot
Telegram account and Telegram bot token
Tronapi

Application Structure

.env file: This file stores application secrets. Application secrets such as:

It is critical to keep these details hidden in your application. Each of them will be used in your application.

errors.py file: This file contains some custom python exceptions used in our application.

keyboards.py file: For our application's user interface, we are using Telegram: we sometimes need to create custom keyboards.

main.py file: This file defines the functions that our application will use to connect to Telegram.

message.json file: The messages we send to app users are saved and curated in this file.

utils.py file: This is our utility file which contains the core logic of our project.

To clone the project, run: git clone https://github.com/Bamimore-Tomi/fauna-wallet.git.

Installs all requirements using - “pip install -r requirements.txt”.

Communicating With Telegram

To communicate to users via Telegram, we need to create a Telegram Bot. To create a Telegram Bot:

Create a Telegram account
Go to BotFather on Telegram to create a new telegram bot. You can access bot father by searching for @botfather on Telegram.
Type /newbot and send
Follow the prompts and enter the information you are asked. The end result would be an access token for your bot.

You can now change the value of the token in your .env file. The access token depicted in the preceding image is invalid. It was only shown here for illustration purposes.

Communicating With the Tron Blockchain

We can connect our application to numerous blockchains, including Bitcoin, Ethereum, and Ripple. In this demonstration, we will work with the Tron blockchain.

When we installed all the requirements, tronapi was among the packages: it interacts with the Tron blockchain in python.

Creating a New Wallet

We explored crypto wallets earlier. Now we will see how to generate a wallet address, a private key and a public key.

from tronapi import Tron
tron = Tron()
account = tron.create_account
address = account.address
fernet_key = _generate_fernet_key(os.getenv("MASTER"), os.getenv("SALT"))
encrypted_private_key = _encrypt_private_key(account.private_key, fernet_key)

We created the account in the account= tron.create_account statement. The account address is stored in the address variable. To protect our private key, I'm now employing the Fernet symmetric encryption algorithm. More information on the algorithm can be found here. It is critical to encrypt the private key before storing it so that even if another party gains unauthorized access to our database, they will not access our blockchain assets.

Checking Wallet Balance

from tronapi import Tron
tron = Tron()
tron.fromSun(tron.trx.get_balance(address))

Sending TRX From One Address to Another

def send_trx(sender_private_key: str, reciever_address: str, amount: int):
    fernet_key = _generate_fernet_key(os.getenv("MASTER"), os.getenv("SALT"))
    private_key = _decrypt_private_key(sender_private_key, fernet_key)
    tron = Tron()
    tron.private_key = private_key
    tron.defa3ult_address = tron.address.from_private_key(tron.private_key)["base58"]
    reciever_address = _validate_address(reciever_address)
    balance = get_balance(tron.default_address["base58"])

    if balance == 0 or amount > balance:
        raise errors.InsufficientBalance

    transaction = tron.trx.send(reciever_address, amount)

    return True

This code segment reinforces the importance of your private key. The function receives the encrypted private key.

Remember that we used a Fernet symmetric encryption algorithm to protect the keys.

We must now use the same algorithm to decrypt it. We can now request the blockchain to send the desired amount to the receiver address. If we have up to that amount, the transaction is complete — otherwise, it fails.

Setting up Fauna

Creating the Database

In Fauna's dashboard, we must create the database for the wallet application. If you haven't already done so, create an account on Fauna's website.

Click the NEW DATABASE button in the dashboard, give the database a name, and then press the SAVE button.

Creating a Fauna Collection

To store the data gathered in the database, we must now create a Fauna collection.

A collection is similar to SQL tables in that it contains identical properties, such as a wallet collection that includes information on users’ wallets. Click on the NEW COLLECTION button to create a collection. Next, you fill out the details of your collection.

Creating Fauna Indexes

We need to create an index for the database collection. A Fauna index allows us to search through data stored in a database collection. Navigate to Indexes and click on NEW_INDEX.

Terms indicates which field(s) the index is allowed to browse.

Creating a Database API Key

Navigate to security on the left navigation panel. Click on Security then click the NEW KEY button and complete the required information.

When you SAVE an API access key is generated.

You can now replace the token's value in your .env file. The access token shown in the image above is invalid - It was only shown for illustration purposes here.

Communicating With Fauna

def load_db():
    load_dotenv()
    client = FaunaClient(secret=os.getenv("FAUNA-KEY"))
    return client

This is the function where we initiate connection with our database. Let’s have a look at the CRUD operations:

Create:

def create_wallet(client: FaunaClient, user_id: int, wallet_name: str) -> bool:

    tron = Tron()

    account = tron.create_account

    address = account.address

    fernet_key = _generate_fernet_key(os.getenv("MASTER"), os.getenv("SALT"))

    encrypted_private_key = _encrypt_private_key(account.private_key, fernet_key)

    wallet = client.query(
        q.create(
            q.collection("wallet"),
            {
                "data": {
                    "user_id": user_id,
                    "wallet_name": wallet_name,
                    "encrypted_private_key": encrypted_private_key,
                    "public_key": account.public_key,
                    "wallet_address": dict(address),
                    "wallet_account_balance": 0.0,
                    "transactions": [],
                    "date_generated": time.time(),
                }
            },
        )
    )

    save_wallets(client)

    return address.base58

Read:

def get_wallets(client: FaunaClient, user_id: int, wallet_name: Optional[str] = None):

    wallets = client.query(
        q.paginate(q.match(q.index("wallet_index"), user_id), size="100_000")
    )

    if len(wallets["data"]) < 1:
        raise errors.WalletNotFound

    wallets_data = [
        q.get(q.ref(q.collection("wallet"), wallet.id())) for wallet in wallets["data"]
    ]

    wallets_data = client.query(wallets_data)

Update:

def record_transaction(
    client: FaunaClient, wallet: dict, type_: str, amount: int, address: str, tx_id: str
):

    tron = Tron()

    bot = telegram.Bot(token=os.getenv("TOKEN"))

    wallet = get_wallets(client, wallet["user_id"], wallet_name=wallet["wallet_name"])

    prev_transactions = wallet["transactions"]

    balance = wallet["wallet_account_balance"]

    if type_ == "credit":
        balance += amount

    if type_ == "debit":
        balance -= amount

    new = {
        "type": type_,
        "address": tron.address.from_hex(address).decode(),
        "amount": amount,
        "tx_id": tx_id,
        "time": time.time(),
    }

    prev_transactions.append(new)

    client.query(
        q.update(
            q.ref(q.collection("wallet"), wallet["ref"]),
            {
                "data": {
                    "transactions": prev_transactions,
                    "wallet_account_balance": balance,
                }
            },
        )
    )

Delete:

def delete_wallet(client: FaunaClient, user_id: int, wallet_ref: str):

    try:
        client.query(q.delete(q.ref(q.collection("wallet"), wallet_ref)))

    except NotFound:
        raise errors.WalletNotFound

Exploring the Application

Conclusion

We covered critical concepts in serverless computing architecture in this article.

We also used Fauna, a serverless database provider, to manage our application's database layer. We also explored CRUD operation in fauna from python.

The source code for the project can be found on Github. If you have any questions, please contact me via Twitter @forthecode__

Building Instant Messaging App With Flask, Socketio, and Fauna

Bamimore-Tomi — Thu, 10 Jun 2021 14:42:03 +0000

Whatsapp, Messenger, Telegram, and other instant messaging apps make use of WebSockets. According to Wikipedia, WebSocket is a computer communications protocol, providing full-duplex communication channels over a single TCP connection.

A duplex communication system is a point-to-point system composed of two or more connected parties or devices that can communicate in both directions. In a full-duplex channel, both parties communicate simultaneously. Instant messaging applications implement the full-duplex concept via protocols like WebSockets.

In this post, we will be exploring how to build a serverless instant messaging application.

What Is a Serverless Application?

Serverless architecture, also known as function as a service, FaaS, is a software design pattern where applications are hosted by a third-party service, eliminating the developer's need for server software and hardware management. (cited from https://www.twilio.com/docs/glossary/what-is-serverless-architecture)

Advantages of Using a Serverless Database

Serverless databases reduce the effort put into managing the database resources. It allows you to focus on other essential parts of your application. Some other advantages of using a serverless database include:

Reduction in operational database cost
Improved database security
Improved scalability
Realtime database access
Quicker deployment time

Introduction to Fauna

Fauna is a serverless database. Fauna is a document database that offers GraphQL and Fauna Query Language (FQL) at its nucleus. You can store collections, indexes, and other databases ( multi-tenancy). Fauna can handle multiple data types. Fauna doesn't have strict schema requirements and has top-notch support for data relationships. You can check it out at: https://docs.fauna.com/fauna/current/

Setting Up your Fauna Database

First, you need to create an account with Fauna. You can do that at: https://dashboard.fauna.com/accounts/register

Creating a New Database

You need to create a database your Flask Application will interact with. First, click on the New Database button. It should look like the one in the image below.

Then, enter the database name.

Click on SAVE to create the database. You will see this:

Now, you have created a new database.

Creating a Fauna Collection

Click on the NEW COLLECTION button to create a collection. A collection is similar to tables in SQL that contain data with similar characteristics. Fauna organizes its data into collections and uses indexes to browse through it. Data in a collection is organized as documents.

Next, you fill out the details of your collection.

The collection name for this example will be users. You can leave the other fields with their default values. Click on SAVE. You will see something similar to this:

Now, we have to create indexes for our collection.

Creating a Fauna Index

Indexes allow us to browse through our database. Navigate to Indexes and click on NEW INDEX. You have to fill out the details of the index.

Fill out the id in the Terms field. Terms specify the data the index is allowed to browse. Click the SAVE button.

You have now created a Fauna index.

Creating Your Database API Key

We need to create an API key to allow us to communicate with our database from Python securely. To generate the key, navigate to the Security tab on the left sidebar.

Generate the new key by clicking on the NEW KEY button.

You will be asked for the database to associate the key with, the key's role, and the optional name for the API key. Provide that. Then, click on the SAVE button.

You will now see your API key (hidden here). Remember always to keep your key private.

Copy and store the keys where you can easily retrieve them.

Wiring it Up to Python


pip install faunadb

After installing, run this sample code provided by Fauna: https://docs.fauna.com/fauna/current/drivers/python.html


from faunadb import query as q

from faunadb.objects import Ref

from faunadb.client import FaunaClient

client = FaunaClient(secret="your-secret-here")

indexes = client.query(q.paginate(q.indexes()))

print(indexes)

If this runs successfully, it means you are done setting up Fauna.

Building the Application

We have now set up the serverless database for our application. We can get our hands dirty with some good stuff. You can clone the project's repository (git clone <https://github.com/Bamimore-Tomi/fauna-chat.git>). Go through the Readme.md file for instructions on how to use the web application.

Application Structure

The structure of the repository should look like this.

The .env was intentionally ignored. It contains app secrets.

Installing Project Requirements

For starters, you have to install the requirements using pip. Running this command in the project's directory will handle that for you.


pip install -r requirements.txt

Simply running python main.py will get the server up and running. Let's run through the routes to see how they work.

Setting up Our Flask Routes

We initialize the Fauna client using client=FaunaClient(secret=os.getenv("FAUNA_KEY")). The Secret key is defined in the .env file. All requests to Fauna will be from the client object.


# main.py

app = Flask(__name__, template_folder='templates')

app.config["SECRET_KEY"] = "your-secret-key"

socketio = SocketIO(app)

The main Flask app is instantiated with the app variable. In the socketio variable, we use SocketIO to enable bi-directional communications between the client and the server.

The following function is a custom login decorator. We will use it to decorate protected routes later in the file. If the user session is not set, they will be redirected to the login page.


def login_required(f):
    @wraps(f)
    def decorated(*args, **kwargs):
        if "user" not in session:
            return redirect(url_for("login"))
        return f(*args, **kwargs)

    return decorated

The Register Route

The register view receives data from the HTML form and saves it to the database. It is good practice to always hash your passwords before storing them in your database. We used the hashlib library for that function. If this is successful, a new user and chat document is created.

The Login Route

The login view validates the credentials submitted by users. If this is successful, a session is set for the user. It is essential to understand how to query Fauna using the indexes you created.


user = client.query(q.get(q.match(q.index("user_index"), email)))

When we created the user_index, we added the Term email (the terms field specifies which document fields can be searched ). Now I am querying the users' collection using the user_index created earlier.

Chat Route

The chat route handles several things. First, it fetches all ids in the user chats list.

chat_list = client.query(q.get(q.match(q.index("chat_index"), session["user"]["id"])))[
    "data"
]["chat_list"]

We can also liken the chat_list to a friend list. A number of try and except blocks were used to create alternative action in case a query fails. For example:

try:
    chat_list = client.query(
        q.get(q.match(q.index("chat_index"), session["user"]["id"]))
    )["data"]["chat_list"]
except:
    chat_list = []

If no one has been added to a user's chat list, we return an empty list.

At the function's beginning, the room_id variable is set from the optional rid url argument. The room id is a unique identifier generated for every chat room. According to socketIO, a room is an arbitrary channel that sockets can join and leave. It can be used to broadcast events to a subset of clients. In this case, a "subset of clients" consists of just two users.

New-Chat Route

This route enables a user to add other users to their chat list.

It confirms that the users are not trying to add themselves,

if new_chat == session["user"]["email"]:
    return redirect(url_for("chat"))

a user that does not exist

try:
    # If user tries to add a chat that has not registered, do nothing
    new_chat_id = client.query(q.get(q.match(q.index("user_index"), new_chat)))
except:
    return redirect(url_for("chat"))

A user that has already been added if new_chat_id["ref"].id() not in chat_list:.

Another vital operation that this route performs is generating the room id.


room_id = str(int(new_chat_id["ref"].id()) + int(user_id))[-4:]

It adds the user id of both users and uses the last four digits as the room id for their chats.

Flask-SocketIO Events

We have seen the regular Flask routes in the application. We will not explore the Flask-Socketio Events in the application.

We have two events here. In an actual production application, you will likely have more events.

Join-Chat Event

The first join_private_chat event is used for adding a user to a specified room. When a client connects to a chat, the URL path will look like this: https://fauna-chat.herokuapp.com/chat/?rid=0488

The SocketIO client uses the rid to know who the user wants to chat with. The client now requests the server to add the user to that room.


var socket = io.connect('http://' + document.domain + ':' + location.port + '/?rid=' + {{ room_id }} );

socket.on( 'connect', function() {

 socket.emit('join-chat', {

 rid: '{{ room_id }}'

 } )

 } )

Once this process is completed, the server now knows who to send a specific message to.

Outgoing Event

The chatting_event function is used when a user sends a new message. It simply saves the message to the database.

messages = client.query(q.get(q.match(q.index("message_index"), room_id)))

conversation = messages["data"]["conversation"]

conversation.append(
    {
        "timestamp": timestamp,
        "sender_username": sender_username,
        "sender_id": sender_id,
        "message": message,
    }
)

client.query(
    q.update(
        q.ref(q.collection("messages"), messages["ref"].id()),
        {"data": {"conversation": conversation}},
    )
)

And broadcasts the message to the specified user.

socketio.emit(
    "message",
    json,
    room=room_id,
    include_self=False,
)

Touring the Application

Conclusion

In this article, we built an Instant Messaging app with Fauna's serverless database and Python. We learned how simple it is to incorporate Fauna into a Python application and had the opportunity to test out some of its most essential features and functions.

Please contact me via Twitter: @__forthecode if you have any questions.

File Handling With Python

Bamimore-Tomi — Mon, 19 Apr 2021 22:53:25 +0000

At some point in programming, you will have to work with files. You will come across things like File IO, File Buffer, and other jargon. In this post, we will explore file handling in Python: methods, procedures, and rules.

Please note that to understand this article, you need to have a basic understanding of Python’s syntax.

`With` or …

Python provides an inbuilt function to open files. You probably know that already. There are two ways to implement the function.

The inbuilt function open returns a stream. In this case, the stream allows you to continuously read or write to the file you opened. The open function takes a couple of arguments which we will explore.

The file argument is the name of the file you want to open in Python. It is usually a string containing the name and extension e.g. my_file.txt.
The mode is an optional argument that usually defaults to ‘r’. There are other options for the mode argument. You should specify the mode argument if you want to perform any operation apart from reading from a file. Here is a list of other options.

Next up is the buffering argument. Buffering is an integer used to set the buffering policy. This may sound a little strange. You can read this page to understand the concept of buffering as it relates to file handling in python.

Another optional argument is encoding. The default encoding is platform-dependent. This is only applicable in text mode, you can check the list of encodings available in python here.

You can read about the other arguments here.

One important thing to note when dealing with files is the with statement. The with statement ensures the acquisition and release of resources. If you use the with statement to access a file, it is certain that the file will always be closed. To use the with statement to manage your objects, check out this example.

Reading, Writing and Appending Operation

In this section, we will be helping a teacher sort and compute the average of students' grades into a file.

A few moments later …

See the result of this set of operations on the input file below

We forgot to add the teacher’s signature to the output file. To solve the problem, we open the file in append mode to avoid overwriting previously written data.

The new output file looks like this.

File handling is not only limited to .txt files. You may have to work with files in other formats and the same rules apply. Thanks for reading.

Building a Natural Language Processing API with FastAPI.

Bamimore-Tomi — Sat, 16 Jan 2021 19:17:55 +0000

Brief History of the Framework ...

FastAPI was built by Sebastián Ramírez. It was built with inspiration from Flask which is a micro-framework i.e it is easy to mix and match other tools and libraries with FastAPI. Specific information about the architecture and design of FastAPI can be found on FastAPI's documentation website

Back to Business ...

We will be building an API with some Natural Language Process features. The structure of the project looks like

The content of each file will be explained in detail.

To get started run the following commands in terminal

pip install virtualenv, virtualenv <folder-name>,cd <folder-name>\scripts,activate. This set of commands are optional but reccommended. Naviagte to the main <folder-name> directory to continue executing the remaining commands.
git clone https://github.com/Bamimore-Tomi/inteligencia.git
pip install -r requirements.txt. This command will install fastapi, uvicorn, nltk, spacy.
python -c "import nltk;nltk.download('wordnet')". This command will download wordnet which contains some trained words needed for the NLP features we will be implementing. Other NLP dependencies would have been installed with the pip install -r requirements.txt command.

The main.py file is where the main FastAPI application lives. We will be spending more time there. I won't dwell on how the NLP functionalities are implemented, this will be treated in subsequent posts.

🚀🚀🚀🚀🚀
We start with a couple of imports in the main.py file

#main.py file
from fastapi import FastAPI
from pydantic import BaseModel
from utils import *

FastAPI is the main application object. The pydantic module is used by FastAPI for type validation on all inputs and outputs for the API, this strict validation reduces the chances of bugs 🐞 and generally help to make your API secure 🔐🔐.

#main.py file
tags_metadata=[
    {
        'name':'similarity',
        'description':'Finds the similarity between 2 sentences using their word vectors.'
    },
    {
        'name':'tokenize',
        'description':'Takes in word, sentences e.t.c and return lexical infromation about each of words. e.g Nouns, Abstract Nouns, Co-ordinating conjunction.'
    },
    {
        'name':'synonyms',
        'description':'Takes in a word or a group of words separated by commas and return a list of English language synonyms for the words.'
    },
    {
        'name':'antonyms',
        'description':'Takes in a word or a group of words separated by commas and return a list of English language antonyms for the words.'
    },
    {
        'name':'tospeech',
        'description':'Takes in a string and returns an audio file of the text.'
    }
]

The main objective of this variable is for documentation of the functionality of different URL paths in this FastAPI application (we will see these paths later on). It is not necessary and can be omitted. Although, it is nice to have when building an API for public consumption. A major perk of FastAPI is how it supports documentation out of the box.

#main.py file
app = FastAPI(title='Tageit',
              description='This is a hobby project for people interesed in using NLP. Email tomibami2020@gmail.com for new functionality you want to be added.',
              openapi_tags=tags_metadata)

This is where the FastAPI application is initialized. Some extra keyword arguments are passed in for documentation. Again, this is nice to have. The application can simply be initialized with app= FastAPI().

Next, some pydantic models that will be used for type validation later on in the file are declared.

#main.py file
class SimilarityIn(BaseModel):
    text_1 : str
    text_2 : str
class SimilarityOut(BaseModel):
    score : float 
class TokenizeIn(BaseModel):
    text : str
class SynonymIn(BaseModel):
    text : str
class AntonymsIn(BaseModel):
    text : str
class TextToSpeech(BaseModel):
    text : str
    language : Optional[str] = 'en'

When working on a large and complex project, it is bad practice to declare your type validation models right in the main application file. This happens to be a small project 😄😄 so it doesn't hurt to declare your models right in the same file. There are many ways to declare your models. The method used here is recommended by FastAPI. The essence of inheriting BaseModel which is a pydantic helper class is to make your type validation classes work the way FastAPI needs it to work. The reason behind each type will be explained as we continue because they will become more intuitive when we see the functionality we want to achieve, the inputs needed, and the required output(s). It will all become clear 💡💡💡.

The API endpoints ...

home :

#main.py file
@app.get('/')
def home():
    return 'Welcome here'

This is not so important, but mon amie you have successfully created your first flask application which you can now run with uvicorn main:app --reload. This command spawns a uvicorn server on your localhost. The intuition of the command is uviorn <file where your main FastAPI application is>:<name of the FastAPI application variable in the file>.The --reload makes the server reload when you make changes to the application file, this is good for development. FastAPI by default runs on port 8000 so you can turn off all your Django applications 😄😄 because a new Sherrif is in town 👮🏻👮🏻👮🏻. If this goes well, you should see something like

$ uvicorn main:app --reload

INFO: Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
INFO: Started reloader process [1720]
INFO: Started server process [6822]
INFO: Waiting for application startup.
INFO: Application startup complete.

similarity: This endpoint receives a post request containing two texts and returns the cosine similarity between the words.

#main.py file
@app.post('/similarity' , response_model=SimilarityOut,tags=['similarity'])
def similarity(text : SimilarityIn):
    score = similarity_(text.text_1, text.text_2)
    return {'score':score}

This response_model=SimilarityOut argument tells FastAPI what the route is expected to return. The class SimilarityOut was declared earlier on as

#main.py file
class SimilarityOut(BaseModel):
    score : float

. You will notice that the return value of the function reads return {'score':score}. Take a close look at score : float in the class above and the score keyword of the return value of the function. To make it simpler. I have told FastAPI that this route will return a dictionary and the only keyword there will be score and the value of score will be a float. You will also notice that the similarity function has a positional argument text : SimilarityIn. The SimilarityIn class has been defined earlier on as

#main.py file
class SimilarityIn(BaseModel):
    text_1 : str
    text_2 : str

this tells FastAPI that I will be expecting the post request to have two keys which are text_1 and text_2 and both of them must be of type str.

Phew 😪😪😪, that was quite verbose but you should get the whole FastAPI input and output validation now. This may look stressful and unnecessary; amigo, I promise you'll begin to see the importance as you begin to build larger APIs.

tokenize:

This API endpoint returns lexical information about a text posted to the URL path.

#main.py file
@app.post('/tokenize', response_model=dict,tags=['tokenize'])
def tokenize(text : TokenizeIn):
    tokens = tokenize_(text.text)
    return tokens

You will notice that the response_model for this endpoint says dict. This means that the endpoint just returns a python dict. Unlike the previous endpoint that specifies the content of the response. This is quite flexible and is useful when you know the type but not the exact content of your response. This also shows that your response model can be an inbuilt python data type like int, float, str. On this line tokens = tokenize_(text.text) the text in the post request is gotten through text.text. This happens due to some FastAPI magic that occurs in the text : TokenizeIn positional argument passed into the tokenize function.

I will be skipping the subsequent endpoints declared in the file.

#main.py file
@app.post('/synonyms', response_model=dict, tags=['synonyms'])
def synonyms(text : SynonymIn ):
    words = text.text.replace(' ','').split(',')
    response = {}
    for i in words:
        syns = synonyms_(i.strip())
        response[i]=syns

    return response

@app.post('/antonyms', response_model=dict, tags=['antonyms'])
def antonyms(text : AntonymsIn ):
    words = text.text.replace(' ','').split(',')
    response = {}
    for i in words:
        syns = antonyms_(i.strip())
        response[i]=syns       
    return response

They all follow the same logic as the previous endpoints that have been explained already. The last endpoint has some peculiarities that need explanation.

tospeech:

This endpoint receives a text from the post request and returns a .mp3 file for the text.

#main.py file
@app.post('/tospeech' ,tags=['tospeech'])
def  text_to_speech(text : TextToSpeech ):
    language = text.language
    if len(language)>2:
        language=language[:2].lower()
    elif len(language)<2:
        language='en'
    audio_object = text_to_speech_(text.text,language=language)
    audio_object.save('aud.mp3')
    return FileResponse('aud.mp3')

This is where I make use of the FileResponse imported at the beginning of the file. This class abstracts all the dirty work needed to return a file object. The text_to_speech function takes a positional argument text : TextToSpeech. The TextToSpeech was also declared earlier in the file. A syntax in the class that should be taken note of is language : Optional[str] = 'en'. Optional there means the language keyword might or might not be supplied in the request. If it is not present in the post request, it should default to a string en. You will also notice that response_model is not specified; the FileResponse handles that for us behind the scenes.

Conclusion

We have seen how FastAPI works with documentation, type validation, and file response. The deployed application can be viewed on heroku and source code. We have also seen how easy it is to get things up and running with FastAPI. I hope you enjoy this terrific FastAPI journey you are about to go on.

DEV Community: Bamimore-Tomi

Never Going Back

Building a Telegram Crypto Wallet Management using Python and Fauna

Introduction to the Serverless Architecture

The Cryptography in Cryptocurrency

Cryptocurrency Wallet

Building a Wallet Management Application

Requirements

Application Structure

Communicating With Telegram

Communicating With the Tron Blockchain

Creating a New Wallet

Checking Wallet Balance

Sending TRX From One Address to Another

Setting up Fauna

Creating the Database

Creating a Fauna Collection

Creating Fauna Indexes

Creating a Database API Key

Communicating With Fauna

Exploring the Application

Conclusion

Building Instant Messaging App With Flask, Socketio, and Fauna

What Is a Serverless Application?

Advantages of Using a Serverless Database

Introduction to Fauna

Setting Up your Fauna Database

Creating a New Database

Creating a Fauna Collection

Creating a Fauna Index

Creating Your Database API Key

Wiring it Up to Python

Building the Application

Application Structure

Installing Project Requirements

Setting up Our Flask Routes

The Register Route

The Login Route

Chat Route

New-Chat Route

Flask-SocketIO Events

Join-Chat Event

Outgoing Event

Touring the Application

Conclusion

File Handling With Python

With or …

Reading, Writing and Appending Operation

Building a Natural Language Processing API with FastAPI.

Brief History of the Framework ...

Back to Business ...

To get started run the following commands in terminal

The API endpoints ...

home :

similarity: This endpoint receives a post request containing two texts and returns the cosine similarity between the words.

tokenize:

tospeech:

Conclusion

`With` or …