DEV Community: feranmiodugbemi

Building our first blockchain project: A blockchain voting contract

feranmiodugbemi — Wed, 06 Sep 2023 00:08:07 +0000

We've all heard about the last election done in Nigeria, how there seem to be claims of tampering with election votes, mistakes in counting votes, and so many other excuses, well, that was my motive for building this project😂😂. So, I thought🤔 "How would it feel like if our Nigerian voting system was blockchain-based", then I decided to build the project.

WHY A BLOCKCHAIN VOTING SYSTEM?
In case you're wondering how a blockchain-based voting system solves the problems in our traditional voting system, Let me answer your curious questions. First of all, the blockchain is trustless and decentralized, so no individual has the power to control or manipulate the votes and secondly I just love the idea😂😂.

WHAT WILL I LEARN FROM THIS PROJECT?
You will gain practical experience on how a smart contract works and how it's deployed. You will also implement the knowledge you gained from my last tutorial about solidity keywords.

LFG🚀🚀🚀

BUILDING OUR SMART CONTRACT

First of all, head over to remix. Remix is an online IDE for writing and deploying smart contracts. Create a new file named "Voting.sol" inside the contracts directory

The blockchain system

The beginning of a new chapter😌

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;

contract VotingSystem{
   //The rest of the code goes in here
}

We are initializing a new contract named VotingSystem that runs on solidity compiler versions of 0.8.9 and above.

Creating our candidates

We will be using the three musketeers of the 2023 Nigerian election😂😂, Atiku, Obi and Tinubu🙌.

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;

contract VotingSystem{
   struct Candidate{
        string name;
        uint numberOfVotes;
    }
   mapping(uint => Candidate) candidates;
   constructor(){
        candidates[0] = Candidate("Tinubu", 0);
        candidates[1] = Candidate("Atiku", 0);
        candidates[2] = Candidate("Obi", 0);
    }
}

Here, we created a Candidate struct to hold the name and numberOfVotes of each candidate. We are mapping a uint to our Candidate to keep track of the number of candidates we have and automatically set their number of votes to be 0.

Voting logic

Let's solve the problem of double voting and vote manipulation

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;

contract VotingSystem{
   struct Candidate{
        string name;
        uint numberOfVotes;
    }
   mapping (address => bool) voterVoted;
   mapping(address => uint) votesPerVoter;
   mapping(uint => Candidate) candidates;
   constructor(){
        candidates[0] = Candidate("Tinubu", 0);
        candidates[1] = Candidate("Atiku", 0);
        candidates[2] = Candidate("Obi", 0);
        voterVoted[msg.sender] = false;
    }
   modifier notVoted {
        require(!voterVoted[msg.sender] || votesPerVoter[msg.sender] == 0, "You have already voted");
        _;
    }
}

We created two mappings, voterVoted is to check if an address has already voted for a candidate before and returns a boolean while votesPerVoter ensures that an address is given just 1 chance to vote. The modifier is used for implementing all the logic and will be used in a Vote function.

Vote function

Let's vote for the right candidate

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;

contract VotingSystem{
   // The code we've written earlier
   function vote(string memory _nameofCandidate) public notVoted returns (string memory) {
        bytes32 nameHash = keccak256(abi.encodePacked(_nameofCandidate));
        bytes32 tinubuHash = keccak256(abi.encodePacked("Tinubu"));
        bytes32 atikuHash = keccak256(abi.encodePacked("Atiku"));
        bytes32 obiHash = keccak256(abi.encodePacked("Obi"));
        if (nameHash == tinubuHash){
            candidates[0].numberOfVotes++;
        } else if(nameHash == atikuHash){
            candidates[1].numberOfVotes++;
        } else if(nameHash == obiHash){
            candidates[2].numberOfVotes++;
        }else {
        revert("Invalid candidate name");
        }
        voterVoted[msg.sender] = true;
        string memory Text = "You have already casted your vote";
        votesPerVoter[msg.sender]++;
        return Text;
    }
}

This is our vote function which is used for casting votes, it takes in the nameOfCandidate that the address is voting for. Since Solidity cannot compare two strings together so we generated a hash of our Candidate's name and the _nameofCandidate using the keccak256 algorithm and compares them, so whichever Candidate's name matches the _nameofCandidate their vote count is increased by one else it reverts to Invalid candidate name.

Getting our candidate's votes

After voting, we want to make sure that the right candidate is leading🙈.

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;

contract VotingSystem{
   // Earlier written code
   function getVotes() public view returns( Candidate[] memory){
        Candidate[] memory candidateList = new Candidate[](3);
        candidateList[0] = candidates[0];
        candidateList[1] = candidates[1];
        candidateList[2] = candidates[2];
        return candidateList;
    }
}

This function allows anyone to retrieve the vote counts for all Candidates and returns it in an array format.

Deploying our contract

It's time to unleash our project to the world😌

Go ahead and click on that compile button to compile the solidity smart contract on the solidity compiler page

So, remix gives us 15 addresses with 100 fake ETH to test our smart contracts on different Ethereum test networks. Now, we will be deploying our contract to one of those addresses. Click on the Deploy button to deploy our contract. The address after AT is called the contract address, We can use it to interact with our contract using a client library like web3.js, ethers.js, web3.py, etc.

Conclusion

In conclusion, our journey through the development of a blockchain-based voting system has been both informative and entertaining. We embarked on this project with the aim of addressing the challenges and concerns surrounding traditional voting systems, particularly in Nigeria. The issues of vote tampering, counting errors, and other excuses that have plagued past elections served as the catalyst for this endeavor 😂😂.

By creating a blockchain voting system, we have introduced a trustless and decentralized approach, where no single entity can manipulate or control the votes. This not only provides transparency but also safeguards the integrity of the electoral process. And let's not forget, we did it because, well, we just love the idea 😂😂.

Throughout this journey, you've had the opportunity to gain practical experience in working with smart contracts and deploying them. You've also applied the knowledge from our previous tutorial on Solidity keywords, further enhancing your blockchain development skills.

So, as we wrap up this adventure, I hope you've not only enjoyed the journey but also gained valuable insights into building your first blockchain project and deploying it successfully. With your newfound skills, you're well-equipped to explore more exciting possibilities in the world of blockchain technology. Until next time, happy coding! 😌🚀🔗

Unlock the Power of Solidity: Exploring the Essential Keywords for Smart Contract Development

feranmiodugbemi — Tue, 08 Aug 2023 23:17:07 +0000

Welcome to the exciting world of smart contract development! If you're eager to dive into the realm of blockchain and build decentralized applications, then Solidity is a language you need to familiarize yourself with. As a high-level programming language designed specifically for Ethereum, Solidity empowers developers to create robust and secure smart contracts. To embark on this journey, it's essential to grasp the fundamental building blocks, and that starts with understanding the common keywords in Solidity. In this article, we'll unravel the key words that form the backbone of Solidity programming, equipping you with the knowledge to harness the potential of this powerful language. Today we will be delve a little deep into solidity keywords for writing Smart Contracts, follow on with this tutorial if you will love to learn more.

Solidity keywords we will cover

pragma
contract
Data types - address, uint, int, string, bool, byte32
modifier
constructor
event and emit
struct
delete
mapping
function
public, external, internal, private
require
returns
return
view
pure
msg
payable
memory
storage
enum
interface
revert
indexed
virtual override

Now let's cover them
1) Pragma:
The "pragma" keyword is used to specify the version of the Solidity compiler that should be used to compile the code. It ensures that the code is compiled with the correct compiler version and prevents compatibility issues.

pragma solidity ^0.8.0;

This shows a version of solidity that should for compilers for version 0.8 and upwards

2) Contract:
The "contract" keyword is used to define a new smart contract in Solidity. A contract is a fundamental building block of Ethereum-based applications and encapsulates the data and functions necessary for a specific purpose.

contract MyContract{
   // Your contract code goes in here
}

This defines a contract MyContract.

3) Data Types:
Solidity provides various data types, including:

Address: Represents an Ethereum address and is used for interacting with other contracts or accounts.
uint: Represents an unsigned integer of various sizes.
int: Represents a signed integer of various sizes.
string: Represents a sequence of characters.
bool: Represents a boolean value (true or false).
bytes32: Represents a fixed-size array of 32 bytes.

address Owner = 0x40b38765696e3d5d8d9d834d8aad4bb6e418e489;
uint unsignedNumber = 1;
int Number = -1;
string name = "Gargamel";
bool Owns = true;
bytes32 Example = 0x4d794e616d650000000000000000000000000000000000000000000000000000;

4) Modifier:
The "modifier" keyword is used to define a function modifier. Modifiers are used to modify the behavior of functions in Solidity contracts. They allow developers to enforce conditions or perform pre- and post-function execution tasks.

modifier(){
   //example
   require(true == true);
   _;
}

A modifier must always end with _;

5) Constructor:
The "constructor" keyword is used to define the constructor function of a Solidity contract. The constructor is automatically executed when the contract is deployed and allows initialization of contract variables. A constructor only runs once.

address owner;
constructor(){
    owner = msg.sender;
}

It gives the owner variable the address that deployed the contract

6) Event and Emit:
The "event" keyword is used to define events in Solidity. The "emit" keyword is used to trigger or emit an event, signaling a specific occurrence within the contract.

   event Article( address author, string title)

   // Inside a function
   // emit the event
   emit Article(msg.sender, _title);

7) Struct:
The "struct" keyword is used to define a user-defined data structure in Solidity. Structs allow developers to create custom composite data types by combining different data types together.

    struct Book {
        string title;
        string content;
    }
    Author myBook;

This defines a Book data type with title and content properties. myBook is given the data type of Author

8) Mapping:
The "mapping" keyword is used to define a key-value data structure in Solidity. Mappings are used to create associations between keys and values, similar to dictionaries or hash tables in other programming languages. You can only map a data type to a data type.

mapping(address => Book) addressBook;

This maps an address to the Book data type and gives it a variable name "addressBook"

9) Function:
The "function" keyword is used to define a function within a Solidity contract. Functions contain the executable code that performs specific tasks or operations.

function MyFuction(){
   // function logic
}

A function without parameters

function MyFunction(string a, string b){
 // Function logic goes here
}

A function with parameters

10) Public, External, Internal, Private:
These keywords are used to define the visibility and accessibility of variables and functions within a contract. Public variables and functions can be accessed from anywhere, while external functions can be called only externally. Internal variables and functions are accessible within the current contract and its derived contracts, and private variables and functions are only accessible within the current contract.

    function publicFunction() public {
        // Public function
    }
    function externalFunction() external {
        // External function
    }
    function internalFunction() internal {
        // Internal function
    }
    function privateFunction() private {
        // Private function
    }

11) Delete:
The "delete" keyword is used to delete the value of a state variable or reset it to its initial state.

function deleteBook() public {
    delete myBook;
}

the deleteBook function is defined as a public function. When this function is called, it will delete the myBook instance by setting all of its fields to their initial default values. For strings, the default value is an empty string.

12) Require:
The "require" keyword is used to validate a condition within a function. If the condition evaluates to false, the function execution is reverted, and any changes made within the function are discarded.

   owner = msg.sender
   require(owner == msg.sender);

13) Returns:
The "returns" keyword is used to specify the return type of a function. It indicates the data type or types that the function will return when invoked.

function example() public returns(string){
    string name = "Hello, world";
}

14) Return:
The "return" keyword is used to exit a function and return a value. It transfers the flow of execution back to the calling function and provides the desired value as the result.

function example() public returns(string){
    string name = "Hello, world";
    return name;
}

15) View:
The "view" keyword is used to indicate that a function does not modify the contract's state. View functions are read-only and do not consume any gas when called externally.

function example() public view returns(string){
    string name = "Hello, world";
    return name;
}

16) Pure:
The "pure" keyword is used to indicate that a function does not read or modify the contract's state. Pure functions are also read-only but are not allowed to access any contract-related information.

function Add(uint a, uint b) public pure returns(uint){
    return a + b;
}

This shows a function that adds two numbers together

17) msg:
"msg" is a global variable that provides information about the current message or transaction being executed. It contains several properties that can be accessed within a contract's function.

msg.sender: This property represents the address of the sender of the current message or transaction.
msg.value: This property represents the amount of Ether (cryptocurrency) sent along with the transaction. It is applicable when the function is meant to receive funds.
msg.data: This property contains the complete calldata (input data) of the transaction. It is a byte array that represents the function signature and its arguments. You can use it to access the raw data sent to a function in its encoded form.

18) Payable:
The "payable" keyword is used to mark a function or a contract to be able to receive Ether (the native cryptocurrency of Ethereum) as part of a transaction.

address payable buyer;

function receive() public payable{
     // function logic
}

Defines a buyer variable and a receive function that can send and receive ether

19) Memory:
The "memory" keyword is used to specify a data location for variables. Variables defined in the memory are temporary and do not persist between function calls.

function example() returns(memory string){
    string name = "Hello, world";
    return name;
}

20) Storage:
The "storage" keyword is used to specify a data location for variables. Variables defined in the storage are persistent and stored on the Ethereum blockchain.

string name = "Hello, world";
function example() returns(storage string){
    return name;
}

21) Enum:
The "enum" keyword is used to define an enumeration type in Solidity. Enums allow developers to define a set of named constant values, which can be used as discrete options within the contract.

   enum isLying{
       Yes,
       No
   }

This defines an enum which has two possible values: Yes and No

22) Interface:
The "interface" keyword is used to define an interface in Solidity. Interfaces provide a way to define the functions that must be implemented by other contracts.

// Interface declaration
interface Token {
    function transfer(address recipient, uint256 amount) external returns (bool);
    function balanceOf(address account) external view returns (uint256);
}

In this example, we have an interface called Token. The interface specifies two functions: transfer and balanceOf.

The transfer function is defined with the external visibility specifier, indicating that it can be called from external contracts. It takes two parameters: recipient, which is the address of the recipient of the tokens, and amount, which is the number of tokens to transfer. The function returns a boolean value indicating whether the transfer was successful.

The balanceOf function is defined with the external visibility specifier as well. It takes one parameter: account, which is the address for which the token balance is queried. The function returns the balance of tokens for the specified account as a uint256 value.

23) revert:
The revert keyword is used in Solidity to explicitly trigger an error and revert the execution of a smart contract. It is commonly used to revert changes made to the state of the contract in case of exceptional conditions or invalid inputs.

function withdraw(uint amount) public {
    require(amount <= balance, "Insufficient balance");
    // Withdraw the amount
    if (!payable(msg.sender).send(amount)) {
        revert("Failed to send funds");
    }
    balance -= amount;
}

In the above example, if the amount to be withdrawn exceeds the available balance, the require statement will throw an error. If the send function fails to transfer the funds, the revert statement is triggered with the error message "Failed to send funds".

24) indexed:
The indexed keyword is used when declaring event parameters in Solidity. It allows efficient filtering and searching of events in the Ethereum blockchain.

event Transfer(address indexed from, address indexed to, uint amount);

function transfer(address to, uint amount) public {
    // Transfer logic
    emit Transfer(msg.sender, to, amount);
}

In the above example, the from and to addresses are declared as indexed in the Transfer event. This allows efficient filtering of events based on the sender or recipient addresses.

25) virtual override:
In Solidity, the virtual and override keywords are used in the context of function inheritance and overriding.
The virtual keyword is used when declaring a function in a base contract to indicate that the function can be overridden by derived contracts. It allows derived contracts to provide their own implementation of the function.

contract Base {
    function getValue() public virtual returns (uint) {
        return 10;
    }
}

contract Derived is Base {
    function getValue() public virtual override returns (uint) {
        return 20;
    }
}

the getValue function is declared as virtual in the Base contract, indicating that it can be overridden. The Derived contract then provides its own implementation of the function.

Conclusion

In conclusion, understanding the essential keywords in Solidity is crucial for anyone venturing into smart contract development. These keywords form the building blocks of Solidity programming and empower developers to create robust and secure smart contracts. By familiarizing yourself with concepts like pragma, contract, data types, modifiers, constructor, events, structs, mappings, functions, visibility specifiers, require, returns, return, view, pure, msg, payable, memory, storage, enum, interface, revert, indexed, and virtual override, you gain the knowledge and tools needed to harness the power of Solidity effectively.

Building a Fitness and diet Chatbot with FaunaDB, OpenAI, and Twilio in Python

feranmiodugbemi — Tue, 08 Aug 2023 23:10:10 +0000

In this article, you will learn how to build a Fitness and diet chatbot using Python, FaunaDB, OpenAI, and Twilio. The chatbot will be able to communicate with you via WhatsApp and provide responses based on your conversation history. You'll be walked through the code and understand the key components and libraries involved in the process.

Prerequisites

Before you begin, make sure you have the following:

Python 3.x installed on your machine
FaunaDB account and API key
OpenAI API key to access the gpt-3.5-turbo model
Twilio account SID, auth token, and a phone number
Ngrok: It allows us to expose our local Flask server to the internet.

Setting Up the Fauna database

To begin using Fauna, your initial step is to establish an account on the official website. This can be accomplished by providing your email address or utilizing your GitHub or Netlify account through the following link: Fauna. For efficient communication with the chatbot, it is necessary to utilize the Fauna database for storing and retrieving user messages.

Creating the database

After creating your account with fauna, you will be creating a database to store the Users and Messages. Here you'd be asked for the database name and you are going to name it MyChatBot and the region is going to be set to Classic and like that you've created your database. Then, you should be presented with a screen like this one below:

Creating your collection

Next, you will be creating 2 collections, which is basically Tables in the SQL world but with a twist in our context.

To create your Collection, click on the Create Collection button on the home page and give it a name, but since you'd be creating the two collections will be naming them Users and Messages. The "Users" collection is for storing the user's username from WhatsApp, while the Messages collection is for storing the user's chat history with the bot. You will be asked for History Days and TTL. The History Days is used to define the number of days Fauna should retain a historical record of any data in that particular collection while the TTL serves as an expiry date for data in the collection. For example, if the TTL is set to 7, any data stored in that collection will be automatically deleted 7 days after its last modified date, but for this tutorial you'll not be needing it so it will be left untouched. After creating the two collections, you should be seeing this:

Creating the Index

Wondering what an Index is?, Well an Index is simply a way to browse data in a collection more efficiently by organizing it based on specific fields or criteria, allowing for faster and targeted retrieval of information. To create your Index, you'll navigate to the Index tab and you should see something like this:

To create the Index, you first of all need to Select a Collection, then specify the Terms, which is the specific data the Index is only allowed to browse. But for this you will be creating two Indexes, users_by_username which would be under the Users collection for registering users and users_message_by_username which would be filtering the user's messages by their username. The Terms for users_by_username and users_messages_by_username would be set to data.username will be set to data.username, then click SAVE to continue.

Getting our Database key

Before you proceed to building the ChatBot, you need to create an API key that would allow your application to easily communicate with your database. To create an API key, you need to navigate to the security tab on the Fauna sidebar (on the left side of the screen).

Next, you will click on the NEW KEY button that will navigate you to the page below:

Here, your key role would be set to Server instead of Admin and set your Key name to our database name which is optional, then click on SAVE and you'd be navigated to a page where your database key would be displayed and meant to be copied immediately. You should see something like this:

After getting the API KEY, store it in the .env file in your coding environment.

Configuring Twilio

In order to demonstrate the procedure, you will set up your Twilio account to use WhatsApp by making use of the Twilio Sandbox for WhatsApp. To access the WhatsApp Sandbox in your Twilio Console, navigate to the Messaging section located on the left sidebar (if you can't see it, click on Explore Products to unveil the product list, where you can locate Messaging). Afterward, expand the "Try it out" dropdown and choose "Send a WhatsApp message" from the available choices. Subsequently, you will be presented with the following display:

After scanning the QR code, you will immediately receive a "join disease-see" message on your WhatsApp. Simply send the message, and just like that, you will be connected to your WhatsApp account.

Setting up the Environment

First, create an app.py file in your coding environment then you have to install the necessary libraries. You need to install faunadb, openai, python-dotenv, twilio, and flask libraries. You can use the following command to install them:
pip install telebot faunadb openai python-dotenv twilio flask

Once the libraries are installed, you can proceed to the code implementation.

Importing Libraries

Let's start by importing the required libraries in your Python script:

import telebot
from faunadb import query as q
from faunadb.objects import Ref
from faunadb.client import FaunaClient
import openai
from dotenv import load_dotenv
from twilio.rest import Client
import os
from flask import Flask, request
from twilio.twiml.messaging_response import MessagingResponse

You need to import faunadb for integrating FaunaDB, openai for utilizing OpenAI's gpt-3.5-turbo model, dotenv for loading environment variables, twilio for sending and receiving WhatsApp messages, os for accessing environment variables, flask for creating a web server, and twilio.twiml.messaging_response for generating TwiML responses.

Initializing Flask App and FaunaDB Client

Let's initialize the Flask app and create a FaunaDB client:

app = Flask(__name__)

def prompt(username, question):
    load_dotenv()
    client = FaunaClient(secret=os.getenv('FAUNA_SECRET_KEY'))
    # ...

You create a Flask app using the Flask(__name__) constructor. Inside the prompt function, you load the environment variables using load_dotenv() and create a FaunaDB client using the provided secret key.

Storing User Messages in FaunaDB

Within the prompt function, you store user messages in FaunaDB using the FaunaDB client:

data = {
    "username": username,
    "message": {
        "role": "user",
        "content": question
    }
}
result = client.query(
    q.create(
        q.collection("Messages"),
        {
            "data": data
        }
    )
)

You create a dictionary data containing the username and the user's question. Then you use the client.query method to create a new document in the "Messages" collection, storing the data dictionary.

Retrieving User Messages from FaunaDB

You retrieve the user messages from FaunaDB by querying the database based on the username:

index_name = "users_message_by_username"
username = username
result = client.query(
    q.map_(
        lambda ref: q.get(ref),
        q.paginate(q.match(q.index(index_name), username))
    )
)

messages = []

for document in result['data']:
    message = document['data']['message']
    messages.append(message)

You specify the index_name for the index to query from FaunaDB. Then you use q.paginate and q.match to retrieve all the documents associated with the given username. You loop through the result and extract the message content, storing it in the messages list.

Setting up OpenAI API

Let's set up the OpenAI API and define the assistant's persona:

openai.api_key = os.getenv('OPENAI_API_KEY')

system_message = {"role":"system", "content" : "You are a dietitian, food nutritionist, and fitness consultant, you provide expert guidance and advice to individuals facing dietary challenges or seeking direction on their food choices and exercise routines. You offer personalized recommendations and solutions to those who are unsure about the right foods to eat or the appropriate exercises to engage in. If user says hello or any greeting introduce yourself."}

prompt_with_persona = [system_message] + [
    {"role": "user", "content": message["content"]} if message["role"] == "user"
    else {"role": "assistant", "content": message["content"]} for message in messages
]

response = openai.ChatCompletion.create(
    model="gpt-3.5-turbo",
    messages=prompt_with_persona
)

generated_reply = response["choices"][0]["message"]["content"]

You set the OpenAI API key using os.getenv('OPENAI_API_KEY') from the .env file as created earlier. Then you define a system_message dict representing the assistant's persona. You construct the conversation prompt by combining the system_message with the user and assistant messages from the messages list.

Afterward, you make an API call to the OpenAI ChatCompletion API using openai.ChatCompletion.create(), passing the conversation prompt as the messages parameter. The API response contains the generated reply from the model, which you extract and store in the generated_reply variable.

Storing Assistant's Reply in FaunaDB

You store the assistant's reply in FaunaDB using the FaunaDB client:

newdata = {
    "username": username,
    "message": {
        "role": "assistant",
        "content": generated_reply
    }
}
result = client.query(
    q.create(
        q.collection("Messages"),
        {
            "data": newdata
        }
    )
)

You create a new dictionary newdata containing the username and the assistant's generated_reply. Then you use the client.query method to create a new document in the "Messages" collection, storing the newdata dictionary.

Handling WhatsApp Messages

Now, let's implement the route for handling WhatsApp messages:

@app.route('/whatsapp', methods=["POST", "GET"])
def chat():
    load_dotenv()
    twilio_phone_number = os.getenv('TWILIO_PHONE_NUMBER')
    sender_phone_number = request.values.get('From', '')
    username = request.values.get('ProfileName')
    question = request.values.get('Body')
    account_sid = os.getenv('TWILIO_ACCOUNT_SID')
    auth_token = os.getenv('TWILIO_AUTH_TOKEN')
    Twilioclient = Client(account_sid, auth_token)
    client = FaunaClient(
        secret=os.getenv('FAUNA_SECRET_KEY')
    )
    reply = None
    user_exists = client.query(
        q.exists(q.match(q.index("users_by_username"), username)))
    if user_exists:
        reply = prompt(username, question)
        answer = Twilioclient.messages.create(
            body=reply,
            from_=twilio_phone_number,
            to=sender_phone_number
        )
    else:
        client.query(
            q.create(
                q.collection("Users"),
                {
                    "data": {
                        "username": username
                    }
                }   
            )
        )
        reply = prompt(username, question)
        answer = Twilioclient.messages.create(
            body=reply,
            from_=twilio_phone_number,
            to=sender_phone_number
        )
    return str(answer.sid)

Inside the /whatsapp route, we load the environment variables, retrieve the necessary data from the incoming request, and create the Twilio and FaunaDB clients. We check if the user exists in FaunaDB using q.exists and q.match. If the user exists, we call the prompt function to generate a reply and send the reply back to the user using Twilio's messages.create() method. If the user doesn't exist, we create a new document in the "Users" collection and follow the same process as above.

Running the Flask App

Finally, let's run the Flask app:

if __name__ == '__main__':
    app.run(debug=True)

We use the if __name__ == '__main__': conditional statement to ensure that the app only runs if the script is executed directly, not imported as a module. The debug=True is set to in order to enable debug mode for better error messages during development. Now run python app.py in your terminal, it will run on localhost:5000. You can now go ahead to ngrok and run ngrok http 5000.

Copy the circled link and paste it in your WhatsApp sandbox

There you have it, you now have your own personal WhatsApp fitness and diet bot

Conclusion

In this article, you learned how to build a chatbot using Python, FaunaDB, OpenAI, and Twilio. We covered the code step by step, from initializing the Flask app to handling WhatsApp messages and generating responses using OpenAI's ChatCompletion API. You can use this code as a starting point to develop your own chatbot with additional features and integrations.

Happy Building!!

Building an intelligent WhatsApp bot for PDF Question-Answering using Langchain, Twilio, Python and ChatGPT

feranmiodugbemi — Tue, 08 Aug 2023 23:06:54 +0000

In today's digital age, messaging platforms have become integral to our daily communication. WhatsApp, with its vast user base and powerful features, offers an excellent opportunity to build intelligent chatbots that can provide instant and personalized assistance. In this article, we will explore how to leverage the power of Flask, Twilio WhatsApp, Langcain and ChatGPT models to create an intelligent WhatsApp bot that excels in PDF question-answering.

Twilio, a leading cloud communications platform, provides an array of tools and services to integrate messaging capabilities into your applications seamlessly. By combining Twilio's messaging API with Flask, a lightweight and flexible Python web framework, we can develop a robust backend for our WhatsApp bot.

To tackle the challenge of processing PDF files and extracting relevant information, we will dive into the realms of language models and natural language processing. OpenAI's advanced language models, such as GPT-3.5 Turbo, offer state-of-the-art capabilities for understanding and generating human-like text. By harnessing the power of OpenAI models using Langcain, we can transform our bot into a knowledgeable assistant that can answer questions based on the contents of uploaded PDF files.

Throughout this article, I will guide you step-by-step, drawing inspiration from Twilio's comprehensive publication guides. You will learn how to set up your development environment, handle incoming messages from WhatsApp, process PDF files, generate document embeddings, and perform question-answering tasks using Twilio, Flask, and powerful language models.

By the end of this tutorial, you will have a fully functional WhatsApp bot capable of providing accurate and insightful answers to questions posed by users. This opens up exciting possibilities for customer support, information retrieval, and automation, empowering businesses and individuals with an intelligent conversational agent at their fingertips.

So, let's dive into the world of Flask, Twilio, OpenAI, and Langchain and embark on a journey to build a remarkable WhatsApp bot that revolutionizes the way we interact with PDFs and obtain instant knowledge.

Prerequisites

Python: Make sure you have Python installed on your system.
Twilio Account: In order to send and receive messages, it is necessary to have a Twilio account. You will require an AUTH_TOKEN, Twilio phone number and ACCOUNT_SID for this purpose.
OpenAI API Key: To use OpenAI's GPT-3.5 model, you need an API key.
Ngrok: Ngrok is a tool that allows us to expose our local Flask server to the internet.

Install dependencies

To get started you'll need the following packages:

dotenv Library: Aloows you to load environment variables in your app. Install using pip install python-dotenv
Langchain: Allows you to use multiple tools for building AI powered apps. Install using pip install langchain
PyPDF2 Library: You will use the PyPDF2 library to read and extract text from PDF files. Install using pip install PyPDF2
Twilio Python Library: Allows you to interact with the twilio api in python. Install using pip install twilio
OpenAI: Enables you to have access to OpenAI's GPT models. Install using pip install openai

However, after installing this packages, you might be prompted to install additional packages in order for you to run the app.

Setting up Twilio Account

To illustrate the process, you will configure your Twilio account to utilize WhatsApp by utilizing the Twilio Sandbox for WhatsApp. Access the WhatsApp Sandbox within your Twilio Console by navigating to the Messaging section on the left sidebar (if you don't see it, click on Explore Products to reveal the product list, where you can find Messaging). Next, expand the "Try it out" dropdown and select "Send a WhatsApp message" from the options. You will then see this:

You will then go ahead and scan the QR code and you'd see "join disease-see" message in your Whatsapp, send it and like that you're connected to your WhatsApp.

Setting up our coding environment

We will then go into our code editor and create an app.py file and a .env file. In our .env file we will go ahead and include the following:



TWILIO_ACCOUNT_SID = xxxxxxxx
TWILIO_AUTH_TOKEN = xxxxxxxx
TWILIO_PHONE_NUMBER = xxxxxxxx
OPENAI_API_KEY = xxxxxxxx

In the pre-requisites, you should have named the respective tokens, which you will now substitute in place of xxxxxxxx.

Building the Bot

Now you've added all your tokens to your .env file and created an app.py file, you will go ahead and import all your dependencies



from flask import Flask, request
import os
from twilio.twiml.messaging_response import MessagingResponse
from twilio.rest import Client
from dotenv import load_dotenv
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain.embeddings.openai import OpenAIEmbeddings
import tempfile
from PyPDF2 import PdfReader
from langchain.vectorstores import FAISS
from langchain.llms import OpenAI
from langchain.chains.question_answering import load_qa_chain
app = Flask(__name__)


@app.route("/message", methods=["POST", "GET"])
def message():
    return "Hello, world"

if __name__ == "__main__":
    app.run(debug=True)

So, the above is the bare bones of the PDF Q and A bot, MessagingResponse to send messages in twilio, Client to access our twilio account, dotenv to access environment variables, RecursiveCharacterTextSplitter to split the texts in the uploaded texts, OpenAIEmbeddings to create word embeddings, requests to get our PDF file from twilio, templfile to create a temporary directory to store the uploaded PDF , PdfReader to be able to get read data from our uploaded pdf file, FAISS to create a vector store for similar texts of your questions in your PDF, load_qa_chain to create a question and answer model.

Next, append this code in the message() function:



    load_dotenv()
    OPENAI_API_KEY = os.getenv('OPENAI_API_KEY')
    response = None
    account_sid = os.getenv('TWILIO_ACCOUNT_SID')
    auth_token = os.getenv('TWILIO_AUTH_TOKEN')
    client = Client(account_sid, auth_token)
    twilio_phone_number = os.getenv('TWILIO_PHONE_NUMBER')
    sender_phone_number = request.values.get('From', '')
    pdf_url = request.values.get('MediaUrl0')
    response = None

This code is used to establish a connection with the Twilio client by retrieving environment variables. Also extracting important information from the sender, specifically the PDF URL, which will be requested later as it is stored in an S3 bucket.

Now you'd add this variables at the top of the @app.route as they will act as as global variables to be accessed later.



pdf_exists = False
VectorStore = None

Generating responses from the PDF

Receiving PDF



if media_content_type == 'application/pdf':
        global pdf_exists, VectorStore
        pdf_exists = True
        response = requests.get(pdf_url)
        with tempfile.NamedTemporaryFile(suffix='.pdf', delete=False) as temp_file:
            temp_file.write(response.content)
            temp_file_path = temp_file.name
            pdf = PdfReader(temp_file_path)
            text = ""
            for page in pdf.pages:
                text += page.extract_text()
            text_splitter = RecursiveCharacterTextSplitter(
                chunk_size = 1000,
                chunk_overlap = 200,
                length_function = len
            )
            chunks = text_splitter.split_text(text=text)
            embeddings = OpenAIEmbeddings()
            VectorStore = FAISS.from_texts(chunks, embedding=embeddings)
            response = "Recieved, You can now ask your Questions"

Firstly, the code verifies whether a PDF file has been received. If a PDF file is detected, the global variable called "pdf_exists" is set to true. Next, the code sends a request to the PDF's URL and retrieves the file. The file is temporarily stored in a directory and its contents are read. Then, the code iterates through the pages of the PDF, dividing the text into segments of 1000 words with an overlap of 200 words.

Afterwards, the code utilizes the OpenAIEmbeddings function to generate embeddings for the text segments. These embeddings are then passed into a VectorStore. Finally, a notification message is sent to indicate that the code is ready to answer questions related to the PDF.

Receiving text



elif pdf_exists:
        question = request.values.get('Body')
        if pdf_exists:
            docs = VectorStore.similarity_search(query=question, k=3)
            llm = OpenAI(model_name="gpt-3.5-turbo", temperature=0.4)
            chain = load_qa_chain(llm, chain_type="stuff")
            answer = chain.run(input_documents=docs, question=question)
            message = client.messages.create(
                body=answer,
                from_=twilio_phone_number,
                to=sender_phone_number
            )
            return str(message.sid)
        else:
            response = "No PDF file uploaded."

The provided code begins by checking if a text was received. If a text was indeed received, it further checks if a PDF file was previously sent by examining the variable pdf_exists. Following this, the code utilizes the VectorStore to search for similar texts based on the question provided. It then employs the gpt-3.5-turbo model to generate an answer based on the retrieved information. The generated answer is subsequently sent as a message, and the message SID (unique identifier) is returned.

However, if a text was sent but no PDF file was uploaded beforehand, the code sends a response stating "No PDF file uploaded."

Receiving an invalid format



else:
        print(media_content_type)
        response = "The media content type is not application/pdf"
    print(media_content_type)
    message = client.messages.create(
        body=response,
        from_=twilio_phone_number,
        to=sender_phone_number
    )

    return str(message.sid)

If the conditions in the if and elif statements are not met, the code will respond with a message stating "The media content type is not application/pdf."

Running our bot

Now go ahead to your terminal and run python app.py and our app will be running on localhost:5000. Now you can go ahead to Ngrok and run ngrok http 5000 so that you can send and receive WhatsApp messages. We should see something like this

Now, copy the circled link, go back to your Twilio sandbox settings and paste it there

There you have it, you can now upload PDFs to your WhatsApp bot and ask it questions

Conclusion

In conclusion, you have gained insights into various aspects of the provided code. You have explored its functionality, how it verifies PDF files, retrieves and processes their contents, generates embeddings, and uses models to answer questions. Furthermore, we have considered situations where specific response messages are triggered when certain requirements are not fulfilled. By comprehending these details, you now have a better understanding of the code's overall behavior and its outcomes in different scenarios.

Happy Building!!

Embracing Web3: My Journey into the Future of the Internet

feranmiodugbemi — Wed, 21 Jun 2023 09:38:07 +0000

Introduction

The evolution of the internet has brought about remarkable advancements in various fields, shaping our lives in unprecedented ways. However, a new paradigm is emerging that promises to revolutionize our digital experiences even further. This article chronicles my personal journey into Web3, highlighting the reasons behind my transition, the importance of Web3, and why you should consider embracing it too

My journey in Web2 and my little accomplishments

In the span of two years, I embarked on an exciting journey into Web2 development. I eagerly delved into various programming languages, but eventually focused on two: Node.js and Python. Through small projects, such as a meeting app that taught me React.js and an event scheduling app that introduced me to backend development, I honed my skills and expanded my knowledge. Along the way, I celebrated milestones like building a social media app, Integrating A.I functions into mobile apps, an app that helps to explain github repos and give ideas for contribution and receiving positive user feedback to so many other amazing projects. This journey has fueled my passion for programming and motivated me to continue exploring and constantly learning.

What is Web3?

Web3 can be simply defined as a decentralized version of the web. It aims to decentralize power and enable peer-to-peer interactions. It leverages blockchain technology and smart contracts to create a more secure, transparent, and user-centric online environment. Web3 envisions a world where individuals have greater control over their data, digital assets, and online identities, fostering trust, privacy, and innovation. Unlike the traditional Web2, which is largely centralized and controlled by a few dominant entities, Web3 aims to empower individuals and foster a more open and democratic online ecosystem. It envisions a future where users have greater control over their data, digital identities, and online interactions.

Why I chose Web3

Several factors played a role in shaping my decision to pursue Web3. Here are a few key considerations:

Saturation in the Web2 realm: As I ventured into the job market, applying for positions and internships, I experienced a mix of responses including acceptances and rejections. However, I noticed that the opportunities I secured often came with lower pay due to my junior developer status. This observation, coupled with the abundance of experienced senior developers in the Web2 domain, influenced my ultimate decision.
Job opportunities: Since it is in its early stages, Web3 provides opportunities for both junior and senior developers enabling the capable ones to get jobs and roles easily(from what I've heard and my research).
Employment prospects: Being in its nascent phase, Web3 presents job opportunities for developers at various levels of experience. This emerging field offers favorable conditions for both junior and senior developers, making it relatively easier for skilled individuals to secure roles and positions (based on anecdotal information and my research).
Supportive and Inclusive Community: The Web3 developer community is vast and inclusive, creating a favorable environment for newcomers. The presence of extensive documentation on various topics and subjects within the Web3 space makes it easier for new developers to learn and enhance their skills.
Empowerment, Ownership, and Decentralization: The three fundamental concepts that deeply resonate with me in Web3 are power, ownership, and decentralization. Web3 offers a system that places the user at the center, granting them exclusive control over their data and identity. This ensures that data and identity cannot be stolen, manipulated, sold, or exploited without the user's consent.
Attractive Compensation: The scarcity of developers in the Web3 space has led to companies offering substantial remuneration to blockchain developers who can provide innovative solutions for their needs.

My learning sources

1) CryptoZombies.io - CryptoZombies is an interactive coding tutorial that teaches you how to write smart contracts in Solidity through gamified lessons. It's a fun and engaging way to learn the basics of smart contract development.

2) Dapp University YouTube Channel - Dapp University is a popular YouTube channel dedicated to teaching blockchain development. The channel covers various topics related to Web3, Ethereum, smart contracts, decentralized finance (DeFi), and more, with hands-on tutorials and project walkthroughs

3) Tech with tim blockchain tutorial powered by Cartesi: This tutorial contains an indepth explanation of blockchain and how it works, building projects and ERC20 tokens.

Other learning sources

Ethereum.org - The official website of the Ethereum blockchain provides comprehensive documentation, tutorials, and resources to learn about Web3 development on Ethereum, including smart contracts, decentralized applications (dApps), and more.
Solidity Documentation - Solidity is the most widely used programming language for developing smart contracts on Ethereum. The Solidity documentation offers detailed explanations, examples, and best practices for writing smart contracts.
Web3.js Documentation - Web3.js is a JavaScript library that allows interaction with the Ethereum blockchain. The Web3.js documentation provides guidance on using the library to build decentralized applications, interact with smart contracts, and handle blockchain transactions.
OpenZeppelin - OpenZeppelin is a widely recognized open-source framework for building secure smart contracts on Ethereum. It offers reusable, audited contracts and libraries, along with guides and tutorials to help developers create robust decentralized applications.
Consensys Academy - Consensys Academy offers in-depth blockchain courses and educational resources. They cover a wide range of topics, including Ethereum development, decentralized application architecture, blockchain security, and token economics. Their courses are highly regarded in the industry.

Summary
In conclusion, I aspire to further enhance my expertise in this domain and make meaningful advancements and contributions to the realm of Web3. I invite you to be a part of this transformative journey as well. This doesn't mean I won't continue writing articles on web2 and A.I.

Happy building!!!!

Building a Fauna and GPT-3.5 turbo Powered Chatbot: A Step-by-Step Tutorial

feranmiodugbemi — Fri, 19 May 2023 22:48:43 +0000

Chatbots have revolutionized the way businesses interact with their customers, providing efficient and personalized assistance. In this tutorial, we will guide you through the process of building a chatbot powered by FaunaDB and the OpenAI GPT-3.5 turbo model. By following the steps outlined below, you'll be able to create an intelligent chatbot that can engage in meaningful conversations with users. Let's get started!

Prerequisites

To follow and fully understand this tutorial, you will need to have:

Python 3.6 or a newer version.
A text editor(VS code preferably).
An understanding of Fauna and Telegram bots.

Step 1: Setting Up the Environment

Before we begin, let's ensure that our development environment is properly set up. We'll need the following libraries:

telebot: A Python library for interacting with the Telegram Bot API.
faunadb: A Python driver for FaunaDB, a serverless cloud database.
openai: A Python library for accessing the OpenAI models.
dotenv: A Python library for loading environment variables from a .env file. Make sure you have these libraries installed. You can use pip to install them:

pip install pyTelegramBotAPI faunadb openai python-dotenv

Next, create a .env file in your project directory to store your environment variables. We'll use this file to store sensitive information like API keys.

Step 2: Setting Up the Fauna database

The first thing you need to get started with Fauna is to create an account on the official website. You can do that using either your email address or your github or netlify account here: https://dashboard.fauna.com/accounts/register
We'd need the fauna database to store and retrieve user's messages for effective communication with our chatbot

Creating our database

After creating our account with fauna, we will be creating a database to store our Users and Messages. Here we'd be asked for our database name and we are going to name it MyChatBot and our region is going to be set to Classic and like that we've created our database, easy right😌. Then, we should be presented with a screen like this one below:

Creating our collection

Next, we'd be creating our collections, which is basically Tables in the SQL world but with a twist in our context.

To create our Collection, click on the Create Collection button on the home page and give it a name, but since we'd be creating two collections we'd be naming them Users and Messages. The Users collection is for storing our user's data and ID from telegram, while the Messages collection is for storing the user's chat history with the bot. You will be asked for History Days and TTL. The History Days is used to define the number of days Fauna should retain a historical record of any data in that particular collection while the TTL serves as an expiry date for data in the collection. For example, if the TTL is set to 7, any data stored in that collection will be automatically deleted 7 days after its last modified date, but for this tutorial we'll not be needing it so it will be left untouched. After creating the two collections, we should be seeing this:

Creating our Index
Wondering what an Index is🤔?, Well an Index is simply a way to browse data in our collection more efficiently by organizing it based on specific fields or criteria, allowing for faster and targeted retrieval of information. To create our Index, we'll navigate to the Index tab and we should see something like this:

To create our Index, we first of all need to Select a Collection, then specify our Terms, which is the specific data the Index is only allowed to browse. But for this tutorial we will be creating two Indexes, users_by_id which would be under our Users collection for registering users and users_messages_by_username which would be filtering our user's messages by their username. The Terms for users_by_id would be set to data.user_id while the Terms for users_messages_by_username will be set to data.username, then click SAVE to continue.

Getting our Database key

Before we begin building a Python app that uses Fauna, we need to create an API key that would allow our application to easily communicate with our database. To create an API key, we need to navigate to the security tab on the Fauna sidebar (on the left side of the screen).

Next, we are to click on the NEW KEY button that will navigate us to the page below:

Here, we would set our key role to Server instead of Admin and set our Key name to our database name which is optional, then click on SAVE and we'd be navigated to a page where our database key would be displayed and meant to be copied immediately. We should see something like this:

After getting the API KEY, store it in the .env file we created earlier in a FAUNA_SECRET_KEY variable.

Step 3: Creating our telegram bot

A Telegram bot is an automated program that operates within the Telegram messaging platform. It is designed to interact with users and perform various tasks, such as providing information, delivering updates, answering queries, and executing commands. These bots are created using Telegram's Bot API and can be integrated into group chats or used in one-on-one conversations.

Conversation with BotFather
BotFather is an essential bot created by the developers of Telegram for creating and managing other bots on the Telegram platform. To interact with BotFather, we need to have a Telegram account. We can search for "@botfather" in the Telegram app to initiate a conversation.

Conversation with BotFather
To create a new bot with BotFather, we will use the /newbot and then supply the name of our bot and we'll then be given our bot API KEY which is the HTTP API access token in the image. We will the store our token key in our .env file in a BOT_SECRET variable. Now, we can now fully proceed to writing code🤩.

Step 4: Importing necessary packages:

As mentioned previously, we require certain packages to develop our bot. Now, we will proceed to import these packages.

import telebot
from faunadb import query as q
from faunadb.objects import Ref
from faunadb.client import FaunaClient
import openai
from dotenv import load_dotenv
import json
import os
load_dotenv()
bot = telebot.TeleBot(os.getenv("BOT_SECRET"))

The load_dotenv() is to load our environment variables and the bot = telebot.TeleBot(os.getenv("BOT_SECRET")) is to create a bot object for our telegram bot.

Step 5: Creating our commands:

Commands in Telegram bots are specific keywords or phrases that trigger the bot to perform a certain action or provide a specific response. For instance, when we utilized the /newbot command during our interaction with BotFather, it initiated a function that facilitated the creation of a new bot. Now, copy and paste the code down below:

def chat(question, user):
    userid = user.from_user.id
    username = user.from_user.username
    return question

def image(prompt, user):
    userid = user.from_user.id
    return image

user_state = {}
@bot.message_handler(commands=['start'])
def start_message(message):
    user_id = message.from_user.id
    username = message.from_user.username
    bot.reply_to(message, "Hello")
@bot.message_handler(commands=['chat'])
def chat_message(message):
    # Set the user's state to 'help' and output a help message
    user_state[message.chat.id] = 'chat'
    bot.reply_to(message, "Hello, how may i help you: ")


@bot.message_handler(commands=['image'])
def image_message(message):
    # Set the user's state to 'help' and output a help message
    user_state[message.chat.id] = 'image'
    bot.reply_to(message, "What kind of image are you creating today: ")


@bot.message_handler(commands=['reset'])
def reset_message(message):
    # Set the user's state to 'help' and output a help message
    user_state[message.chat.id] = 'reset'
    bot.reply_to(message, "Resetting chat......... ")

@bot.message_handler(func=lambda message: True)
def echo_all(message):
    if message.chat.id in user_state and user_state[message.chat.id] == 'chat':
        chat_message = message.text
        user = message
        bot.reply_to(message, chat(chat_message, user))

    elif message.chat.id in user_state and user_state[message.chat.id] == 'start':
        user = message
        bot.reply_to(message, user)
        user_state[message.chat.id] = None

    elif message.chat.id in user_state and user_state[message.chat.id] == 'image':
        image_prompt = message.text
        user = message
        bot.reply_to(message, image(image_prompt, user))
        user_state[message.chat.id] = 'image'
        bot.send_message(message.chat.id, "What Image are you creating again?")

    elif message.chat.id in user_state and user_state[message.chat.id] == 'reset':
        chat_reset = message.text
        bot.reply_to(message, reset())
        user_state[message.chat.id] = None


bot.polling()

Now, let's now go through the functionalities of the code above
The bot responds to user commands such as /start, /chatand /image, while maintaining the conversation state for each user using the user_state dictionary. Upon receiving the /start command, the bot sends a "Hello" reply and resets the user's state. Similarly, when the /chat command is received, the bot asks how it can help and sets the user's state to 'chat'. In the case of the /image command, the bot prompts the user for the type of image and sets the state to 'image'. For any other messages, the bot checks the user's state and responds accordingly, such as echoing the message in the 'chat' state, requesting the image prompt again in the 'image' state, providing user information and resetting the state in the 'start' state. The bot continuously listens for incoming messages using bot.polling().

Step 5: Updating our commands

The code provided in step 4 was only a small portion of our chatbot implementation. Presently, we will be enhancing our code to develop a fully operational chatbot.

The /start command
The /start command will serve as the initial entry point for our chatbot. It will verify whether a user exists in our faunadb User collection using the users_by_id index we created earlier, and if not, it will add the user to the User collection and then send a message that will redirect the user to our /chat which handles our chat functionalities. This process involves retrieving the user's username and ID from our Telegrambot API. The updated code:

@bot.message_handler(commands=['start'])
def start_message(message):
    client = FaunaClient(
        secret=os.getenv('FAUNA_SECRET_KEY')
    )
    user_id = message.from_user.id
    username = message.from_user.username
    user_exists = client.query(
        q.exists(q.match(q.index("users_by_id"), user_id)))
    if not user_exists:
        client.query(
            q.create(
                q.collection("Users"),
                {
                    "data": {
                        "user_id": user_id,
                        "username": username
                    }
                }
            )
        )
    bot.reply_to(message, "🌿🤖 Hello! Welcome to the fauna and gpt3 powered bot! 🌟💫\nTo begin, type /chat or click on it")

The /chat command
To create our chatbot, we will first create a faunadb client using the FaunaClient class and our secret key from an environment variable. Then, we will prepare a data object containing the username and the user's question, and insert it into the Messages collection in FaunaDB.

Next, we will retrieve the previous messages associated with the username by executing an index query. This query will retrieve all documents from the Messages collection that match the username, and we will extract the content of each message and store them in a list called "messages".

After that, we will set up the OpenAI API by configuring the API key from an environment variable. We will also define the persona of the assistant within a system message.

Then, we will construct the conversation prompt by combining the system message, user messages, and assistant messages from the messages list. We will use this conversation prompt to generate a response from the GPT-3.5 Turbo model, and then extract the generated reply from the API response.

We will then prepare the data for the assistant's reply and insert it into the Messages collection within FaunaDB. Finally, we will return the generated reply as the output of our chatbot.

def prompt(username, question):
    # Create a FaunaDB client
    client = FaunaClient(secret=os.getenv('FAUNA_SECRET_KEY'))
    data = {
        "username": username,
        "message": {
            "role": "user",
            "content": question
        }
    }
    result = client.query(
        q.create(
            q.collection("Messages"),
            {
            "data": data
            }
        )
    )
    index_name = "users_messages_by_username"
    username = username
    # Paginate over all the documents in the collection using the index
    result = client.query(
        q.map_(
            lambda ref: q.get(ref),
            q.paginate(q.match(q.index(index_name), username))
        )
    )

    messages = []

    for document in result['data']:
        message = document['data']['message']
        messages.append(message)

    # Set up OpenAI API
    openai.api_key = os.getenv('OPENAI_SECRET_KEY')

    # Define the assistant's persona in a system message
    system_message = {"role":"system", "content" : "A helpful assistant that provides accurate information."}

    # Construct the conversation prompt with user messages and the system message
    prompt_with_persona = [system_message] + [
        {"role": "user", "content": message["content"]} if message["role"] == "user"
        else {"role": "assistant", "content": message["content"]} for message in messages
    ]

    # Generate a response from the model
    response = openai.ChatCompletion.create(
        model="gpt-3.5-turbo",
        messages=prompt_with_persona
    )

    # Extract the generated reply from the API response
    generated_reply = response["choices"][0]["message"]["content"]

    newdata = {
        "username": username,
        "message": {
            "role": "assistant",
            "content": generated_reply
        }
    }
    result = client.query(
        q.create(
            q.collection("Messages"),
            {
            "data": newdata
            }
        )
    )

    return generated_reply

If the user exists, the preceding steps will take place, which is why we created a prompt function to handle this scenario. In our chat function, if the user exists, the prompt function is executed. However, if the user does not exist, they are redirected back to the /start command in order to register them. The updated chat function:

def chat(question, user):
    client = FaunaClient(
        secret=os.getenv('FAUNA_SECRET_KEY')
    )
    global chat_list
    userid = user.from_user.id
    username = user.from_user.username
    user_exists = client.query(
        q.exists(q.match(q.index("users_by_id"), userid)))
    if user_exists:
        reply = prompt(username, question)
        return reply
    else:
        return "🌿🤖 Hello! Welcome to the fauna and gpt3 powered bot! 🌟💫\nThis user is not logged in , type /start or click on it to login"

The /image command
The /image command is utilized to transform user text into images. Here's how it operates: First, it verifies if the user exists in the database. If the user exists, it proceeds to generate and return the image url output using the openAI Dall-E 2 model. The updated code:

def image(prompt, user):
    client = FaunaClient(
        secret=os.getenv('FAUNA_SECRET_KEY')
    )
    userid = user.from_user.id
    openai.api_key = os.getenv('OPENAI_SECRET_KEY')
    user_exists = client.query(
        q.exists(q.match(q.index("users_by_id"), userid)))
    if user_exists:
        generated_image = openai.Image.create(
            prompt=prompt,
            n=1,
            size="1024x1024"
        )
        image_url = generated_image['data'][0]['url']
        return image_url
    else:
        return "🌿🤖 Hello! Welcome to the fauna and gpt3 powered bot! 🌟💫\nThis user is not logged in , type /start or click on it to login"

Having completed the necessary implementations, it is now time to put our bot to the test and ensure its full functionality.

Conclusion

Congratulations! You have successfully built an intelligent chatbot using FaunaDB and the OpenAI GPT-3.5 turbo model. By integrating FaunaDB for message storage and retrieval, and leveraging the power of GPT-3.5 turbo for generating responses, your chatbot can engage in meaningful conversations with users.

Feel free to customize and enhance your chatbot by adding more features, improving the conversation flow, or integrating it with other platforms. The possibilities are endless!

Remember to handle security considerations, such as protecting sensitive data and managing access to API keys, to ensure the secure operation of your chatbot.

Happy bot-building!

Link to code: https://github.com/feranmiodugbemi/Fauna-chat-bot

Beyond Web 2.0: Exploring the Benefits and Opportunities of Web 3.0's Decentralized Future

feranmiodugbemi — Fri, 28 Apr 2023 18:49:05 +0000

Introduction

As the internet has evolved, so has the way we interact with it. The first iteration of the web, known as Web 1.0, was primarily static and focused on providing information. With the introduction of Web 2.0, the internet became more interactive, allowing users to contribute content and engage with others. Now, we stand on the precipice of another major shift in the way we use the internet, as Web 3.0 comes into focus.

Web 3.0 is the next generation of the internet, built on decentralized systems and utilizing blockchain technology. This new web promises to transform the way we interact with each other and the world around us, and there are several compelling reasons why you should consider transitioning from Web 2.0 to Web 3.0:

1.) Decentralization: One of the most significant differences between Web 2.0 and Web 3.0 is the move towards decentralization. With Web 2.0, content is created and controlled by a small number of powerful corporations. Web 3.0, on the other hand, allows for the creation and distribution of content to be in the hands of a decentralized community. This decentralized structure makes the internet more resilient and less vulnerable to censorship, manipulation, and other forms of control.

2.) Security: With Web 3.0, security is built into the system from the ground up. By utilizing blockchain technology, Web 3.0 ensures that data is secure and cannot be easily tampered with. This is particularly important given the rise of cybercrime and data breaches in recent years.

3.)Privacy: Web 2.0 has been criticized for its lack of privacy protections. With Web 3.0, users have greater control over their data and can decide who has access to it. This increased privacy is achieved through the use of decentralized identity solutions that allow users to control their own identity and data.

4.)Interoperability: Web 3.0 allows for greater interoperability between different applications and systems. This means that data can be easily shared between different platforms, enabling greater collaboration and innovation.

5.)Micropayments: Web 3.0 introduces the concept of micropayments, which allows for transactions as small as a few cents to be made easily and securely. This opens up new revenue streams for content creators and other participants in the decentralized ecosystem.

Conslusion

In conclusion, the transition from Web 2.0 to Web 3.0 represents a fundamental shift in the way we use the internet. By embracing decentralization, security, privacy, interoperability and micropayments. Web 3.0 promises to create a more open, inclusive, and decentralized internet that is resistant to censorship and manipulation. As Web 3.0 continues to evolve, it will be exciting to see the new applications and possibilities that emerge.

Introduction to serverless databases with faunadb and python

feranmiodugbemi — Wed, 12 Apr 2023 14:15:08 +0000

INTRODUCTION

In recent years, serverless computing has gained popularity as a way to build applications faster and more efficiently. One of the key components of serverless architecture is serverless databases, which eliminate the need for database servers and provide scalability and flexibility to handle fluctuating workloads.
FaunaDB is a serverless NoSQL database that allows you to build modern applications without worrying about database infrastructure management. In this article, we'll explore the basics of FaunaDB and how to use it with Python to create serverless applications by building a contact manager.

What is a serverless database?

A serverless database is a database that does not require any server infrastructure to manage or operate. Instead, it provides a cloud-based environment that automatically manages scalability, availability, and other operational tasks.

What is FaunaDB?

FaunaDB is a serverless NoSQL database that enables you to build applications with global scalability and high performance. It's designed to be developer-friendly, and it provides a flexible data model that allows you to store structured, semi-structured, and unstructured data.

Why use FaunaDB?

Serverless architecture: FaunaDB eliminates the need for database servers and provides automatic scaling, so you don't have to worry about infrastructure management.
Global distribution: FaunaDB is built on a globally distributed architecture, which means your data is always available and accessible from anywhere in the world.
Developer-friendly: FaunaDB provides a rich set of APIs and SDKs for various programming languages, making it easy to integrate with your application.
Flexible data model: FaunaDB supports a flexible data model that allows you to store structured, semi-structured, and unstructured data, making it suitable for a wide range of use cases.

Let's get started!

Step 1: Install required libraries

To get started, we'll need to install the required libraries. We'll be using the FaunaDB Python driver, Flask, and the dotenv library to load environment variables. You can install them using pip: pip install faunadb flask python-dotenv.
After that we will clone this github repo:https://github.com/feranmiodugbemi/ContactManager/tree/5d7d969a3ef23bb3cd81fb5b8f41e2b04883e4ba. Then, we will create a .env and a .gitignore file in our root directory. We should have something like this in our directory:

Though this is an updated code but our UI should look something like this after we run python app.py at http://localhost:5000/:

Step 2: Creating our database

To create our database watch this video below:
Our database should be named "Contactmanager" and should not be prepopulated with demo data

Step 3: Creating our Collection

A collection is simply a grouping of related data or documents within a database. To create our Collection watch this video below:
Our Collection should be named "Users".

Step 4: Getting our FaunaDB access key

Next, you need to set up your database access key. You can get your access key by creating an account on FaunaDB's website and then create a new database. Watch this video if you don't know how to get your "access key":

Then we store our "access key" in our .env file in a FAUNASECRET variable.

Step 5: Updating our UI

Bceause I will not be going into details about the UI. Delete everything in the index.html file and replace it with the HTML in this link: https://github.com/feranmiodugbemi/ContactManager/blob/master/templates/index.html

Step 6: Setting up our flask application

First, let's create a new Flask application and import the necessary libraries. We'll be using the faunadb library to interact with FaunaDB, and dotenv to load environment variables.

from flask import Flask, render_template, request, flash, redirect
from faunadb import query as q
from faunadb.objects import Ref
from faunadb.client import FaunaClient
from dotenv import load_dotenv
import os

load_dotenv()
app = Flask(__name__)
app.config["SECRET_KEY"]='Feranmiodugbemi'

Also, you can name your app.config whatever you like.
We also need to connect to FaunaDB. To do this, we'll create a new instance of FaunaClient and pass in our FaunaDB secret key, which we'll store in an environment variable.

client = FaunaClient(
  secret=os.getenv('FAUNASECRET')
)

Step 7: Creating a new contact

Now that we have our Flask application set up and connected to FaunaDB, we can create the functionality to create, update, and delete contacts.

Let's start with creating a new contact. We'll define a new route and add a form to our HTML template to collect the necessary information.

@app.route("/", methods=["POST", "GET"])
def hello():
    if request.method == "POST":
        name = request.form.get('name')
        occupation = request.form.get('occupation', default='')
        address = request.form.get('address', default='')
        contact = request.form.get('contact')
        email = request.form.get('email', default='')
        client.query(
            q.create(
                q.ref('collections/Users'),
                {
                    'data':{
                        'id': q.new_id(),
                        'name':name,
                        'occupation':occupation,
                        'address' : address,
                        'contact': contact,
                        'email': email
                    }
                }
            )
        )
        flash("New contact added successfully", category="success")
        return redirect('/')
    else:
        return render_template('index.html')

In this code, we're using the request object to retrieve the data from the form. We're then using the create function from the query module of faunadb to create a new contact in our FaunaDB database. The create function takes two arguments: the collection where we want to add the new contact, and the data we want to add.

We're also using the flash function to display a success message to the user, and then redirecting them back to the homepage.

Step 8: Getting all the contacts

Next, let's add the functionality to get all the contacts from our FaunaDB database and display them on the homepage. We'll define a new route and use the paginate function from the query module to retrieve all the documents in our collection and store them in a list called data. We then pass this list to the index.html template as a parameter to display the data.

# Getting all the contacts
result = client.query(
    q.map_(
        q.lambda_("x", q.get(q.var("x"))),
        q.paginate(q.documents(q.collection("Users")))
    )
)
data = [doc["data"] for doc in result["data"]]
return render_template('index.html', data=data)

We will replace the code in the else statement with the code above.

Step 9: Creating our index

Incase you're wondering what an index is🤔, an Index is a data structure that improves the speed of data retrieval operations on a database table. It is essentially a list of values that are organized in a specific order to facilitate faster search and retrieval of data.

An index is created on one or more columns of a database table, and it can be used to quickly locate rows of data based on the values in those columns. By creating an index, database queries can be optimized, resulting in faster response times and improved performance and FaunaDB make it very easy to create an index. You can create an index by following this video below:

Our index should be named "users_by_id"

Step 10: Adding our Delete Functionality

The delete functionality is implemented in the delete route. This route takes an id parameter that is used to select the document to be deleted from the collection using the index. We first convert the id parameter to a string, then use it to search for the document in the collection using a match query. We then use the select query to retrieve the document reference and use it to delete the document.

@app.route('/delete/<int:id>')
def delete(id):
    id = str(id)
    result = client.query(
        q.select(['ref'], q.get(q.match(q.index("users_by_id"), id)))
    )
    client.query(q.delete(result))
    return redirect('/')

Step 11: Adding our Update Functionality

The update functionality is implemented in the update route. This route takes an id parameter that is used to select the document to be updated from the collection using the index. We first convert the id parameter to a string, then use it to search for the document in the collection using a match query. We then use the select query to retrieve the document reference and use it to update the document.

@app.route('/update/<int:id>', methods=["POST"])
def update(id):
    id = str(id)
    if request.method == "POST":
        name = request.form.get('updatename')
        occupation = request.form.get('updateoccupation', default='')
        address = request.form.get('updateaddress', default='')
        contact = request.form.get('updatecontact')
        email = request.form.get('updateemail', default='')
        result = client.query(
            q.select(['ref'], q.get(q.match(q.index("users_by_id"), id)))
        )
        client.query(
            q.update(result, {
                'data':{
                    'name': name,
                    'occupation': occupation,
                    'address': address,
                    'contact': contact,
                    'email': email
                }
            })
        )
    return redirect('/')

Conclusion

In this article, we have shown how to use FaunaDB with Python Flask to create a simple CRUD application. We have provided explanations and additional information for each functionality implemented in the application. We hope that this article has been helpful in introducing FaunaDB and demonstrating its use in a practical application. You can get the full code to the github repo here: https://github.com/feranmiodugbemi/ContactManager. If you have any questions, don't hesitate to contact me on Twitter: @FeranmiOdugbemi

How to Create an AI-Powered Chatbot with Gradio and OpenAI's GPT-3.5

feranmiodugbemi — Mon, 13 Mar 2023 00:00:49 +0000

Introduction

Artificial intelligence (AI) has revolutionized the way we interact with technology. From virtual assistants to chatbots, AI-powered tools have become an integral part of our daily lives. In this tutorial, we will show you how to create a simple AI-powered chatbot using Gradio and OpenAI's GPT-3 natural language processing model.

Gradio is a Python library that enables developers to create customizable UI components for machine learning models. It provides an easy-to-use interface for building web-based apps that can run locally or on the cloud. OpenAI's GPT-3 is one of the most advanced natural language processing models available today. It can generate human-like responses to text inputs, making it ideal for chatbot applications.

Let's get started!

Step 1: Install Required Libraries

The first thing you need to do is to create your "app.py" file and then install the required libraries. These include:

gradio: a web app library for creating customizable UI components
openai: a Python wrapper for OpenAI's GPT-3 API
pyttsx3: a Python library for text-to-speech conversion
dotenv: a library for loading environment variables from a .env file

You can install these libraries using pip, like this:



pip install gradio openai pyttsx3 python-dotenv

Step 2: Set Up OpenAI API Key

Next, you need to set up your OpenAI API key. You can get your API key by creating an account on OpenAI's website. Watch this video if you don't know how to get your "API key"

Once you have your API key, create a file called ".env" in your project directory and add the following line:



OPENAI_API_KEY=<your-api-key>

This will load your API key as an environment variable that you can access in your Python code using the dotenv library.

Step 3: Define Chatbot Function

Now, we will define the function that will power our chatbot. Here's the code:



import gradio as gr
import openai
import pyttsx3
from dotenv import load_dotenv
import os
load_dotenv()

openai.api_key =  os.getenv("OPENAI_API_KEY")

messages=[
        {"role": "system", "content": "You are a teacher"}
    ]
def transcribe(audio):
    global messages
    file = open(audio, "rb")
    transcription = openai.Audio.transcribe("whisper-1", file)
    print(transcription)
    messages.append({"role": "user", "content": transcription["text"]})
    response = openai.ChatCompletion.create(
        model="gpt-3.5-turbo",
        messages=messages
    )

    AImessage = response["choices"][0]["message"]["content"]
    engine = pyttsx3.init()
    engine.say(AImessage)
    engine.runAndWait()
    messages.append({"role": "assistant", "content": AImessage})
    chat = ''
    for message in messages:
        if message["role"] != 'system':
            chat += message["role"] + ':' + message["content"] + "\n\n"
    return chat


ui = gr.Interface(fn=transcribe ,inputs=gr.Audio(source='microphone',type='filepath'), outputs='text')

ui.launch()

This function takes an audio input from a microphone, transcribes it using OpenAI's Audio API, sends it to GPT-3 for processing, and returns the AI-generated response as text. It also converts the response to speech using the pyttsx3 library.

Let's go over the key components of this function:

The "messages" list stores the conversation history between the user and the chatbot. It is initialized with a system message telling the user that they are a teacher.
The "transcribe" function takes an audio file path as input and reads it using the "open()" function. It then transcribes the audio using OpenAI's Audio.transcribe() method and adds the user's message to the "message" list.
The "openai.Completion.create()" method sends the conversation history to GPT-3 for processing and generates a response based on the previous messages.
The "AImessage" variable stores the generated response text. We then use the "pyttsx3" library to convert the text to speech and play it back to the user. Finally, we add the AI-generated response to the "messages" list and format the conversation history as a string that can be returned to the user.

Step 4: Create Gradio Interface

Now that we have our chatbot function defined, we can create a Gradio interface to capture audio input from the user and display the chat history. Here's the code:



ui = gr.Interface(fn=transcribe, inputs=gr.Audio(source='microphone', type='file'), outputs='text')
ui.launch()

This code creates a Gradio interface object and sets the "fn" parameter to our "transcribe" function. We specify that the input type is a microphone audio source and the output type is text. Finally, we launch the interface using the "launch()" method.

Step 5: Run the Chatbot

To run the chatbot, simply run the Python script gradio app.py or python app.py incase gradio app.py doesn't work and it will run on http://127.0.0.1:7860. Gradio will launch a web-based interface that allows users to speak into their microphone and receive AI-generated responses in real-time and it will then look like this:

Then you can click on the "Record from microphone" button to start recording your voice command and press "Stop recording" to stop recording and send your voice command to the server else it will return an error; press the "Submit" button to send your voice command and watch the magic that happens. Then click on the "Clear" button to record another voice command again.

Conclusion

In this tutorial, we've learnt how to create a simple AI-powered chatbot using Gradio and OpenAI's GPT-3.5 model. With just a few lines of code, you can build a chatbot that can generate human-like responses to text inputs, making it ideal for a variety of applications. We hope you found this tutorial helpful and we encourage you to explore the many other applications of AI and machine learning in your own projects. Here is the link to the project :
https://github.com/feranmiodugbemi/python-Chatgptapi

Introduction to Artificial Intelligence, Machine Learning and Neural networks

feranmiodugbemi — Mon, 27 Feb 2023 01:53:12 +0000

What is Artificial intelligence?
Artificial intelligence (AI) is the ability of machines to perform tasks that typically require human intelligence, such as visual perception, speech recognition, decision-making, and language translation.

What is machine learning?
Machine learning is a field of computer science and artificial intelligence (AI) that focuses on the development of algorithms and statistical models that enable computer systems to learn from and make predictions or decisions based on data. In essence, machine learning involves creating programs that can automatically improve their performance on a task by learning from experience or data.

What is a neural network?
A neural network is a type of machine learning algorithm that is designed to recognize patterns and make decisions or predictions based on input data. It is inspired by the structure and function of the human brain and is therefore also known as an artificial neural network.

Tensorflow and Keras
Tensorflow is an open-source software library for dataflow and differentiable programming across a range of tasks. It is developed by the Google Brain team and used extensively in machine learning and deep learning applications.

Keras is a high-level neural networks API written in Python and integrated with Tensorflow as its default backend. Keras provides an easy-to-use interface for building, training, and deploying deep learning models.

Demo project
Let's now walk through a demo project that uses Tensorflow and Keras to build a machine learning model. We will use the Fashion MNIST dataset, which contains 70,000 grayscale images of 10 different types of clothing items. The goal of our model is to predict the type of clothing item in a given image.

Here's the code for the demo project:

import tensorflow as tf
import keras as k
from tensorflow import keras
import numpy as np
import matplotlib.pyplot as plt

data = keras.datasets.fashion_mnist

(train_images, train_labels), (test_images, test_labels) = data.load_data()

class_names = ["T-shirt", "Trouser", "Pullover", "Dress", "Coat", "Sandal", "Shirt", "Sneaker", "Bag", "Ankle boots"]

train_images = train_images/255.0
test_images = test_images/255.0

model = k.Sequential([
    keras.layers.Flatten(input_shape=(28,28)),
    keras.layers.Dense(128, activation="relu"),
    keras.layers.Dense(10, activation="softmax")  
])

model.compile(optimizer="adam", loss="sparse_categorical_crossentropy", metrics=["accuracy"])

model.fit(train_images, train_labels, epochs=5)

prediction = model.predict(test_images)
for i in range(5):
    plt.grid(False)
    plt.imshow(test_images[i], cmap=plt.cm.binary)
    plt.xlabel("Actual: " + class_names[test_labels[i]])
    plt.title("Prediction: "+ class_names[np.argmax(prediction[i])] )
    plt.show()

Let's go through the code step by step.

Libraries Import

import tensorflow as tf
import keras as k
from tensorflow import keras
import numpy as np
import matplotlib.pyplot as plt

The first few lines import the necessary modules: Tensorflow, Keras, Numpy, and Matplotlib

Data loading

data = keras.datasets.fashion_mnist
(train_images, train_labels), (test_images, test_labels) = data.load_data()

This block loads the Fashion-MNIST dataset from Keras. This dataset contains 60,000 training images and 10,000 testing images of 10 different clothing items. The "load_data()" function returns the training and testing images as well as their corresponding labels.

Data Preprocessing

class_names = ["T-shirt", "Trouser", "Pullover", "Dress", "Coat", "Sandal", "Shirt", "Sneaker", "Bag", "Ankle boots"]
train_images = train_images/255.0
test_images = test_images/255.0

This block defines the names of the 10 clothing items in the dataset and scales the pixel values of the images to be between 0 and 1. This is a common preprocessing step for image data.

Model Building

model = k.Sequential([
    keras.layers.Flatten(input_shape=(28,28)),
    keras.layers.Dense(128, activation="relu"),
    keras.layers.Dense(10, activation="softmax")  
])
model.compile(optimizer="adam", loss="sparse_categorical_crossentropy", metrics=["accuracy"])

This block defines the neural network model to be used and compiles it with an optimizer, loss function, and evaluation metric. The model has three layers: a flatten layer to convert the 2D image data into a 1D array, a dense layer with 128 neurons and ReLU activation function, and a dense output layer with 10 neurons and softmax activation function to output the probability of each class.

Model Training

model.fit(train_images, train_labels, epochs=5)

This block trains the neural network model using the training images and labels for a specified number of epochs. During training, the model adjusts its parameters to minimize the loss function and improve its accuracy on the training data.

Prediction and Visualization

prediction = model.predict(test_images)
for i in range(5):
    plt.grid(False)
    plt.imshow(test_images[i], cmap=plt.cm.binary)
    plt.xlabel("Actual: " + class_names[test_labels[i]])
    plt.title("Prediction: "+ class_names[np.argmax(prediction[i])] )
    plt.show()

This block makes predictions on the test images using the trained model and visualizes the first 5 test images with their corresponding actual labels and predicted labels. The "argmax()" function is used to get the index of the predicted class with the highest probability.

In summary, this code demonstrates how to build a simple neural network using Keras and Tensorflow to classify images of clothing from the Fashion MNIST dataset. The code showcases how to load the data, define the neural network architecture, compile and train the model, and make predictions on new data.

So, there we go we've just trained a basic neural network. Here is the link to the Github repository https://github.com/feranmiodugbemi10/Demo-AI.👋

Image Conversion Web App with Python and Flask

feranmiodugbemi — Fri, 10 Feb 2023 02:03:49 +0000

In this article, we will create a simple image conversion web app using Python Flask and Python Image Library (PIL). This app allows users to upload an image, choose a format, and convert the image to the selected format. The article is intended for developers who are looking to build a simple web app with Flask.

Installing Required Packages

To start, we will install two packages that we will be using in this project: Flask and Pillow (Python Image Library). To install them, run the following command:
pip install Flask Pillow

Creating Required Files

We will be creating three files for this project: app.py, convert.html, and index.html.

Flask Server

Let's start by creating a Flask server in the app.py file. In this file, we will write the code for our Flask application. First, we will import the necessary modules and then the code for running our app

from flask import Flask, render_template, request, redirect
from PIL import Image
import os

app = Flask(__name__)

@app.route('/')
def hello():
    return render_template("index.html")

if __name__ == '__main__':
    app.run(debug=True)

In the code above, we are importing the required packages and creating a Flask instance. We also have a home page route that returns an index.html file.

HTML and JavaScript Template

Next, we will create two HTML templates: index.html and convert.html inside a templates folder. The index.html file will be the home page of our web application, where users will be able to upload images to be converted. The convert.html file will be used to display the converted image.
We can use a ready-made HTML template from a website such as https://bootstrapious.com for the index.html file. This template will provide a user-friendly interface for uploading images and selecting the format to convert the image to.

In the Index.html template, we will include in the form the following parameters:

<form action="/convert" enctype="multipart/form-data" method="post" id="form">

This form will be used to submit the uploaded image for conversion in a "/convert" route which we will create shortly in our app.py, also we are sending a multipart/form-data because we are submitting a text and an image, so we are splitting the data.

In this template, you will need to add the following code for the image input field:

<input id="upload" type="file" onchange="readURL(this);" name="image" accept=".jpg, .png, .bmp, .eps, .gif, .im, .msp, .pcx, .ppm, .tiff" class="form-control border-0">

The "accept" attribute specifies the types of files that can be uploaded.

We will also add a select field to specify the format to convert the image to:

<div class="input-group mb-3">
                <select class="custom-select" id="inputGroupSelect02" name="format">
                    <option value="BMP" selected>BMP</option>
                    <option value="EPS">EPS</option>
                    <option value="GIF">GIF</option>
                    <option value="IM">IM</option>
                    <option value="JPEG">JPEG</option>
                    <option value="MSP">MSP</option>
                    <option value="PCX">PCX</option>
                    <option value="PNG">PNG</option>
                    <option value="PPM">PPM</option>
                    <option value="TIFF">TIFF</option>
                </select>
                <div class="input-group-append">
                     <label class="input-group-text" for="inputGroupSelect02">To</label>
                </div>
            </div>
            <button type="submit" class="btn btn-outline-secondary">convert</button>
            <br>.

This code displays the options for the image formats that we offer to convert to.

Our "Index.html" file will end up looking like this:

<!DOCTYPE html>

<html>
    <head>
        <meta charset="utf-8">
        <meta http-equiv="X-UA-Compatible" content="IE=edge">
        <title>Image converter</title>
        <meta name="description" content="">
        <meta name="viewport" content="width=device-width, initial-scale=1">
        <link rel="stylesheet" href="static/css/index.css">
        <script src="https://code.jquery.com/jquery-3.5.1.min.js"></script>
       <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/bootstrap@4.6.2/dist/css/bootstrap.min.css">
    </head>
    <body>

        <h1> This is an image converter </h1>
        <div class="container py-5">

    <!-- For demo purpose -->
    <header class="text-white text-center">
        <h1 class="display-4">Bootstrap image upload</h1>
        <p class="lead mb-0">Build a simple image upload button using Bootstrap 4.</p>
        <p class="mb-5 font-weight-light">Snippet by
            <a href="https://bootstrapious.com" class="text-white">
                <u>Bootstrapious</u>
            </a>
        </p>
        <img src="https://bootstrapious.com/i/snippets/sn-img-upload/image.svg" alt="" width="150" class="mb-4">
    </header>


    <div class="row py-4">
        <div class="col-lg-6 mx-auto">

            <!-- Upload image input-->
            <form action="/convert" enctype="multipart/form-data" method="post" id="form">
            <div class="input-group mb-3 px-2 py-2 rounded-pill bg-white shadow-sm">
                <input id="upload" type="file" onchange="readURL(this);" name="image" accept=".jpg, .png, .bmp, .eps, .gif, .im, .msp, .pcx, .ppm, .tiff" class="form-control border-0">
                <label id="upload-label" for="upload" class="font-weight-light text-muted">Choose file</label>
                <div class="input-group-append">
                    <label for="upload" class="btn btn-light m-0 rounded-pill px-4"> <i class="fa fa-cloud-upload mr-2 text-muted"></i><small class="text-uppercase font-weight-bold text-muted">Choose file</small></label>
                </div>
            </div>


            <div class="input-group mb-3">
                <select class="custom-select" id="inputGroupSelect02" name="format">
                    <option value="BMP" selected>BMP</option>
                    <option value="EPS">EPS</option>
                    <option value="GIF">GIF</option>
                    <option value="IM">IM</option>
                    <option value="JPEG">JPEG</option>
                    <option value="MSP">MSP</option>
                    <option value="PCX">PCX</option>
                    <option value="PNG">PNG</option>
                    <option value="PPM">PPM</option>
                    <option value="TIFF">TIFF</option>
                </select>
                <div class="input-group-append">
                     <label class="input-group-text" for="inputGroupSelect02">To</label>
                </div>
            </div>
            <button type="submit" class="btn btn-outline-secondary">convert</button>
            <br>
            </form>
            <!-- Uploaded image area-->
            <p class="font-italic text-white text-center">The image uploaded will be rendered inside the box below.</p>
            <div class="image-area mt-4"><img id="imageResult" src="#" alt="" class="img-fluid rounded shadow-sm mx-auto d-block"></div>

        </div>
    </div>
</div>


        <script src="static/javascript/index.js"></script>

        <script src="https://cdn.jsdelivr.net/npm/jquery@3.6.1/dist/jquery.slim.min.js"></script>
        <script src="https://cdn.jsdelivr.net/npm/popper.js@1.16.1/dist/umd/popper.min.js"></script>


        <script src="https://cdn.jsdelivr.net/npm/bootstrap@4.6.2/dist/js/bootstrap.bundle.min.js"></script>
    </body>
</html>

In the next part of our code, we handle the file conversion process in the backend.

Now, Let's create our "/convert" route in our app.py:

@app.route('/convert', methods=["POST", "GET"])
def convert():
    return redirect("/")

So what we did here was just create the route that accepts both POST and GET requests. If a GET request is made, the user will be redirected to the main page.

Now, Let's get our image from the frontend:

@app.route('/convert', methods=["POST", "GET"])
def convert():
    if request.method == "POST":
        file = request.files["image"]
        format = request.form.get("format")
   return redirect("/")

Here, if a POST request is made, we retrieve two inputs from the user. The first input is the image file, and the second input is the desired format for the conversion. The desired format is obtained from the select input in the "index.html" file.
Note: the name parameter must be format else it won't work.

After retrieving the inputs, we split the filename into two parts - the output image and its file type. We then convert the desired format to lowercase.

Next, we open the image using the Python Image Library (PIL) and save it with the desired format. We then move the image to a newly created folder called "images" within the "static" folder to keep our files organized.

Finally, we generate the URL of the image and pass it to the "convert.html" template using the "render_template" function. The final output of the "app.py" file is as follows:

@app.route("/convert", methods=["POST", "GET"])
def convert():
    if request.method == "POST":
        file = request.files["image"]
        format = request.form.get("format")
        outputimage, x = file.filename.split('.')
        format = format.lower()
        outputimage = outputimage + "." + format
        with Image.open(file) as image:
            image.convert('RGB').save( outputimage)
            path = 'static/images/' + outputimage 
            os.rename(outputimage, path )
            filepath = 'images/' + outputimage
            image_url = url_for('static', filename=filepath)
        return render_template("convert.html", image_url=image_url)

    return redirect("/")

Now that we have our image conversion code working, it's time to display the image on a webpage and make it look presentable.

We start by opening our convert.html file and displaying the image using the following HTML code:

<div class="container">
        <img src="{{ image_url }}" class="img-fluid" alt="Responsive image">
        <br><br>
        <a download href="{{ image_url }}" class="download-btn">Download</a>
        <a href="javascript:history.back()" class="back-btn">Back</a>
      </div>

Here, the "" tag is used to display the image, and the "src" attribute is set to "image_url" so that the URL of the converted image is dynamically displayed on the page.

We also added a download button using the tag, which allows the user to download the image with a single click. The download attribute is used to specify that the linked resource should be downloaded, rather than navigating to it.

Now, let's make the page look more attractive by adding some basic styling using CSS.

<style>
        .container {
        text-align: center; 
        background-color: #f2f2f2; 
        padding: 20px; 
        border-radius: 10px;
      }

      .img-fluid {
        width: 50%;
        height: auto;
      }

      .download-btn, .back-btn {
        background-color: #757f9a;; 
        color: white; 
        padding: 10px 20px; 
        border-radius: 20px; 
        text-decoration: none;
        margin-top: 20px;
      }
    </style>

The .container class sets the background color, padding, and border radius for the overall container. The .img-fluid class sets the width of the image to 50% and the height to auto to make the image responsive.

The .download-btn and .back-btn classes set the background color, text color, padding, border radius, and margin for the download and back buttons, respectively.

To run the app, navigate to the directory containing the files and run the following command in the terminal:

python app.py

Then, open a web browser and navigate to http://localhost:5000.

And that’s it, our image conversion app is now complete! You can now run the application using the command ‘python app.py’ and you should be able to convert your images to the desired format by uploading an image from your computer, selecting a format from the dropdown, and clicking the convert button. You can then download the converted image from the app and see the changes for yourself.

We have now successfully created a simple and effective image conversion app using Flask, PIL and HTML/CSS. This app can be further improved by adding more image formats, error handling, and more styling to make it visually appealing, but for now, we have a working model that can be used as a starting point. The complete code for this project is available on my GitHub repository at https://github.com/feranmiodugbemi10/imageconverter.git. Feel free to clone the repository and use the code as a starting point for your own projects.

I hope this article was helpful in understanding how to create an image conversion app using Flask, PIL and HTML/CSS. If you have any questions or feedback, please let me know in the comments section below.