DEV Community: Hameed Osilaja

Postmortem: Service Outage on MathEase Platform

Hameed Osilaja — Sat, 11 Nov 2023 17:01:19 +0000

In a world not so far away, where APIs responded happily until they didn't... 😥

Issue Summary.

Duration - 1 hour 25 minutes (Start: 07-10-2023 10:21 GMT, End: 07-10-2023 11:46 GMT), coincided with my coffee break, lol.
Impact - unsuspecting and happy users were unable to get answers to math questions, it just keeps loading without returning a response (like bro, what the...).
Root cause - too much API calls to the WolframAlpha API, due to an increase in traffic after our marketing campaign blew off, i guess WolframAlppha was like, bro, this is way too much than we signed up for 😂.

Timeline.

The issue was detected at 07-10-2023 10:21 GMT by automated monitoring systems triggering an alert for external API failure and unusually high traffic.
Actions Taken - Assumed the issue might be related to a recent code deployment that introduced a performance regression, but then ran tests on the codebase and found out the WolframAlpha API was not responding. Took the issue to the backend team for further investigation.
Misleading Investigation - Investigated recent code changes extensively, diverting attention from the actual cause (if it was, I would have completely roasted Folarin, cause he pushed the last code to deployment, lucky him 😐).
Escalated - The issue was escalated to the backend team.
Resolution - Increased rate limit and paid for premium service of the WolframAlpha API. Also implemented emergency scaling of server resources to handle the unexpected traffic.

Root Cause and Resolution.

Root cause - The surge in number of external API calls and traffic was caused by a successful marketing campaign that brought in significantly more users than anticipated.
Resolution - Upgraded the WolframAlpha external API service to a premium one. Reviewed and updated infrastructure capacity planning to accommodate sudden spikes in traffic.

Corrective and Preventive Measures.

Enhanced monitoring to provide early warnings for external API failures.
Conduct regular capacity planning exercises to anticipate and handle increased user loads.
Tasks.
Enhance communication strategies for informing users during service outages.
Conduct a thorough review of the incident response process for better coordination.
Implement the early warning alert system on DataDog.

What Happens When You Type 'www.google.com' and press Enter.

Hameed Osilaja — Sun, 15 Oct 2023 19:52:59 +0000

Have you ever wondered what happens behind the scene when you enter a URL like 'www.google.com' into your web browser and hit Enter?

The process might appear as though it’s simple, but under the hood, so many complex operations take place to deliver the web page you requested. In this article, we’ll walk through the journey of a web request, explaining in detail each stage from the moment you press enter to the moment you see Google’s homepage.

Schema illustrating the flow of the request created when you type https://www.google.com in your browser and press Enter

Here’s an overview of the things we’ll be discussing during the course of this article;

DNS Request.
TCP/IP.
Firewall.
HTTPS/SSL.
Load-balancer.
Web server.
Application server.
Database.

Now, let’s take all these one after the other.

DNS request.

The moment you enter a website address in your web browser and hit Enter, your browser initiates a Domain Name System (DNS) request. The DNS server’s job is to translate human-readable URL such as 'www.google.com' into an IP address which is how computers identify websites on the internet.

Why does this have to happen?

Computers identify servers through IP addresses. An Internet Protocol (IP) address is the unique identifying number assigned to every device connected to the internet, they usually look something like this “192.168.123.132”. Imagine having to memorize numerical IP addresses of every single website you visit, a really challenging task given the vast number of websites available. So, that’s where DNS comes in, DNS simplifies the process, allowing you to use user-friendly domain names (which are easier to remember by the way), while it takes care of the translation behind the scenes. Now, let’s take a look at the behind the scenes process.

The DNS resolution process.

When you enter a URL like 'www.google.com' in your browser, and press enter, your device sends a DNS query to a local DNS resolver.
The resolver checks its cache to see if it has the IP address for 'www.google.com'.
If not, it contacts the root server. The root server does not have the specific IP address, but it directs the resolver to the authoritative name server for .com TLD (Top Level Domain).
The .com TLD's authoritative name server in turn, guides the resolver to Google’s authoritative name server.
Google’s authoritative name server finally provides the IP address for 'www.google.com' to the resolver.
The resolver then caches this information on your local system for future use. This way, it no longer has to go through this lengthy resolution process when next you want to visit 'www.google.com'. This also gravely increases speed.

TCP/IP connection.

After the DNS resolution process, the next crucial step in the journey of a web request is to establish a TCP/IP (Transmission Control Protocol/Internet Protocol) connection. This step ensures that there is a reliable and organized exchange of data between your device and the web server. TCP/IP is the foundational protocol suite of the internet. It consists of two primary protocols;

Internet Protocol (IP) - handles the routing and addressing of data packets, ensuring they reach their intended destination.
Transmission Control Protocol (TCP) - manages the orderly and reliable transfer of data.

What are Data Packets?

In the digital world, data is divided into small units of information called packets, which can be transmitted over the internet. You can picture a packet as letters in the postal service, each one having addresses and content of the letter within the envelope, packets also contain data (the data to be transferred) and metadata (information such as source and destination IP address, port numbers and sequence numbers).

The process of initiating a connection between your device (client) and the web server (server) involves a three-way handshake;

SYN (Synchronize) - the client sends a SYN packet to the server to request a connection.
SYN-ACK (Synchronize Acknowledgement) - the server acknowledges the request by sending a SYN-ACK packet.
ACK (Acknowledgement) - the client then sends back an ACK packet, confirming the connection.

NOTE: The above process is to ensure that both parties (i.e client and server) are ready to communicate.

Firewall.

After the TCP/IP connection, the next crucial layer of defense in the journey of your web request is the Firewall. A firewall acts as a digital gate keeper, monitoring and controlling the flow of data packets to protect your device and network from potential threats. It examines data packets to determine whether they should be allowed or blocked based on predefined rules. These rules can include criteria such as source and destination IP addresses, port numbers, and the protocol being used (i.e TCP or UDP).

Firewalls are also configured with security policies which helps determine the level of access and permissions for different types of traffic. Common policies include allowing HTTP (port 80) and HTTPS (port 443) for web browsing, while blocking potentially harmful traffic.

HTTPS/SSL.

Now, following the firewall’s role in securing your internet connection, another important layer of security is HTTPS (Hypertext Transfer Protocol Secure) and SSL (Secure Sockets Layer). These two technologies work alongside one another to protect the privacy and integrity of data exchanged between the client and the server. HTTPS is a secure version of HTTP which is used to transfer data between the client and the server.

Why do we need HTTPS/SSL?

The internet is a very wide and interconnected network where data travels across numerous routes. Some of these routes may not be entirely secure, making it very important to encrypt data so as to protect it from tampering or interception. HTTPS and SSL provides the encryption needed to transfer data over the network.

NOTE: SSL provides the encryption and secure connection used in HTTPS.

To establish trust and verify the identity of a web server, HTTPS uses digital certificates (SSL certificates). These digital certificates are issued by trusted Certificate Authorities (CAs). Examples of CAs include Comodo, GeoTrust, and Symantec. So, when you visit an HTTPS-enabled website, your browser checks the digital certificate to ensure it is valid and signed by a trusted CA.

Load-balancer.

Once a secure connection has been established between the client and the server through HTTPS/SSL, the next step in the journey of your web request is often managed by load-balancers. Although this part is not always in play because load-balancers are meant to improve performance, and enhance the reliability of web services, which might not be needed for a website with very little traffic. But for a big company like Google, it’s a very important aspect because as websites and web applications grow in popularity, they often experience a significant increase in traffic and this can strain a single web server's capacity and lead to performance issues or even downtime.

Load balancers address these challenges by efficiently distributing incoming requests among multiple servers, preventing overloads, and improving responsiveness. Now, the client request is sent to the load balancer, which in turn directs this request to one of Google’s web servers for further processing of the request.

Web server.

A web server is specialized software or hardware that listens for incoming HTTP or HTTPS requests from clients, such as web browsers. Web servers are a very essential component of the web infrastructure. They are responsible for receiving and responding to client requests, serving web pages, and processing dynamic content, etc.

When a client's request arrives at the web server, the server identifies the requested resource, whether it's an HTML page, an image, a script, or any other web content.
The web server retrieves the resource from its storage (if it's a static content) or generates it dynamically by executing scripts or querying databases (if it's a dynamic content). Then based on the request made, it sends whatever content requested back to the client (as a response) for display in the browser. All these sending of data back and forth (from client to server and back) occurs through either HTTP or HTTPS (since web servers can handle both unencrypted HTTP requests and secure, encrypted HTTPS requests).

There are various types of web server solutions, these two are the most popular.

Apache HTTP Server: An open-source and widely used web server.
Nginx: Known for its performance and scalability, often used as a reverse proxy server in combination with Apache.

Application server.

Application servers are specialized software or frameworks that handle dynamic, data-driven web applications, providing the logic and functionality required to serve complex web services.

Roles of an application server.

Application servers execute the business logic of web applications. This includes handling user authentication, managing sessions, processing form submissions, and enforcing security policies.
They interact with web servers to process client requests, generate dynamic content, and communicate with databases and other resources.
Application servers play a crucial role in the development and delivery of dynamic web applications. These applications generate content on-the-fly, responding to user interactions, database queries, and various forms of input.
They also expose API endpoints that allow external services, web applications, or mobile apps to interact with the system. These APIs are crucial for data exchange and integration.

So, basically, after the web server's role in delivering static and some dynamic content, the application server's role is to generate dynamic responses, process complex business logic, and deliver interactive and data-driven web applications.

Databases.

Databases are key foundational components of modern web applications, responsible for the secure storage, retrieval, and management of data. After the application server's role in presenting dynamic web applications, the journey of your web request takes an important step by interacting with a database. Databases are used to persistently store data, such as user profiles, content, transaction records, etc.

Most common types of databases.

Relational databases (also known as SQL databases) - they use tables to organize data into rows and columns. They are excellent for structured data and transactions.
Non-relational databases (also known as NoSQL databases) - are designed for unstructured or semi-structured data. They are often used for flexible data storage.

Basically, after the application server processes dynamic content, databases store and manage the data required to drive web applications, making them essential for applications ranging from e-commerce websites to social media platforms and beyond.

Conclusion.

The seemingly simple act of typing a URL and pressing Enter involves a beautiful and remarkable journey through various stages of internet technology. From DNS translation to security protocols, load balancing, and server-side processing, each step contributes to the seamless experience of accessing the web.

Now that you understand this process, I hope you can now appreciate the complexity that goes into serving the web pages we use daily 🤗.

Thanks for reading, cheers ✨🎉.

ChatGPT API is not free, here's an alternative.

Hameed Osilaja — Mon, 04 Sep 2023 17:37:35 +0000

If you have a natural curiosity, much like myself, you've probably always been eager to experiment with ChatGPT, I mean, to explore its capabilities by creating something with it.

To get the API Key, developers need to log in to OpenAI’s website and select ‘View API Keys’. Although the API Key is not free, OpenAI provides a free credit of about $18 upon account creation. After the free credit expires, the cost is $0.002 per 1000 tokens. If the API Key is not working, it might be due to technical issues or the exhaustion of free tokens.

As a developer interested in utilizing the ChatGPT API, you need to obtain an API key which is available on OpenAI’s website, but unfortunately, it comes at a price. In this article, we’ll be discussing a very simple alternative I use instead of investing in OpenAI's API.

The OpenAI’s API was made available to developers on 1st of March 2023. At this time, they released a one month free trial to all API key holders where each user gets an $18.00 credit on their account which will be valid until 1st of April 2023. If you were able to benefit from the free trial, well congratulations to you, but I’m sure after the expiration date, your API key no longer works, and now you’re being asked to pay.

Interestingly, you can generate an API key for free. However, when you attempt to use it, you'll encounter a rate limit reached error, prompting you to purchase credits (a very clever selling strategy by OpenAI, lol 😁).

What’s the way around this?

While searching for a cost-effective alternative to OpenAI's API, I came across numerous open-source ChatGPT alternatives. However, one particular option that caught my attention is GPT4Free.

What is GPT4Free?

GPT4Free is a project developed by xtekky on GitHub, that has integrated the structure of ChatGPT to create a revolutionary, user-friendly platform. I won’t take too much time giving details about the project, you can check it out the GitHub repository here.

How to use GPT4free.

Now, let's delve into the coding part of this article. We'll write a basic Python script to illustrate how you can integrate GPT4Free into your upcoming project.

There are two ways to this;

You can clone the GitHub repository, set up a virtual environment, and create your Python script.
Or you can simply install the official GPT4Free Python package.

However, for the purposes of this tutorial, we will utilize the second option, so, lets go!

First and foremost, let's create a virtual environment. I can't emphasize enough how crucial it is to establish a virtual environment for your Python projects. It aids in isolating your project's dependencies from your system's global dependencies.

# On macOS and Linux
$ python3 -m venv env

# On windows
$ python -m venv env

Now that we have our virtual environment setup, lets activate it

# On macOS and Linux
$ source venv/bin/activate

# On windows
$ .\venv\Scripts\activate

Now, it’s time to install the gpt4free package g4f

$ pip install g4f

Once the package is done installing, create a new file, I'll name mine gpt4free.py

import g4f

messages = []

while True:
    userInput = input("\nUser: ")
    messages.append({"role": "user", "content": userInput})

    response = g4f.ChatCompletion.create(
        model=g4f.models.gpt_4,
        provider=g4f.Provider.DeepAi,
        messages=messages,
    )

    print(f"\n{response}")

Now, let's break the code down.

Firstly, we imported the g4f package that we installed earlier. Then, we created a messages list to hold the message, which will serve as a parameter for the create function from g4f.

Next, we established a while loop. Although this step isn't strictly necessary, it only allows us to continue a chat with the chosen model.

We then request user input, which will serve as the prompt for the model. This input is added to the messages list.

Afterward, we invoke g4f.ChatCompletion.create with three parameters:

model: this parameter specifies the model to be used for the chat. g4f supports various models, and in this example, we selected the gpt_4 model. You can find other supported models on the official GitHub page.
provider: here, we specify the provider to be used for this chat. Multiple providers are available, including OpenaiChat, Bard, Bing, and others. In this case, we've chosen DeepAi.
Note: Not all providers may be operational, you can refer to the GitHub page for additional information.)
messages: this parameter takes our messages list.

Finally, we print the response received.

Let’s run our code.

# On macOS and Linux
$ python3 gpt4free.py

# On windows
$ python gpt4free.py

The result;

(env) C:\Users\hameed\ai_test>python gpt4free.py

User: give me 5 tips to become a better developer

1. Continuous Learning: Technology is constantly evolving and as a developer, you should always be striving to learn new things. Take advantage of resources like online courses, tutorials, and other learning
materials to keep yourself up-to-date with the latest trends and best practices.

2. Write Clean and Efficient Code: Writing clean and efficient code is essential for becoming a good developer. This ensures that your code is easy to read, understand, modify, and maintain. Keep in mind the
SOLID principles and try to implement them in your code.

3. Collaborate with other Developers: Working with other developers on projects or open source repositories can provide valuable feedback, guidance, and help you learn from their experience. Consider joining
local developer groups or attending meetups to collaborate and learn from others in the industry.    

4. Adopt Best Practices: Adopting best practices for software development can improve the quality of your code and development process. Learn about software development methodologies, testing frameworks, and
version control to help ensure your code meets quality standards.

5. Experiment with New Technologies: Experimenting with new technologies and frameworks allows you to expand your knowledge and skill set as a developer. This helps you stay ahead of the curve and stay relevant in the ever-changing industry. Keep experimenting with new technologies and implementing interesting
concepts.


User: give me 3 more extra tips


Sure, here are three extra tips to become a better developer:

1. Practice regularly: Just like any skill, programming requires consistent practice to develop. Regular coding exercises and personal projects help you to learn new concepts and apply what you've learned in
practical settings.

2. Learn from others: Joining online communities, attending meetups and conferences, and collaborating with fellow developers will expose you to new ideas and perspectives. Learn from experienced developers and seek their feedback on your code.

3. Keep up with evolving technology: Technology is constantly evolving, and being able to stay up-to-date with new trends and tools is vital in the tech industry. Participate in online forums and subscribe to tech blogs and newsletters to stay informed about the latest developments in your field.

User: Traceback (most recent call last):
  File "C:\Users\USER\Desktop\CRAP\ai_test\test_g4f.py", line 7, in <module>
    userInput = input("\nUser: ")
KeyboardInterrupt
^C
(env) C:\Users\hameed\ai_test>

Wow, amazing isn't it?

We first got a prompt asking us to enter an input (exactly what we asked the python script to do earlier), which I asked it to "give me 5 tips to become a better developer", then on clicking enter, our input was submitted to the g4f chat completion model, then voila!!!, we got our response printed out. I even went ahead to ask it to give me three more, and it did. Then finally exit the while loop using CTRL + c.

Conclusion.

Now that you have the power of using AI in any of your projects, feel free to explore more possibilities with the g4f package. Keep building amazing projects.

Happy coding ✨.

Debugging Memory Leaks in C Using Valgrind.

Hameed Osilaja — Wed, 31 May 2023 11:01:41 +0000

Introduction

Memory leaks can be one of the most frustrating and elusive bugs to track down in C programming. These leaks occur when allocated memory is not properly deallocated (or freed), leading to a loss of available memory over time. Fortunately, tools like valgrind exist to help developers detect and debug memory leaks efficiently.

Memory leaks are a common problem in C programs. They can cause a variety of problems, including:

Program crashes
Slow performance
Memory exhaustion

In this article, we will explore how Valgrind can be used to identify and fix memory leaks in C programs.

What is Valgrind?

Valgrind is an open-source dynamic analysis tool suite that is widely used for debugging and profiling. It provides a range of tools to detect memory leaks, invalid memory accesses, and other memory-related errors in C and C++ programs. It does this by running your program in a virtual environment, allowing it to monitor memory allocations and de-allocations, detect errors, and provide detailed reports on memory usage.

How To Set-up Valgrind:

Before diving in, you'll need to install valgrind on your system. Valgrind is available for most Linux distributions and can be installed using the package manager. For example, on Ubuntu, you can install Valgrind by running the following command:

sudo apt-get install valgrind

Once Valgrind is installed, you can run your C program with it by using the following command:

valgrind --leak-check=full ./your_program

Valgrind will then run your program and report any memory leaks that it finds. The output will be displayed in the terminal.

Example.

Let's consider the following C program that contains a simple memory leak:

#include <stdlib.h>

int main() {
    int *ptr = malloc(sizeof(int));
    return 0;
}

In the above program, we created a main function that allocates a memory of 4 bytes (size of an integer) using malloc. Now let's compile this program:

gcc main.c -o test-valgrind

NOTE: we explicitly set our output file to be test-valgrind, you can name your output file whatever you like.

Now, let's run our program using valgrind.

valgrind --leak-check=full ./test-valgrind

After running the program, here's the output that Valgrind produces:

==2896== Memcheck, a memory error detector
==2896== Copyright (C) 2002-2017, and GNU GPL'd, by Julian Seward et al.
==2896== Using Valgrind-3.13.0 and LibVEX; rerun with -h for copyright info
==2896== Command: ./my_program
==2896==
==2896== HEAP SUMMARY:
==2896==    in use at exit: 4 bytes in 1 blocks
==2896==   total heap usage: 1 allocs, 0 frees, 4 bytes allocated
==2896==
==2896== 4 bytes in 1 blocks are definitely lost in loss record 1 of 1
==2896==   at 0x4C29BE3: malloc (vg_replace_malloc.c:299)
==2896==   by 0x40053E: main (in main.c:4)
==2896==
==2896== LEAK SUMMARY:
==2896==    definitely lost: 4 bytes in 1 blocks
==2896==    indirectly lost: 0 bytes in 0 blocks
==2896==    possibly lost: 0 bytes in 0 blocks
==2896==    still reachable: 4 bytes in 1 blocks
==2896==        suppressed: 0 bytes in 0 blocks
==2896== Rerun with --leak-check=full to see details of leaked memory
==2896==
==2896== For counts of detected and suppressed errors, rerun with: -v
==2896== ERROR SUMMARY: 1 errors from 1 contexts (suppressed: 0 from 0)

To fix memory leaks identified by Valgrind, carefully review the reported errors and follow these steps:

Identify the specific lines of code where memory is allocated but not freed.
Determine the appropriate location to free the allocated memory.
Add the necessary free() function calls to release the allocated memory.

From the above output, we can see that we have lost 4 bytes of memory (equivalent to the size of an integer), Valgrind even went further, telling us where the memory leak is coming from:

==2896== 4 bytes in 1 blocks are definitely lost in loss record 1 of 1
==2896==   at 0x4C29BE3: malloc (vg_replace_malloc.c:299)
==2896==   by 0x40053E: main (in main.c:4)

it says the memory was allocated by malloc in our main.c file. Now that we've identified the source of the memory leak, it time to go ahead and fix it. We can fix the memory leak by adding free(ptr) before the return statement:

#include <stdlib.h>

int main() {
    int *ptr = malloc(sizeof(int));
    free(ptr);
    return 0;
}

By analyzing the Valgrind report and applying the necessary fixes, you can eliminate memory leaks in your C programs and ensure optimal memory management.

More useful Valgrind arguments.

--leak-check=full: option to get more detailed information about the leaks that Valgrind finds.
--show-leak-kinds=all: Show all leak kinds including definite, indirect, possible, and reachable in the full report.
--track-origins=yes: option to track the origin of the memory that is being leaked. This can help you to find the code that is causing the leak.
--verbose: option to show unusual behavior of your program.
--log-file: option to write to a file (useful when output exceeds terminal space)

Conclusion

Valgrind is a powerful tool that can be used to debug memory leaks in C programs. It is easy to use and can help you to find and fix memory leaks quickly and easily. By following the tips in this article, you can use Valgrind to improve the quality of your C programs.

Sending Automated Emails With Gmail Using Python.

Hameed Osilaja — Sun, 21 May 2023 13:45:02 +0000

INTRODUCTION.

In today's digital age, automated emails have become an essential part of many business and personal communication workflows. Whether it's sending notifications, updates, or personalized messages, automating the email-sending process can save a whole lot of time and effort. In this article, we will explore how to send automated emails with Gmail using Python.

REQUIREMENTS.

A Gmail account.
Python Installation.

Python provides powerful libraries and modules that make it relatively easy to automate email sending. We will be using the smtplib and email module. smtplib is a built-in library in Python, along with the Gmail SMTP server to send emails. Python's email module is a powerful library that provides functionalities to create, manipulate, and send email messages. It allows you to construct email messages with various components such as headers, subject, body, attachments and more.

CONTENT.

Setting Up Gmail.

Before we dive into the coding part, there are a few prerequisites and setup steps you need to follow to enable automated email sending through Gmail.

Enable 2-Step Verification (just a security measure).
Generate an App Password.

Enable 2-Step Verification.

To ensure your Google account is safe, you need to enable 2-Step Verification. Go to your Google Account settings, navigate to the Security section, enable the "2-Step Verification" option.

Generate an App Password.

This part is the most important. To enhance security, Google requires an app-specific password for programs like Python to access your Gmail account. To generate an app password;

Go to your Google Account settings and navigate to the Security section, select “2-Step Verification” and scroll to the bottom, then select “App Passwords”.

Select “Other (custom name)” and give it any name of your choice, then click “Generate”.

Yay!!!, you’ve successfully generated your app password. Be sure to copy the generated password and save it somewhere safe because once you close the interface, you won’t be able to see the password anymore.

Now that we have the necessary setup in place, let's proceed to the coding part.

Writing the Python Code.

To send automated emails using Python, you need to import the smtplib and email module, and configure it with your Gmail account credentials and the SMTP server settings.

from email.message import EmailMessage
import ssl, smtplib

def automated_email():

    email_sender = 'youremail@gmail.com'
    email_password = 'your-generated-password-here'
    email_reciever = 'reciever-email-here'

    subject = 'Your Email Subject'
    body = """
        This will contain the contents of your email.   
        This will contain the contents of your email.   
        This will contain the contents of your email.   
    """

    # Create an instance of EmailMessage
    em = EmailMessage()
    em['From'] = email_sender
    em['To'] = email_reciever
    em['Subject'] = subject
    em.set_content(body)

    # Create a secure SSL context
    context = ssl.create_default_context()

    # Connect to the SMTP server and send the email
    with smtplib.SMTP_SSL('smtp.gmail.com', 465, context=context) as smtp:
        # Login to the email sender's account
        smtp.login(email_sender, email_password)
        # Send the email
        smtp.sendmail(email_sender, email_reciever, em.as_string())

The email sender's address, password, and the recipient's email address are set in the email_sender, email_password, and email_reciever variables, respectively.

Note: Make sure to replace the placeholder values with your valid Gmail account information, including the email sender's address, password, and recipient's email address. Keep your email credentials secure and consider using environment variables to store sensitive information.

If you would like to format the email content with HTML tags, this is an updated version.

from email.message import EmailMessage
from email.mime.multipart import MIMEMultipart
from email.mime.text import MIMEText
import ssl, smtplib

def send_mail():

    email_sender = 'youremail@gmail.com'
    email_password = 'your-generated-password-here'
    email_reciever = 'reciever-email-here'

    subject = 'Your Email Subject.'

        content = """
                <html>
                    <body>
                           <b>Hi</b></br>
                           <p>This email is html formatted.</p>
                    </body>
                </html>
                """

    # Create an instance of MIMEMultipart for composing the email
    em = MIMEMultipart()
    em['From'] = email_sender
    em['To'] = email_reciever
    em['Subject'] = subject

    # Attach the content as HTML to the email
    em.attach(MIMEText(content, "html"))

    # Create a secure SSL context
    context = ssl.create_default_context()

    # Connect to the SMTP server and send the email
    with smtplib.SMTP_SSL('smtp.gmail.com', 465, context=context) as smtp:
        # Login to the email sender's account
        smtp.login(email_sender, email_password)
        # Send the email
        smtp.sendmail(email_sender, email_reciever, em.as_string())

Here, an instance of MIMEMultipart is created to compose the email. The email's sender, recipient, and subject are set using the corresponding headers in the MIMEMultipart object. The content of the email, passed as the content argument, is attached to the email as HTML using MIMEText.

The above codes provide a basic example of sending automated emails with Gmail using Python. However, you can enhance and customize the functionality based on your requirements. Here are a few ideas:

Adding Attachments: You can use the email module in Python to create more complex email messages with attachments. This allows you to send files along with your automated emails.
Email Templates: Instead of composing the email content within the code, you can utilize email templates to separate the content from the code. Libraries like Jinja2 can help you create and render email templates with dynamic data.
Error Handling: Implement robust error handling to handle exceptions and provide informative messages in case of any issues during the email sending process.
Scheduled Emails: Use Python's datetime module and scheduling libraries like schedule or APScheduler to send automated emails at specific times or intervals.

Conclusion

Automating email sending using Python and Gmail can greatly streamline your communication processes. Whether it's sending notifications, updates, or personalized messages, the smtplib module in Python makes it easy to connect to the Gmail SMTP server and send automated emails. Remember to ensure the security of your Gmail account by enabling less secure app access and generating an app password. With the power of Python and Gmail, you can save time and effort while effectively reaching your recipients.

How to Deploy a FastAPI App on Deta Space

Hameed Osilaja — Sat, 01 Apr 2023 09:34:48 +0000

Introduction.

According to the documentation here,

“FastAPI is a modern, fast (high-performance), web framework for building APIs with Python 3.7+ based on standard Python type hints.”

FastAPI is an easy to learn Python framework which I love best for building my APIs. If you would like to learn more about it, you can visit the documentation. In this article, we’re concerned with how to deploy your FastAPI app on Deta Space so it can be available for use to anyone around the world.

A little about Deta. Deta is a company that offers various services including cloud, Deta Base (Instantly usable database with a feature-rich API.), python and Node.js deployment, all for free.

If you’re familiar with DETA, you would know that they used to be deta.sh (deprecated), but after more than 2 years, they decided to make an upgrade to DETA CLOUD (which is even way cooler) to give developers a free and easy way to get their ideas live on the internet.

I remember then, I used to deploy my fastAPI app on DETA MICRO (deprecated), but since it’s now deprecated, in this article, you’ll learn with how to deploy your FastAPI app on DETA SPACE so it can be available for use to anyone around the world.

But first things first, let’s create a simple FastAPI app for demonstration purposes.

REQUIREMENTS.

Python.
Deta Space account (remember, it’s totally free. You can create one here). NOTE: if you have a deta.sh account before, you can still use that to login to Deta Space.

CREATE A SIMPLE APP.

Let’s create a simple FastAPI app.

Create a directory.

Open a new terminal window and create a directory for your app, I’ll name mine fastapi-tutorial, then cd into it.

$ mkdir fastapi-tutorial
$ cd fastapi-tutorial

Create a virtual environment.

This step is optional, but it makes sense. The importance of creating a virtual environment is to isolate your project dependencies from your global dependencies on your PC. For windows;

$ python -m venv my-env
$ my-env\Scripts\activate

Or on a mac PC.

$ python3 -m venv my-env
$ Source my-env\bin\activate

Install FastApi.

Now, you’ll need to install fastapi and uvicorn. Uvicorn is an ASGI server, for production.

(my-env) $ pip install fastapi
(my-env) $ pip install "uvicorn[standard]"

Create a simple route.

Create a file main.py and add the following code;

from fastapi import FastAPI

app = FastAPI()


@app.get("/")
def read_root():
    return {"message": "Deploying FastApi to Deta Space"}

Create a requirements.txt file.

Create a requirements.txt file, this will contain all your dependencies so Deta will know which dependency to install for your app.

(my-env) $ pip freeze > requirements.txt

Open the file, it should look something like this;

fastapi==0.89.1
uvicorn==0.20.0

Run the app.

Now, run the app to be sure everything works fine.

(my-env) $ uvicorn main:app --reload

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

You can visit http://127.0.0.1:8000 to see your app.

Yay 🎉, you’ve successfully created your app. Now let’s deploy.

DEPLOYMENT STEPS.

Now that you’ve successfully created your app, let’s get to deployment.

Install Deta Space CLI.

To install the Space CLI on windows, open powershell and paste this command;

iwr https://get.deta.dev/space-cli.ps1 -useb | iex

And for a Mac PC;

curl -fsSL https://get.deta.dev/space-cli.sh | sh

Login to Deta Space.

Once you’ve successfully installed the CLI, the next thing is to login to Deta Space. Back to your project terminal window, paste the following command;

$ space login
? Enter access token >

The above command will ask for an “access token” to authenticate your CLI. Generate the token in the next step.

Generate an access token.

To generate an access token, login to your space dashboard (on the web), click on the search (command) bar, then click “Settings”

Then click “Generate token”

You’ll get a new token, copy it and save it somewhere safe, because you won't be able to view the token again. Paste the token in the CLI prompt, then click enter. You should see a success message.

👍 Login Successful!

Create a new Space project.

Type the following command to create a new Space project.

$ space new

You will be prompted to enter a name for your project. Next, the CLI will try to detect any existing applications in your directoriy. If found, the CLI will show a generated config for those applications.

Once you confirm the generated config, the CLI will create a new project in Builder and generate a Spacefile file in your local directory, which contains the configuration of your app, used by Deta Space to understand what your app looks like and how to run it. The whole process should look something like this;

Push your app to space.

To do this run this command;

$ space push

This command will validate your Spacefile, then upload all the necessary files to Deta’s build pipeline.

If for some reason you,re getting an error ! Failed to push code and create a revision. Please try again!, open your Spacefile (usually at the root directory of your project), it should look like this;

# Spacefile Docs: https://go.deta.dev/docs/spacefile/v0
v: 0
micros:
  - name: FastAPI
    src: .
    engine: python3.9
    primary: true

Make sure the src is pointing to the directory where you have your main.py and requirements.txt files, then run the command again. You should get a success message

✓ Successfully started your build!
✓ Successfully pushed your Spacefile!

Congratulations 🤩, you’ve successfully deployed your project. To see your new project live, go to your space dashboard, you’ll find the new app you created there, click on the app, and it’ll take you to the live app, where you can copy the link and share to others.

Happy coding 😁!