Problem Formulation

I just tried to run AutoGPT on an EC2 instance using SSH from my local Windows machine. But here’s the annoying part: the connection always closes and AutoGPT can only work in small ~10 minute increments. When I return to my machine, I need to SSH into my instance and restart the program.

Problem Formulation: Your SSH connection to a remote server works properly at your workplace, but it freezes after 10-15 minutes when connecting from home. You don’t receive any error messages, but you notice zombie login users that need to be killed manually.

Quick and Easy Solution (Client-Side)

To prevent an SSH connection from closing when the client goes silent, you can configure the client to send a keep-alive signal to the server periodically.

Create a configuration file in your home directory at $HOME/.ssh/config, and set its permissions to 600 using chmod 600 ~/.ssh/config after file creation. To send a keep-alive signal every 240 seconds, for example, add the following lines to the configuration file:

Host * ServerAliveInterval 240

You can get this done with the following two commands on Linux:

printf '%s\n' 'Host *' ' ServerAliveInterval 240' > ~/.ssh/config
chmod 600 ~/.ssh/config

You can then check the file content using the command cat ~/.ssh/config like so:

Alternative Solution: Server Side

In some cases, you have access to the server’s SSH settings. In that case, add an entry ClientAliveInterval 60 to the file /etc/ssh/sshd_config. I used the Vim editor in the terminal to accomplish this.

Do you want to keep improving your coding and tech skills? Feel free to check out our Python and tech academy by downloading your free cheat sheets for starters:

In this two-part tutorial series, we will learn how to create a translation app using Django. As an extra feature, we are going to demonstrate two ways to create a word counter that counts the number of words written.

Translating text to a language one can understand is no longer a new development. As many businesses are done on an international level, it necessitates the need to communicate in a language the other party can understand.

Advancement in technology has removed the barrier to communication. With an app such as Google Translate, you can get the meaning of text written in another language.

As part of learning Django through building projects, we are going to implement such a feature.

What We Are Going to Learn

As earlier stated, this is a two-part series project tutorial. The first part focuses on building a translation app. In the second part, we are going to learn how to add another feature, a word counter. I’m going to show you how to go about building it using both JavaScript and Python.

By the end of this tutorial, you are not only going to learn how Django interacts with web pages, but you are also going to learn how to manipulate the DOM with JavaScript. Thus, even if you have little or no knowledge of HTML, CSS, and JavaScript, you can combine your knowledge of Python with my explanation to understand what we are doing.

Getting Started

Although this is a beginner Django project, I expect you to know the steps involved in setting up Django as I don’t have to be repeating myself whenever I’m writing a Django project tutorial. However, if this is your first time, check this article to learn how to install Django.

Your Django project should be created in the current folder using the name, translator. Then use app as the name of the Django app. After installation, go to the settings.py file and add the app name.

INSTALLED_APPS = [ 'django.contrib.admin', 'django.contrib.auth', 'django.contrib.contenttypes', 'django.contrib.sessions', 'django.contrib.messages', 'django.contrib.staticfiles', # custom app 'app', ]

Creating the View Function

Next, go to the views.py file and add the following code to it.

from django.shortcuts import render

from translate import Translator # Create your views here. def index(request): if request.method == 'POST': text = request.POST['translate'] lang = request.POST['language'] translator = Translator(to_lang=lang) translation = translator.translate(text) context = { 'translation': translation, } return render(request,'index.html', context) return render(request, 'index.html')

This is a very simple view function. We get the input from the HTML form provided it is a POST request. Then, we call on the Translator class of the translator module to translate the given text into the language selected. The Translator class has an argument, to_lang. This indicates the language you want your text to be translated.

We finally use the render function to display the translated text on the index.html web page. We can as well use the HttpResponse() function but it will not be displayed on the index.html web page.

But if the request method is not POST, we simply return the web page containing an empty form.

This part is as simple as it should be. But in future tutorials, we will be dealing with a more complicated view function.

The Templates

Next is the templates folder. Create the folder and add it to the settings.py file.

TEMPLATES = [ { 'BACKEND': 'django.template.backends.django.DjangoTemplates', 'DIRS': [os.path.join(BASE_DIR, 'templates')], # add these 'APP_DIRS': True, 'OPTIONS': { 'context_processors': [ 'django.template.context_processors.debug', 'django.template.context_processors.request', 'django.contrib.auth.context_processors.auth', 'django.contrib.messages.context_processors.messages', ], }, },

]

Inside the folder, we create the index.html file.

<!DOCTYPE html>

<html> <head> <title>Django Translate</title> </head> <body> <h1>Django Translate App</h1> <form method="post"> {% csrf_token %} <label for="django">Enter Text:</label> <br/> <textarea on‌Change="" id="translate" name="translate" placeholder="Enter your text here" rows="10" cols="70"></textarea> <br> <select required name="language"> <option value="French">French</option> <option value="Spanish">Spanish</option> <option value="German">German</option> <option value="Italian">Italian</option> </select> <br> <br> <button id="btn" type="submit">Translate</button> </form> <br> <textarea id="text" placeholder="Your text will appear here" rows='10' cols='70'>{{ translation }}</textarea> </body> <script src="{% static 'js/script.js' %}"></script>

</html>

You can see the form element has the method property as POST. Without this, our view function will not work as expected. The csrf_token is a mandatory requirement for security. We use the select element to list the languages. You can add as many as you want.

Notice that the textarea and the select elements each has a name property, and if you check the view function, you will see that it has the same name as found in the HTML file. This is the way we retrieve data from the web page.

Finally, we register the URL of the app both in the project level and in the app level. For the project level, go to translate/urls.py file and add this:

from django.contrib import admin

from django.urls import path, include urlpatterns = [ path('admin/', admin.site.urls), path('', include('app.urls'))

]

For the app level create a app/urls.py file and add this:

from django.urls import path

from .views import index urlpatterns = [ path('', index, name='home'),

]

Check the article I mentioned to see a brief explanation of the above code. That’s it. We are good to go. Fire up the local server to test what we have done.

Notice how we make the translated text appear inside the box. We accomplished this using Django templating language. Remember the context variable passed to the render() function? It is a dictionary object, the name of the key being what we passed to the textarea element. Thus, we are telling Django to display the value of the key to the web page.

And what is the value? The translated text! That is how Django dynamically writes to a web page. Feel free to play with any language of your choice provided the language is included in the translate library.

Conclusion

This is how we come to the end of the first part of this tutorial series. The full code for the project series can be found here. In the second part, we will learn two ways we can count the number of words written in the textarea element:

Recommended: How I Created a Translation and Counter App using Django (2/2)

Problem Formulation

Working with Python often involves processing complex data structures such as dictionaries and lists. In many instances, it becomes necessary to convert a dictionary of lists into a more convenient and structured format like a Pandas DataFrame .

DataFrames offer numerous benefits, including easier data handling and analysis , as well as an array of built-in functions that make data manipulation much more straightforward.

In this context, the potential challenge arises in figuring out how to correctly convert a dictionary with lists as its values into a DataFrame. Various methods can be employed to achieve this goal, but it is crucial to understand the appropriate approach in each situation to ensure accurate and reliable data representation .

Method 1: Using DataFrame.from_dict()

In this method, we will use the DataFrame.from_dict() function provided by the pandas library to convert a Python dictionary of lists to a DataFrame. This function is quite versatile, as it can construct a DataFrame from a dictionary of array-like or dictionaries data.

To begin with, let’s import the necessary library:

import pandas as pd

Next, create a dictionary with lists as values. For example, let’s consider the following dictionary:

data = { 'Name': ['Sam', 'Alex', 'Jamie'], 'Age': [29, 28, 24], 'Country': ['USA', 'UK', 'Canada']

}

Now, use the from_dict() method to create a DataFrame from the dictionary. The process is quite simple, all you have to do is call the method with the dictionary as its argument.

df = pd.DataFrame.from_dict(data)

And there you have it, a DataFrame created from a dictionary of lists! The resulting DataFrame will look like this:

 Name Age Country
0 Sam 29 USA
1 Alex 28 UK
2 Jamie 24 Canada

The benefits of using this method are its simplicity and compatibility with different types of dictionary data. However, always remember to maintain a consistent length for the lists within the dictionary to avoid any issues.

Method 2: Using pd.Series() with DataFrame

In this method, we will be using the Pandas library’s pd.Series data structure inside the DataFrame method. It is a useful approach that can help you convert dictionaries with lists into a DataFrame format quickly and efficiently.

To implement this method, you can use Python’s dictionary comprehension and the items() method, as shown in the syntax below:

pd.DataFrame({key: pd.Series(val) for key, val in dictionary.items()})

Here, dictionary.items() fetches key-value pairs from the dictionary, and pd.Series(val) creates a series of values from these pairs. The result is a well-structured Pandas DataFrame!

Let’s take a look at an example:

import pandas as pd data = { "Name": ["Alice", "Bob", "Claire"], "Age": [25, 30, 35], "City": ["London", "New York", "Sydney"],

} df = pd.DataFrame({key: pd.Series(val) for key, val in data.items()})

print(df)

Executing this code will generate the following DataFrame:

 Name Age City
0 Alice 25 London
1 Bob 30 New York
2 Claire 35 Sydney

As you can see, using the pd.Series data structure with the DataFrame method provides a clean and effective way to transform your dictionaries with lists into Pandas DataFrames!

Recommended: Python Dictionary Comprehension: A Powerful One-Liner Tutorial

Method 3: json_normalize()

In this method, we will use the pd.json_normalize function to convert a Python dict of lists to a Pandas DataFrame. This function is particularly useful for handling semi-structured nested JSON structures, as it can flatten them into flat tables.

To begin, you should first import the Pandas library using the following snippet:

import pandas as pd

Next, create your Python dict of lists like this example:

data = { 'manoj': ["java", "php", "python"], 'rajesh': ["c", "c++", "java"], 'ravi': ["r", "python", "javascript"]

}

With your data ready, you can now use the json_normalize function to convert the dict of lists into a DataFrame.

Here’s how:

df = pd.json_normalize(data, record_path='manoj', meta=['rajesh', 'ravi'])

And that’s it! You now have a DataFrame created from the dict of lists. Don’t forget to preview your DataFrame using print(df) or df.head() to ensure that the data has been converted correctly.

Method 4: Utilizing DataFrame Constructor with List Comprehension

In this method, we create a pandas DataFrame from a dictionary of lists using the DataFrame constructor and list comprehension. This approach is quite simple and potentially more efficient for larger datasets.

First, we need to import the pandas library:

python import pandas as pd

Next, let’s create a sample dictionary of lists containing student data:

data = { 'Name': ['Alice', 'Bob', 'Charlie'], 'Math': [80, 70, 90], 'History': [95, 85, 78] } 

Now, we will use the DataFrame constructor and list comprehension to convert the dictionary of lists into a pandas DataFrame:

df = pd.DataFrame({key: pd.Series(value) for key, value in data.items()}) 

Here’s what’s happening in the code above:

• The dictionary of lists is iterated using items() method to obtain the key-value pairs
• Each value is converted to a pandas Series using pd.Series() function
• A DataFrame is created using the pd.DataFrame() constructor to combine the converted series

Once the DataFrame is constructed, it will look something like this:

 Name Math History

0 Alice 80 95

1 Bob 70 85

2 Charlie 90 78 

Method 4 provides a concise and versatile way to transform a dictionary of lists into a DataFrame, making it convenient for data manipulation and analysis. Enjoy working with it!

Summary

In this article, we explored the process of converting a Python dictionary with lists as values into a pandas DataFrame. Various methods have been discussed, such as using pd.DataFrame.from_dict() and pd.DataFrame.from_records() to achieve this.

It’s important to choose a method that fits the specific structure and format of your data. Sometimes, you might need to preprocess the data into separate lists before creating a DataFrame. An example of doing this can be found here.

Throughout the article, we provided examples and detailed explanations on how to work with complex data structures, including lists of lists and lists of dictionaries. Remember to keep the code clean and efficient for better readability!

Recommended: How to Create a DataFrame From Lists?

With the knowledge gained, you’ll be better equipped to handle Python dictionaries containing lists, and successfully transform them into pandas DataFrames for a wide range of data analysis tasks. Happy coding!