DEV Community: James Kinga

Python3: Try-Else Statement

James Kinga — Thu, 13 Apr 2023 18:55:39 +0000

Introduction
What is Try-Else Statement?
Benefits of try-else
Conclusion

Introduction

Errors are common in programming, regardless of the level of experience and competence. These errors are often referred to as exceptions and occur due to many reasons such as unexpected user inputs, network failures, system crashes, etc. In Python, exceptions are handled using the try-except statement. However, there is another useful variation of the try statement called the try-else statement, which we will be discussing in this article.

What is Try-Else Statement?

The try-else statement in Python is used to execute a block of code if no exception is thrown in the try block. It is an optional clause that can be added to the end of a try-except statement. The syntax of the try-else statement is as follows:

try:
    # a block of code that may cause an exception
except ExceptionType:
    # a block of code to handle the exception
else:
    # a block of code that executes if theres no exception raised

In the try block, we write the code that may raise an exception. If an exception is raised, the code in the except block is executed to handle the exception. However, if there is no exception raised in the try block, the code in the else block is executed.

Let's consider an example to understand the try-else statement better. Assume we want to take input from the user and calculate its square. We can write the code using the try-else statement as follows:

try:
    x = int(input("Enter a digit: "))
except ValueError:
    print("Invalid input. Please enter another digit.")
else:
    print("The square of the digit is: ", x*x)

In this code, we use the input() function to take input from the user. However, since the input can be any string, we use the int() function to convert the input into an integer. If the user enters a non-numeric value, a ValueError exception is raised, and the code in the except block is executed, which prints an error message. If the input is a valid integer, the code in the else block is executed, which calculates and prints the square of the number.

Benefits of try-else

Now, let's take a look at some benefits of using the try-else statement in Python.

Improved code readability
Better error handling
Improved code readability

1. Improved code readability

The try-else statement can help make your code more readable and easier to understand. By separating the code that may raise an exception from the code that executes when there is no exception, you can make it clear what your code is doing and how it handles errors.



     try:
        f = open('file.txt', 'r')
        contents = f.read()
        print(contects)
     except IOError:
        print("File not found or could not be read.")

This code opens a file, reads its contents, and prints them. However, if the file does not exist or could not be read, the code in the except block is executed, which prints an error message.

Now, let's rewrite the code using the try-else statement:


     try:
        f = open('file.txt', 'r')
     except IOError:
        print("File not found or could not be read.")
     else:
        contents = f.read()
        print(contects)

In this code, we use the try-else statement to separate the code that may raise an exception from the code that executes when there is no exception. The code in the try block attempts to open the file, and if there is an IOError, the code in the except block is executed. If the file is successfully opened, the code in the else block is executed, which reads the file's contents and prints them. This code is more readable and easier to understand than the previous code.

2. Better error handling

The try-else statement can also help you handle errors more effectively. By separating the code that may raise an exception from the code that executes when there is no exception, you can handle errors more precisely and avoid catching and handling exceptions that are not relevant to the current code.

For example, consider the code below:



     try:
        result = calculate_result()
     except Exception:
        print("An error occurred. Please try again later.")

In this code, we are catching all exceptions that may occur while calling the calculate_result() function. This may include exceptions that are not related to the function's logic, such as network errors or system crashes. By catching all exceptions, we are not handling errors precisely and may hide important error messages.

Now, let's rewrite the code using the try-else statement:


    try:
       result = calculate_result()
    except ValueError:
       print("Invalid input. Please enter a valid number.")
    except ZeroDivisionError:
       print("Cannot divide by zero.")
    else:
       print("The result is:", result)

In this code, we use the try-else statement to handle specific exceptions that may occur while calling the calculate_result() function. If the function raises a ValueError, we print an error message indicating that the input was invalid. If the function raises a ZeroDivisionError, we print an error message indicating that the input was zero, and division by zero is not allowed. If there is no exception raised, we print the result. This code handles errors more precisely and provides better feedback to the user.

3. Cleaner code

The try-else statement can help you write cleaner code by eliminating unnecessary code blocks and reducing the nesting level of your code. By separating the code that may raise an exception from the code that executes when there is no exception, you can write cleaner and more concise code.

For example, consider the following code:



    try:
       x = int(input("Enter a number: "))
    except ValueError:
       print("Invalid input. Please enter a valid number.")
    else:
       try:
          result = 100/x
       except ZeroDivisionError:
          print("Cannot divide by zero.")
       else:
          print("The result is:", result)

In this code, we use two nested try-except statements to handle different types of exceptions. The outer try-except statement handles the ValueError exception that may occur while converting the input to an integer. The inner try-except statement handles the ZeroDivisionError exception that may occur while dividing 100 by the input. This code is more complex and harder to read than the previous code.

Now, let's rewrite the code using the try-else statement:


    try:
       x = int(input("Enter a number: "))
    except ValueError:
       print("Invalid input. Please enter a valid number.")
    else:
       if x == 0:
          print("Cannot divide by zero.")
       else:
          result = 100/x
          print("The result is:", result)

In this code, we use the try-else statement to handle the input conversion and the division in a single block of code. If the input is zero, we print an error message. If the input is valid, we calculate the result and print it. This code is cleaner and easier to read than the previous code.

Conclusion

In conclusion, the try-else statement in Python is a useful variation of the try-except statement that can help you write cleaner, more readable, and more effective code. By separating the code that may raise an exception from the code that executes when there is no exception, you can handle errors more precisely, provide better feedback to the user, and write cleaner and more concise.

Simple Twitter Bot to Retweet & Favorite Using Python & Tweepy

James Kinga — Mon, 14 Feb 2022 12:07:24 +0000

Intro

I came across the #TwitterBotChallengeKE while scrolling through Twitter's great tech communities. As a genuinely curious individual, I decided to give it a try. After a few google searches, I discovered quite a few resources and at least got a clue on where to start. This is a great way to test and flex your coding skills, while interacting with APIs and learning how they work. It's also fascinating to see what you build in action, especially if you're not very active on Twitter. There's a rich pool of resources from around the web and a supportive Twitter Community making it beginner friendly for all codenewbies.

Twitter Bot Challenge (#BuildWhat'sNext)

The Twitter Bot Challenge aims to support the tech ecosystem in Kenya to build using the Twitter API. We will be using the API to build for fun by creating bots. This is a summary of my experience participating, the good, the bad and the ugly, and most of all what you learned.

The goal is to create a twitter bot which tweets Dev, Linux, and other Coding content. Primarily, I decided to develop the bot using Python as it has several handy libraries and tools. As always, it is safer to code new python projects within virtual environments.

Requirements

Twitter developer account
Python3.8
Python virtual environment
Hosting Server or Cloud

Twitter Developer Account

Create a Twitter developer account. I decided to play it safe and create a separate account from my main Twitter account (@Kingah254). I’ve had a few accounts suspended in the past, I had to be cautious. This is a fairly easy processes and approval takes a few minutes.

Search for Twitter Developer Account on any search engine of your choice and choose the first option (should be). This will redirect you to a Developer Portal. Create a new application under the Projects & Apps section.

Request for a Twitter Developer Account and provide a few answers:

Create an application:

Request for privileged permissions under the User Authentication Settings. I decided to use OAuth 1.0a:

Select the Read and write and Direct message App permissions:

Generate API Key, API Key Secret, Access Token and Access Token Secret:

Python Virtual Environment

For this project, we will use Python3.8, and primarily the Tweepy Python package to develop a simple Twitter bot that retweets, and favorites tweets with certain keywords.

Create a virtual environment to install all the necessary modules using pip, separate and without interfering with the system(global) packages. This can be done by running the command:

python3 -m venv yourvirtualenv

Activate the virtual environment to install the libraries:

source yourvirtualenv/bin/activate

Install the following packages/libraries:

tweepy - this is the primary python package the bot uses to communicate or interface with the Twitter API. It has a rich module and function libraries in addition to a supportive community. This makes it the most popular package for automating Twitter.

Install using:

pip install tweepy

configparser - used to hide important credentials such as api key, api key secret, access token and access token secret. Therefore, it is safer when sharing the code with others as one does not have to share these credentials.

Install using:

pip install configparser

time - a Python module that is used to represent time in different ways including objects, numbers and strings as well as offering various functionality such as waiting during code execution.

Let's Code

Create a configuration file, config.ini to store the authentication credentials i.e. the API keys and access tokens.

In config.ini

[jk_bot]
api_key=<Your API Key here>
api_key_secret=<Your API Key Secret Here>

access_token=<Your Access Token Here>
access_token_secret=<Your Access Token Secret here>

We’ll start by importing the dependencies:

import tweepy
import configparser
from time import sleep

#ConfigParser is used to grab the authentication credentials from a config 
#file making it safer when sharing the code.
config = configparser.ConfigParser()
config.read('config.ini')

apiKey = config['jk_bot']['apiKey']
apiKeySecret = config['jk_bot']['apiKeySecret']

accessToken = config['jk_bot']['accessToken']
accessTokenSecret = config['jk_bot']['accessTokenSecret']

Next, we will instantiate the authentiacation handler using the API key and API key secret and then use the access token and access token secret to complete the authentication process on the API authentication handler. Afterwards, we instantiate a new tweepy API object using the authentication handler object.

import tweepy
import configparser
from time import sleep

#ConfigParser is used to grab the authentication credentials from a config 
#file making it safer when sharing the code.
config = configparser.ConfigParser()
config.read('config.ini')

apiKey = config['jk_bot']['apiKey']
apiKeySecret = config['jk_bot']['apiKeySecret']

accessToken = config['jk_bot']['accessToken']
accessTokenSecret = config['jk_bot']['accessTokenSecret']

# authenticate API keys 
auth = tweepy.OAuthHandler(apiKey, apiKeySecret)
auth.set_access_token(accessToken, accessTokenSecret)
print('Authentication successful!')

api = tweepy.API(auth)

The above code should return an Authentication Successful! message

Next, assign favorite and follow and create a list of the keywords to react by to tweets. After which we create a function using tweepy cursor and search to get the tweets and the usernames. The main function also defines the logic of actions for the bot. If the bot has not retweeted a certain tweet, favorite and retweet it using the favorite() and retweet() methods available to the tweet object.

import tweepy
import configparser
from time import sleep

#ConfigParser is used to grab the authentication credentials from a config 
#file making it safer when sharing the code.
config = configparser.ConfigParser()
config.read('config.ini')

apiKey = config['jk_bot']['apiKey']
apiKeySecret = config['jk_bot']['apiKeySecret']

accessToken = config['jk_bot']['accessToken']
accessTokenSecret = config['jk_bot']['accessTokenSecret']

# authenticate API keys 
auth = tweepy.OAuthHandler(apiKey, apiKeySecret)
auth.set_access_token(accessToken, accessTokenSecret)
print('Authentication successful!')

api = tweepy.API(auth)

# assign to favorite and follow
Favorite = True
Follow = True

hashtags = ['#python']

# the function with the logic on the bot actions
def main():
    for tweet in tweepy.Cursor(
        api.search_tweets, q=hashtags).items():
        try:
            print("\nTweet by: @" + tweet.user.screen_name)

            # check if we have retweeted and retweet if not
            if not tweet.retweeted:
                try:
                    tweet.retweet()
                    print("Tweet retweeted!")
                except Exception as e:
                    print(e)

            # check if we have favorited and favorite if not
            if not tweet.favorited:
                try:
                    tweet.favorite()
                    print("Tweet favorited!")
                except Exception as e:
                    print(e)

            # bot sleep time (seconds)
            sleep(60)

        except tweepy.TweepyError as e:
            print(e.reason)


        except StopIteration:
            break


while True:
    main()
    sleep(20)

Once completed, we can run the bot. Here is a screen capture of the bot in action:

Conclusion

This is a simple Twitter bot and there is a lot one can do using Tweepy. It is possible to add more logic using several other methods to implement more functionalities.
Next goal is to host the bot on the cloud to ensure it runs throughout. Follow for a follow-up article.

Important Network and Troubleshooting Tools for Linux

James Kinga — Wed, 29 Dec 2021 09:05:16 +0000

1. Overview

At times, navigating Linux operating system can be daunting for new users and so is the troubleshooting process. Unlike in Windows where one simply navigates to the control panel to troubleshoot network issues, Linux is often not so direct and obvious.

Therefore, this article seeks to simplify this process by discussing some of the basic Linux commands to view the network status and troubleshoot any related issues.

2. Tools and Commands

2.1. ifconfig

ifconfig displays the status of the currently active interfaces if not argument is given.
Useful options:

-a to view all interfaces which are currently available, even if down
-s display a short list (like netstat -i)

Example of ifconfig output:

eth0      Link encap:Ethernet  HWaddr 02:42:ac:11:00:0a  
          inet addr:172.17.0.10  Bcast:172.17.255.255  Mask:255.255.0.0
          UP BROADCAST RUNNING MULTICAST  MTU:1500  Metric:1
          RX packets:2235 errors:0 dropped:0 overruns:0 frame:0
          TX packets:667 errors:0 dropped:0 overruns:0 carrier:0
          collisions:0 txqueuelen:0 
          RX bytes:508519 (508.5 KB)  TX bytes:92572 (92.5 KB)

lo        Link encap:Local Loopback  
          inet addr:127.0.0.1  Mask:255.0.0.0
          UP LOOPBACK RUNNING  MTU:65536  Metric:1
          RX packets:0 errors:0 dropped:0 overruns:0 frame:0
          TX packets:0 errors:0 dropped:0 overruns:0 carrier:0
          collisions:0 txqueuelen:1000 
          RX bytes:0 (0.0 B)  TX bytes:0 (0.0 B)

eth0 - the Ethernet interface. Can be eth1, eth2,..., ethn
lo - the loopback interface which is used by the system to communicate with itself.

2.2. ping

Basically used to test connectivity. Common and handy flags:

-c, -count count
Stop after sending (and receiving) count ECHO_RESPONSE packets.
-q, -quiet

Quiet output. Nothing is displayed except the summary lines at startup time and when finished.
-i, -interval wait

Wait wait seconds between sending each packet. The default is to wait for one second between each packet. This option is incompatible with the -f option.

2.3. whois

whois searches for an object in a RFC 3912 (WHOIS) database.
WHOIS is a query and response protocol that is commonly used for accessing databases that contain the registered users of an Internet resource, such as a [domain name] or a [IP] [address] block, but it can also be used for a wider range of information.

The majority of recent implementations of whois attempt to guess the correct server to query for the requested object. Whois will connect to whois.networksolutions.com for NIC handles or whois.arin.net for [IPv4] addresses and network names if no guess can be made.
Often not installed by default on most systems but can be installed using apt - sudo apt install whois

2.4. nslookup

nslookup is used to determine the Internet name servers interactively. It stands for Name Server Lookup.
nslookup has two modes:

Interactive: useful in querying name servers for information about various hosts and domains or to print a list of hosts in a domain.
Non-interactive: useful to print just the name and requested information for a host or domain.

Usage:

nslookup [-option] [name | -] [server]

Where host [server] looks for information for a host using the default server or server, if one is given.

2.5. traceroute

traceroute prints the route packets trace to network host.
Traceroute records the path packets follow from an IP network to a certain host. It makes use of the IP protocol's time to live (TTL) parameter to try to get an ICMP TIME EXCEEDED response from each gateway on the route to the host.

2.6. netstat

netstat gets the network connections, routing tables, interface statistics, masquerade connections, and multicast memberships.
This tool prints information about the Linux subsytem. Useful arguments include:

--route, -r

Display the kernel routing tables. See the description in route(8) for details. netstat -r and route
-e produce the same output.

--groups, -g

Display multicast group membership information for IPv4 and IPv6.

--interfaces, -i

Display a table of all network interfaces.

--statistics, -s

Display summary statistics for each protocol.

2.7. dig

dig is a DNS lookup tool. This means it interrogates dig is a flexible tool for interrogating DNS name servers. It performs DNS lookups and displays the answers that are returned from the name server(s) that were queried.

Most DNS administrators use dig to troubleshoot DNS problems because of its flexibility, ease of use and clarity of output. Other lookup tools tend to have less functionality than dig.

Simple usage:

dig @server name type

Where:

server
is the name or IP address of the name server to query. When the supplied server argument is a hostname, dig resolves that name before querying that name server.
If no server argument is provided, dig consults /etc/resolv.conf; if an address is found there, it queries the name server at that address. If either of the -4 or -6 options are in use, then only addresses for the corresponding transport will be tried. If no usable addresses are found, dig will send the query to the local host. The reply from the name server that responds is displayed.

name
is the name of the resource record that is to be looked up.

type
indicates what type of query is required — ANY, A, MX, SIG, etc. type can be any valid query type. If no type argument is supplied, dig will perform a lookup for an A record.

3. Conclusion

This article looked at seven handy network tools for Linux: ifconfig, ping, whois, nslookup, traceroute, netstat and dig.

We also discussed the usage of each tool and its importance in troubleshooting various network issues.

Getting Started with Docker & Flask

James Kinga — Sun, 26 Sep 2021 09:53:51 +0000

This article offers a look at how to get started with docker and flask through a practical and hands-on (approach) python application. The goal is to provide a first look and understanding of some of the most quintessential tools for developers in the contemporary world.

Docker

Docker is an open platform for developing, shipping, and running applications. Docker enables you to separate your applications from your infrastructure so you can deliver software quickly. With Docker, you can manage your infrastructure in the same ways you manage your applications. By taking advantage of Docker’s methodologies for shipping, testing, and deploying code quickly, you can significantly reduce the delay between writing code and running it in production.

Docker Container

Essentially, a container refers to a unit that houses all the code and dependencies of an application in a standard format that allows it to runs quickly and reliably across computing environments. Therefore, a docker container lightweight, standalone, executable container that comprises all components necessary to run an application such as libraries,code, and runtime.

Docker installation

The recommended method of installation is through setting up Docker's repositories and installing from them; it's not only easy to install but also enables quick upgradability. Therefore, we shall install using the repository approach in Ubuntu 20.04 LTS.

Set up the repository

First, update apt and install necessary packages to us a repository over HTTPS:

$ sudo apt-get update

$ sudo apt-get install \
> apt-transport-https \
> ca-certificates \
> curl \
> gnupg \
> lsb-release

Add Docker’s official GPG key:

$ curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /usr/share/keyrings/docker-archive-keyring.gpg

Set up a stable repository and add the nightly or test (or both) repository:

$ echo \
  "deb [arch=amd64 signed-by=/usr/share/keyrings/docker-archive-keyring.gpg] https://download.docker.com/linux/ubuntu \
  $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

Install Docker Engine

Run an update apt and install the latest version of Docker Engine and containerd:

$ sudo apt-get update

$ sudo apt-get install docker-ce docker-ce-cli containerd.io

Confirm whether the Docker Engine is correctly installed using hello-world:

$ sudo docker run hello-world

You can visit the official Docker Docs page to view the installation procedures for other operating systems

Flask

This is a simple and lightweight Python web framework that offers useful tools for developing Python web applications.
Flask is super useful for building microservices, you can utilize any number of its built-in extensions to design and deploy microservices at high velocity.

Setting Up Our Environment

This project will require:

Python 3.6+ and PIP3
Virtual environment - Venv
Create project directory
Create venv
Install required packages using PIP e.g. Flask
Create a directory for the app and navigate into the directory:

$ mkdir demoapp

$ cd demoapp/

Create a virtual environment using venv:

$ python3 -m venv venv

$ ls
venv

Activate the virtual environment:

$ source venv/bin/activate

The prefix (venv) is an indication that the virtual environment is active.

Install Flask using pip3:

$ pip3 install flask

Demo Flask Application

Build the python application,

This is a simple python application that utilizes the GET and POST requests. It creates a form where a user (say a student), is prompted to enter their name and the field of interest. The user inputs are the formatted and displayed upon clicking the submit button.

Create app.py and code using an IDE of your choice. In this case, we use VS Code:

$ touch app.py

Here is the code for the application:

# import Flask and request
from flask import Flask, app, request

# develop the app
app = Flask(__name__)

# both GET and POST requests
@app.route("/form-example", methods=['GET', 'POST'])
def form_example():
    # the POST request
    if request.method == 'POST':
        username = request.form.get('username')
        interest = request.form.get('interest')
        return '''
            <h1>The student's name is: {}</h1>
            <h1>The field of interest is: {}</h1>'''.format(username, interest)

    # the GET request
    return '''
              <form method="POST">
                  <div><label>Username: <input type="text" name="username"></label></div>
                  <div><label>Interest: <input type="text" name="interest"></label></div>
                  <input type="submit" value="Submit">
              </form>'''

if __name__ == '__main__':
    # we'll run the app in debug mode on port 3000
    app.run(debug=True, port=3000, host="0.0.0.0")

Generate a requirements.txt file using freeze command

$ pip freeze > requirements.txt

Build the App's container image

In order to build the application, you need to use a Dockerfile. A Dockerfile is simply a text-based script of instructions that is used to create a container image.

Create a file named Dockerfile in the same directory as app.py:

$ touch Dockerfile

Contents of the Dockerfile:

FROM python:3.6

COPY . /src

COPY ./requirements.txt /src/requirements.txt

WORKDIR src

EXPOSE 3000:3000

RUN pip3 install -r requirements.txt

CMD [ "python", "app.py" ]

Build the container image using docker build command:

$ sudo docker build -t demoapp .

Running the application

Start the container using docker run command

$ sudo docker run -dp 3000:3000 demoapp

Use your browser to access http://172.17.0.2:3000/form-example. You should see the app!

Results

The first page is a form with Username and Interest field entries and a Submit button:

Upon entering the name, field of interest press Submit

And Voila!!

DEV Community: James Kinga

Python3: Try-Else Statement

Table of contents

Introduction

What is Try-Else Statement?

Benefits of try-else

1. Improved code readability

2. Better error handling

3. Cleaner code

Conclusion

Simple Twitter Bot to Retweet & Favorite Using Python & Tweepy

Intro

Twitter Bot Challenge (#BuildWhat'sNext)

Requirements

Twitter Developer Account

Python Virtual Environment

Let's Code

Conclusion

Important Network and Troubleshooting Tools for Linux

1. Overview

2. Tools and Commands

2.1. ifconfig

2.2. ping

2.3. whois

2.4. nslookup

2.5. traceroute

2.6. netstat

2.7. dig

3. Conclusion

Getting Started with Docker & Flask

Docker

Docker Container

Docker installation

Set up the repository

Install Docker Engine

Flask

Setting Up Our Environment

Demo Flask Application

Build the python application,

Build the App's container image

Running the application

Results