Forem: ajitdhulam

Advanced Concepts: Transactions and Sharding

ajitdhulam — Sun, 17 Sep 2023 14:42:14 +0000

Advanced Concepts: Transactions and Sharding

1. Transactions in MongoDB:
Transactions ensure data consistency and integrity when performing multiple operations as a single unit of work. MongoDB supports multi-document transactions, allowing you to group multiple operations into a transaction and ensuring that they all succeed or fail together.

from pymongo import MongoClient


client = MongoClient()
db = client['mydatabase']
collection = db['mycollection']


with client.start_session() as session:
    with session.start_transaction():
        try:
            # Perform multiple operations within the transaction
            collection.update_one({"name": "Alice"}, {"$set": {"age": 29}})
            collection.update_one({"name": "Bob"}, {"$set": {"age": 33}})
            session.commit_transaction()
        except Exception as exc:
            print("Transaction aborted:", exc)
            session.abort_transaction()

2. Sharding and Horizontal Scaling:
Sharding involves distributing data across multiple servers to handle larger workloads and provide horizontal scaling. MongoDB's sharding feature is particularly useful for managing large datasets and high-throughput applications.

Enable Sharding: In the MongoDB shell, enable sharding for a specific database:

use mydatabase
sh.enableSharding("mydatabase")

Shard a Collection: Choose a shard key (e.g., a field to distribute data) and shard the collection:

sh.shardCollection("mydatabase.mycollection", { "shard_key_field": 1 })

Insert Data: Insert data into the sharded collection:

collection.insert_one({"shard_key_field": "value", "other_field": "data"})

Sharding allows MongoDB to distribute data across multiple shards, improving performance and accommodating large amounts of data.

These advanced concepts, such as transactions, sharding, and replication, provide MongoDB with the capabilities needed to handle complex scenarios and large-scale applications. The provided Python code snippets offer a glimpse into how these features can be implemented.

Conclusion:
The combination of Python and MongoDB stands as a dynamic force in today’s software development realm. The versatility of Python and the flexible design of MongoDB combine to provide a powerful tool. Python’s applications cover web development, data analytics, and AI, while MongoDB’s derivation from traditional databases provides scalability and flexibility. The CRUD process is seamless in the PyMongo driver. Improved queries, streamlined data modeling, and integration with web frameworks like Flask and Django increase productivity. The ability to communicate and partner effectively allows manufacturers to manage complex situations. Ultimately, this deal empowers developers to have two powerful people, capable of introducing innovation in different areas.

Integrating MongoDB with Web Frameworks: Flask and Django

ajitdhulam — Sun, 17 Sep 2023 14:33:21 +0000

Integrating MongoDB with Web Frameworks: Flask and Django:

1. Defining Models with Flask-MongoEngine:
Flask-MongoEngine simplifies integrating MongoDB with Flask applications. It provides an Object-Document Mapping (ODM) layer for MongoDB and Flask.

from flask import Flask
from flask_mongoengine import MongoEngine


app = Flask(__name__)
app.config['MONGODB_SETTINGS'] = {
    'db': 'mydatabase',
    'host': 'localhost',
    'port': 27017
}
db = MongoEngine(app)


class User(db.Document):
    username = db.StringField(required=True, unique=True)
    email = db.EmailField(required=True)


# Create a new user
new_user = User(username="john_doe", email="john@example.com")
new_user.save()


# Query users
users = User.objects(username="john_doe")

2. Integrating MongoDB with Django using Django-MongoDB-Engine:
Django-MongoDB-Engine allows Django to work with MongoDB as a database backend, providing a seamless integration experience.

from django.db import models
from djangotoolbox.fields import ListField, EmbeddedModelField
from mongodb_engine.fields import ObjectIdField


class User(models.Model):
    username = models.CharField(max_length=50, unique=True)
    email = models.EmailField()


# Create a new user
new_user = User(username="jane_doe", email="jane@example.com")
new_user.save()


# Query users
users = User.objects.filter(username="jane_doe")

Note: Settings for this are different as you need to install some packages and modify settings, you can refer to the references section.

By integrating MongoDB with Flask and Django using their respective MongoDB extensions, you can seamlessly use MongoDB as a database backend for your web applications. This integration provides the flexibility of NoSQL databases while leveraging the features and convenience of popular web frameworks.

Taking Queries to the Next Level: Advanced Querying

ajitdhulam — Sun, 17 Sep 2023 14:32:58 +0000

Taking Queries to the Next Level: Advanced Querying

1. Querying Techniques:
PyMongo offers a range of methods that allow you to craft complex queries to retrieve specific data from MongoDB collections. These techniques include filtering documents, sorting results, and limiting the number of retrieved documents.

from pymongo import MongoClient


# Connect to MongoDB
client = MongoClient()
db = client['mydatabase']
collection = db['mycollection']


# Filtering Documents:
# Retrieve documents where age is greater than 25
filtered_docs = collection.find({"age": {"$gt": 25}})


# Sorting Results:
# Retrieve documents sorted by age in descending order
sorted_docs = collection.find().sort("age", -1)


# Limiting Retrieved Documents:
# Retrieve only the first 5 documents
limited_docs = collection.find().limit(5)


# Combining Techniques:
# Retrieve and print documents of people aged 25-35, sorted by name
query = {"age": {"$gte": 25, "$lte": 35}}
result = collection.find(query).sort("name", 1)


for doc in result:
    print(doc)

Filtering Documents:
The find() method can accept query criteria to filter documents based on specific conditions. In the example above, only documents with an age greater than 25 are retrieved.
Sorting Results:
The sort() method sorts query results based on specified fields. In the code snippet, documents are sorted by age in descending order
Limiting Retrieved Documents:
The limit() method restricts the number of documents returned by a query. In this case, only the first 5 documents are retrieved.
Combining Techniques:
Query techniques can be combined to create more precise queries. In the example, documents of people aged 25 to 35 are retrieved and sorted by name.

By mastering advanced querying techniques, you can extract specific subsets of data from MongoDB collections, enabling you to obtain the information you need efficiently and effectively.

Seamless Integration: Building Python Applications with MongoDB

ajitdhulam — Sun, 17 Sep 2023 14:32:28 +0000

Seamless Integration: Building Python Applications with MongoDB

Building applications that interact with MongoDB using Python is a seamless process thanks to libraries like PyMongo. Python's versatility and MongoDB's flexibility complement each other, allowing you to create dynamic and data-driven applications.

1. Creating Python Applications with MongoDB:
Python applications can easily interact with MongoDB databases to perform a variety of tasks, from storing and retrieving data to performing complex data analysis. This integration is facilitated by PyMongo's intuitive API.

from pymongo import MongoClient

# Connect to MongoDB
client = MongoClient()
db = client['mydatabase']
collection = db['mycollection']

# Insert a document
new_doc = {"name": "Ajit", "age": 28}
collection.insert_one(new_doc) 

# Query documents
result = collection.find({"age": {"$gt": 25}}) 

for doc in result:
    print(doc)

2. Utilising Python Classes for Modelling:
Python's object-oriented capabilities can be leveraged to model MongoDB documents as Python classes, providing a structured and intuitive way to interact with data.

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age


    def save_to_db(self):
        collection.insert_one({"name": self.name, "age": self.age})



# Create and save a Person object
alice = Person("Ajit", 28)
alice.save_to_db()


# Query and display Person objects
result = collection.find({"age": {"$gt": 25}})


for doc in result:
    person = Person(doc["name"], doc["age"])
    print(person.name, person.age)

By creating Python classes that mirror your MongoDB document structure, you can encapsulate data and operations, making your code more organized and maintainable.

CRUD Operations with PyMongo:

ajitdhulam — Sun, 17 Sep 2023 14:31:37 +0000

CRUD Operations with PyMongo:

CRUD (Create, Read, Update, Delete) operations are fundamental when working with databases. PyMongo, the official MongoDB driver for Python, provides methods to perform these operations seamlessly.

Creating Documents: Creating documents involves inserting new data into a collection. PyMongo's insert_one() and insert_many() methods accomplish this.

# Insert a single document
new_doc = {"name": "Ajit", "age": 28}
collection.insert_one(new_doc)

# Insert multiple documents
new_docs = [
    {"name": "Bob", "age": 32},
    {"name": "Charlie", "age": 25}
]
collection.insert_many(new_docs)

Reading Documents: Reading documents involves querying the database to retrieve data. PyMongo's find() method and other query methods allow you to retrieve data based on specific criteria.

# Find all documents
all_docs = collection.find()


# Find documents that match a specific condition
young_people = collection.find({"age": {"$lt": 30}})

Updating Documents: Updating documents allows you to modify existing data. PyMongo's update_one() and update_many() methods help you achieve this.

# Update a single document
collection.update_one({"name": "Ajit"}, {"$set": {"age": 28}})


# Update multiple documents
collection.update_many({"age": {"$lt": 30}}, {"$inc": {"age": 1}})

Deleting Documents: Deleting documents involves removing data from a collection. PyMongo's delete_one() and delete_many() methods enable you to delete documents based on specified criteria.

# Delete a single document
collection.delete_one({"name": "Alice"})


# Delete multiple documents
collection.delete_many({"age": {"$gt": 30}})

Setting the Stage: Installing MongoDB and Python:

ajitdhulam — Sun, 17 Sep 2023 14:30:12 +0000

Setting the Stage: Installing MongoDB and Python:

1. Installing MongoDB:

macOS: Install MongoDB on macOS using Homebrew. Homebrew is a package manager that simplifies software installation. The following commands tap into the MongoDB formula, install the Community Edition, and start the MongoDB service.

brew tap mongodb/brew
brew install mongodb/brew/mongodb-community
brew services start mongodb/brew/mongodb-community

Windows:
Download the MongoDB installer from the official website and follow the installation steps. MongoDB can be set up as a Windows service during installation.
Linux (Ubuntu):
On Ubuntu, you can install MongoDB using apt by adding the repository key, updating the repository list, and then installing the MongoDB packages. The service can be started with systemctl.

wget -qO - https://www.mongodb.org/static/pgp/server-4.4.asc | sudo apt-key add - echo "deb [ arch=amd64,arm64 ] https://repo.mongodb.org/apt/ubuntu $(lsb_release -cs)/mongodb-org/4.4 multiverse" | sudo tee /etc/apt/sources.list.d/mongodb-org-4.4.list
sudo apt-get update
sudo apt-get install -y mongodb-org
sudo systemctl start mongod

2. Integrating Python and MongoDB:
PyMongo is a Python driver for MongoDB that provides an interface to interact with MongoDB databases using Python code. You can install pymongo by using the below command.

pip install pymongo

3. Connecting to a MongoDB instance using PyMongo:
Here's how you can connect to a MongoDB instance and perform basic operations:
This will create DB in mongo or you can create it directly in python code and use it as below.

from pymongo import MongoClient


# Connect to the default local MongoDB instance
client = MongoClient() 

# Access a database and a collection
db = client['mydatabase']
collection = db['mycollection']

Unlocking the Power of Python and MongoDB: A Comprehensive Journey

ajitdhulam — Sun, 17 Sep 2023 14:29:41 +0000

In the evolving software development landscape, the dynamic duo of Python and MongoDB has emerged as a potent alliance. This partnership capitalizes on Python's versatility and MongoDB's adaptability, allowing developers to create efficient, scalable, and data-driven applications. Whether you're an experienced developer or a newcomer eager to explore the fusion of databases and Python, this comprehensive guide will accompany you from the fundamental concepts to advanced techniques.

Introduction to Python and MongoDB: A Winning Pair:
let's dive deeper into Python's versatility, significance in the software development ecosystem, strengths, and applications across various domains:

1. Versatility and Significance:
Python is a versatile, high-level programming language that is widely used across various domains due to its simplicity, readability, and extensive library support. It's considered a "general-purpose" language because it can be applied to a wide range of tasks and industries. This versatility has contributed to Python's significance in the software development ecosystem.

2. Strengths:

Readability: Python's syntax emphasizes readability and clean code, making it easier to understand and maintain. This characteristic is especially beneficial when collaborating on projects.
Conciseness: Python allows developers to express concepts in fewer lines of code compared to many other programming languages. This concise syntax boosts productivity and reduces the likelihood of errors.
Vast Library Ecosystem: Python boasts a rich collection of libraries and frameworks that cover almost every application domain. This ecosystem enables developers to leverage existing solutions and accelerate development.
Community Support: Python has a vibrant and active community of developers, contributors, and users. This results in a wealth of online resources, tutorials, and forums where developers can seek help and share knowledge.
Cross-Platform Support: Python can be used on several operating systems, including Windows, macOS, and Linux... This makes it suitable for developing applications that can run seamlessly across different operating systems.
Integration Capabilities: Python can be easily integrated with other languages (like C, C++, and Java), allowing developers to use Python for specific tasks while leveraging existing codebases.

3. Applications:

Web Development: Thanks to frameworks like Django and Flask, Python is frequently used for web development. These frameworks simplify the process of building web applications by providing tools for handling routing, databases, and user authentication.
Data Analysis and Visualization: Python's libraries such as pandas, NumPy, and Matplotlib enable data analysts and scientists to efficiently clean, manipulate, and visualize data. An interactive platform for data exploration is offered by Jupyter Notebooks.
Machine Learning and AI: Python is a dominant language in the field of machine learning and artificial intelligence. Libraries like Scikit-learn, TensorFlow, and PyTorch empower developers to build and deploy machine learning models.
Scientific Computing: Python is widely used in scientific research and simulations, according to scientific computing. Its libraries support mathematical computations, simulations, and complex scientific computations.
Automation and Scripting: Python's ease of use makes it an ideal choice for automating tasks and writing scripts. It's often used for system administration, scripting repetitive actions, and managing files.
Game Development: Python can be used for creating games and interactive applications using libraries like Pygame.
Internet of Things (IoT): Python's lightweight footprint and versatility make it suitable for programming IoT devices and handling data from sensors.
Desktop Applications: Python can be used for creating desktop applications with graphical user interfaces (GUIs) using libraries like Tkinter and PyQt.

let's dive deeper into MongoDB's scalability, flexibility, and its departure from traditional SQL databases:

1. Introduction to MongoDB as a NoSQL Database: MongoDB is a widely used NoSQL (Not Only SQL) database that differs from traditional SQL databases in its approach to data storage and management. In MongoDB, data is stored in flexible, JSON-like documents known as BSON (Binary JSON) that can vary in structure from one document to another within the same collection. This is in contrast to SQL databases, where data is stored in rigid tables with predefined schemas.

2. Departure from Traditional SQL Databases: Traditional SQL databases, characterized by their structured schema and normalized data models, excel in maintaining data integrity and ensuring consistency. However, they can become limiting when dealing with rapidly changing or unstructured data. This is where NoSQL databases like MongoDB shine. MongoDB's schema-less nature allows for quick and dynamic changes to data structures, making it suitable for applications with evolving requirements.

3. Scalability and Core Strengths: MongoDB's scalability and flexibility are two of the core strengths that set it apart from traditional SQL databases:

Scalability: MongoDB is designed to handle the growing demands of modern applications. It offers both vertical and horizontal scalability. Vertical scaling involves upgrading the hardware of a single server (e.g., increasing RAM or CPU) to accommodate more load. However, MongoDB's true prowess lies in horizontal scaling.
Horizontal Scaling: MongoDB's architecture is well-suited for distributing data across multiple servers or nodes. This approach, often referred to as sharding, allows MongoDB to handle extremely large datasets and high traffic loads. Sharding involves partitioning data and distributing it across multiple shards (server instances), enabling seamless expansion as data volume increases.
High Availability: MongoDB is engineered for high availability through features like replica sets. In a replica set, multiple copies of data are maintained across different servers. If one server goes down, another copy can take over, ensuring continuous service. Automatic failover mechanisms minimize downtime and data loss.
Flexibility: MongoDB's document-oriented model allows developers to work with data in a way that closely resembles how it's used in their application code. There's no need for complex joins, and changes to data structures can be made without altering the entire database.
Schema Evolution: MongoDB's flexibility extends to schema evolution. New fields can be added to documents without affecting existing ones, enabling applications to adapt to changing requirements without data migration hassles.
Diverse Use Cases: MongoDB is suitable for a range of use cases, including content management systems, real-time analytics, IoT applications, and more. Its ability to handle structured, semi-structured, and unstructured data makes it versatile

Django Internationalization Tutorial-4

ajitdhulam — Wed, 09 Feb 2022 19:25:40 +0000

`Dynamically Change language, based on user choice.`

In the last post, demonstrated how to translate Django templates and JavaScript code. However, even though there are several ways to control how Django utilizes translations, we have so far utilized the settings to establish an application-wide language. In this last post, I will teach you how to configure Django to utilize a user-defined language.

Setting different languages by user local
Django has a flexible methodology for determining which language to use for translations. In this part, I will teach you how to use translations based on the browser's supported language. To begin, open the settings file (languages/ settings.py) and ensure that English is selected as the default language:

# Internationalization
# https://docs.djangoproject.com/en/2.2/topics/i18n/

LANGUAGE_CODE = 'en-us'

Now, we must tell Django which languages we have available for translations. Add the LANGUAGES list to your settings file

# Internationalization
# https://docs.djangoproject.com/en/2.2/topics/i18n/

from django.utils.translation import ugettext_lazy as _

LANGUAGES = (
    ('en-us', _('English')),
    ('pt-pt', _('Portuguese')),
)

LANGUAGE_CODE = 'en-us'

Finally, we must add the LocaleMiddleware to our list of middleware classes:

MIDDLEWARE = [
    'django.middleware.security.SecurityMiddleware',
    'django.contrib.sessions.middleware.SessionMiddleware',
    'django.middleware.locale.LocaleMiddleware',  # add this extra
    'django.middleware.common.CommonMiddleware',
    ...
    ...
]

Start the server, and Django should now be able to return your translations. If you make any modifications to the messages, remember to compile them.

Selecting User language from list on web
Django is to allow the user to select from a list. It uses the set_language redirect view.
First, open languages/urls.py and include the set_language view:

from django.views.i18n import JavaScriptCatalog
from django.urls import path, include

from . import views

urlpatterns = [
    path('', views.index, name='index'),
    path('jsi18n/', JavaScriptCatalog.as_view(), name='javascript-catalog'),
    path('i18n/', include('django.conf.urls.i18n')),
]

Now, open the template file at templates/languages/index.html and include the form to select the language:

{% load i18n %}

<h1>{% trans 'Hello' %}</h1>
<p>{% trans 'Welcome to my site.' %}</p>

<form action="{% url 'set_language' %}" method="post">{% csrf_token %}
    <input name="next" type="hidden" value="{{ redirect_to }}">
    <select name="language">
        {% get_current_language as LANGUAGE_CODE %}
        {% get_available_languages as LANGUAGES %}
        {% get_language_info_list for LANGUAGES as languages %}
        {% for language in languages %}
            <option value="{{ language.code }}"{% if language.code == LANGUAGE_CODE %} selected{% endif %}>
                {{ language.name_local }} ({{ language.code }})
            </option>
        {% endfor %}
    </select>
    <input type="submit" value="Go">
</form>

The form displays a list of languages before sending a POST request to the set language view with the language selected. Finally, open languages/views.py and ensure that render is used to render the template rather than render to response, as the latter fails to include the csrf token:

from django.shortcuts import render

def index(request):
    return render(request, 'languages/index.html')

Finally, because this technique makes use of the session variable, you may need to use python3 manage.py migrate to construct the database tables.

and finally the whole web page translate demo based on user choosen language.

References:
https://lokalise.com/blog/django-i18n-beginners-guide/
http://www.marinamele.com/taskbuster-django-tutorial/internationalization-localization-languages-time-zones
https://www.pycorners.com/
https://phrase.com/blog/posts/quick-guide-django-i18n/
https://www.pycorners.com/storie/6/2020/12/2/django-web-page-translation
https://www.youtube.com/watch?v=z_p8WxFGV5A&ab_channel=VeryAcademy
https://www.youtube.com/watch?v=AlJ8cGbk8ps&t=2s&ab_channel=PrettyPrinted

Disclaimer: This is a personal [blog, post, statement, opinion]. The views and opinions expressed here are only those of the author and do not represent those of any organization or any individual with whom the author may be associated, professionally or personally.

Django Internationalization Tutorial-3

ajitdhulam — Wed, 09 Feb 2022 19:03:46 +0000

Liquid syntax error: Tag '{% load i18n %}' was not properly terminated with regexp: /\%\}/

Django Internationalization Tutorial-2

ajitdhulam — Wed, 09 Feb 2022 18:35:15 +0000

`Depth about settings and translation from view.py file`

In the previous tutorial of Django Internationalization, we developed a basic view that returns a message defined in the output variable.

In this post our objective will be to execute the interpretation of that message. For this we will utilize the Django project made in the past post.

Settings configuration:

Naturally, Django projects made with preparation are as of now set up for internationalization (i18n) and confinement (l10n). Notwithstanding that, open the venture settings at langtests/settings.py and ensure that USE_I18N and USE_L10N are set to true

# Internationalization
# https://docs.djangoproject.com/en/2.2/topics/i18n/

LANGUAGE_CODE = 'en-us'
TIME_ZONE = 'UTC'

USE_I18N = True
USE_L10N = True
USE_TZ = True

One significant setting to note is the LANGUAGE_CODE, which characterizes the default language for the whole project. As a matter of course, it is set to 'en-us' nevertheless later we will change it to 'pt-pt' to test that translation is working.

The second thing we should do is add the laguages application (The one we created in first tutorial) to the rundown of Installed apps in settings.py. Although we could get to the view without it, for projects it will be essential:

# Application definition

INSTALLED_APPS = [
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
    'languages'
]

Translation:
In Django, all translatable strings must be expressly stamped. In Python code, we determine interpretation strings by utilizing the ugettext() function or underscore (_) as alias of it. For this application, open languages/views.py and mark the result string as translatable.

from django.utils.translation import ugettext as _
from django.http import HttpResponse

def index(request):
    output = _('Welcome to my site.')
    return HttpResponse(output)

Extra Changes: In addition to the import statement, the only significant change is the use of the underscore alias for ugettext.

Create Translation Files:
Since we have distinguished the translatable strings, we want to make the interpretation documents themselves.  In Django, translation files are called message files and have a .po file extension.

Django accompanies a device (makemessages) that robotizes the creation and updates of these documents. Even though you can execute this content from a few spots, we will save it basic for this instructional exercise and use it inside the lanagues application since it is the main application we have.

make sure to create the locale directory inside the language's directory (using mkdir locale).

For instance, let us create a message file for Portuguese. Inside the languages directory do:

django-admin makemessages -l pt_pt

This will create the following structure in
the language's application.

Note: It is worth noting that I used an underscore for the language directory (pt_pt rather than pt-pt). Although we use dashes such as pt-pt in Django settings, we must use underscores in folders.

Writing Translation Messages:
Assuming you really look at the substance of django.po you will view the string prepared as meant Portuguese. In basic terms, the Django makemessages script looks for events of ugettext() and takes out all strings set apart for translation.

To do the translation, just fill in the content of msgstr:

#: views.py:5
msgid "Welcome to my site."
msgstr "Bem-vindo ao meu site"

After translating all strings, we must compile the strings with the compilemessages script:

django-admin compilemessages

A new file django.mo will appear next to the message file.

Testing Sample Translation
Although everything appears to be prepared for interpretations, assuming we direct the program toward http://localhost:8000/languages/, we are going to get the "Welcome to my site." string in English. This is on the grounds that we have not indicated anyplace to which language we ought to interpret the string.

# Internationalization
# https://docs.djangoproject.com/en/2.2/topics/i18n/


LANGUAGE_CODE = 'pt-pt'
TIME_ZONE = 'UTC'

USE_I18N = True
USE_L10N = True
USE_TZ = True

Now point the browser to http://localhost:8000/languages/:

Django will return the string translated into Portuguese, as Google translation giving option you are viewing in Portuguese and want to convert into English.

Django Internationalization Tutorial-1

ajitdhulam — Wed, 09 Feb 2022 17:04:18 +0000

`Introduction and Base Project` .

Before starting here if you are familiar with creating Django project feel free to skip this tutorial and start the next.

If not just make sure you have installed python and Django in your system by follow command, if you want more detail follow Django Website

pip install django

above command will install Django application in system, now we need to create project directory where we can store our code and manage to run, copy below code, and run in your CMD/Terminal

django-admin startproject langtests

This will create the langtests directory in the current working directory. To create the languages app, cd into langtests and execute:

python3 manage.py startapp languages

The directory structure of our project will be the following:

Here, langtests contains 1 manage.py file, one sub directory which contains 4 python files with extension .py file such as settings.py, urls.py, wsgi.py and _init.py. and last i.e. third one is 2nd sub folder which is our application i.e., languages, this contains 5 python files and one folder with name migrations, migrations folder store all db file info will discuss this in other post, now look at 5 diff files namely __init_.py, admin.py, models.py, tests.py, and views.py,

Overview of each file:

_init_.py: An empty file that tells Python that this directory should be considered a Python package.

settings.py: Contains all the information of projects such as Database, Template, Middleware, Third Party, i18N, Static information and many more. Settings/configuration for this Django project. Django settings will tell you all about how settings work.

urls.py: The URL (Uniform Resource Locator) declarations for this Django project; a “table of contents” of your Django-powered site. You can read more about URLs (Uniform Resource Locators) in URL dispatcher.

wsgi.py: An entry-point for WSGI-compatible web servers to serve your project. See How to deploy with WSGI for more details.
If you have worked with Django, you already know what these files are. If not, I recommend following the Django tutorial as it will allow you to understand most of the basic concepts.

Let get touch some code introductory code part:

Let create a simple view for our 'languages' app's index page. Open languages/views.py and paste the code below:

from django.http import HttpResponse

def index(request):
     output = 'Welcome to my site.'
     return HttpResponse(output)

This view will now be mapped to a URL. Created a file named urls.py in the languages directory that contains the following code:

from django.contrib import admin
from django.urls import path

urlpatterns = [
    path('admin/', admin.site.urls),
]

Finally, from the root URLconf, map a URL. Include the URLs for the language apps in urlpatterns in langtests/urls.py as follows:

from django.conf.urls import include
from django.contrib import admin
from django.urls import path

urlpatterns = [
    path('admin/', admin.site.urls),
    path('languages/', include('languages.urls')),
]

To test the view, start the Django server using below command

python3 manage.py runserver

and navigate to http://localhost:8000/languages/ in your browser.

Django Internationalization

ajitdhulam — Wed, 09 Feb 2022 15:27:36 +0000

`Information about Tutorial structure & Nomenclature`

We know how vastly popular Django framework for python is, and it supports a lot of battery-inclusion. One of the built-in features of Django is i18n i.e., Internationalization: Below 4 tutorials shows how to utilize i18n to remove language barriers in web applications, with user choose language.

This tutorial series show how to setup translation using Django framework, that means translate the whole web page based on user chosen language, for blog purpose used 2 languages first and default English(en-us) and second one is Portugues(pt-pt), will start project from scratch, before that please go with few nomenclatures to understand easily, and for this blog using Django 2.2 on python 3.7 and all tutorial applicable for later version also

Nomenclature

Django Internationalization = The goal of internationalization and localization is to allow a single web application to offer its content in different languages and formats tailored to the audience, Read more .

USE_I18N = If this is set to False, Django will make some optimizations so as not to load the translation machinery, Read more .

USE_L10N = A Boolean that specifies if localized formatting of data will be enabled by default or not. If this is set to True, e.g., Django will display numbers and dates using the format of the current locale. Read more