Category: Technology

Django formfield_for_foreignkey function
Mastering Django formfield_for_foreignkey: Complete Guide with Examples

Django’s admin is one of its most powerful features. Out of the box, it gives you CRUD forms to create, edit, and manage your models. But sometimes, the default dropdowns for ForeignKey fields are too broad — they list all related objects in the database, which may not always be secure, efficient, or user-friendly.

This is where formfield_for_foreignkey comes in.

In this guide, we’ll cover everything you need to know:
- ✅ What formfield_for_foreignkey is
- ✅ How Django handles ForeignKey fields by default
- ✅ Real-world use cases for overriding it
- ✅ Advanced examples with filtering, permissions, and tenants
- ✅ Best practices for production apps
- ✅ FAQs and troubleshooting tips
By the end, you’ll be able to customize your admin dropdowns to be smarter, safer, and tailored to your business rules.

1. What is formfield_for_foreignkey?

In Django Admin, the method formfield_for_foreignkey(self, db_field, request, **kwargs) is a hook method inside ModelAdmin. It allows you to customize the queryset for ForeignKey dropdown fields in the admin form.

By default, Django lists all related objects in the dropdown. But with this hook, you can:
- Filter objects (e.g., only active ones)
- Restrict by logged-in user
- Sort objects for usability
- Enforce multi-tenant separation
- Apply role-based visibility rules
Method signature:
```
def formfield_for_foreignkey(self, db_field, request, **kwargs):
    # custom logic
    return super().formfield_for_foreignkey(db_field, request, **kwargs)
```
2. How Django Handles ForeignKey by Default

Consider this example:
```
class Author(models.Model):
    name = models.CharField(max_length=100)

class Book(models.Model):
    title = models.CharField(max_length=200)
    author = models.ForeignKey(Author, on_delete=models.CASCADE)
```
In Django Admin, when creating a Book, the author dropdown will list all authors in the database.

That’s fine for small projects, but:
- It can clutter the UI when there are thousands of authors.
- It may expose data users shouldn’t see (e.g., other tenants’ data).
- It can confuse staff who only need a subset.
This is the default behavior — and exactly where formfield_for_foreignkey helps.

3. Real-World Use Cases

Example 1: Filter by Logged-In User
```
@admin.register(Book)
class BookAdmin(admin.ModelAdmin):
    def formfield_for_foreignkey(self, db_field, request, **kwargs):
        if db_field.name == "author":
            kwargs["queryset"] = Author.objects.filter(created_by=request.user)
        return super().formfield_for_foreignkey(db_field, request, **kwargs)
```
✅ Only authors created by the logged-in user appear in the dropdown.

Example 2: Show Only Active Records
```
def formfield_for_foreignkey(self, db_field, request, **kwargs):
    if db_field.name == "author":
        kwargs["queryset"] = Author.objects.filter(is_active=True)
    return super().formfield_for_foreignkey(db_field, request, **kwargs)
```
✅ Inactive authors are hidden.

Example 3: Sort Dropdown Alphabetically
```
def formfield_for_foreignkey(self, db_field, request, **kwargs):
    if db_field.name == "author":
        kwargs["queryset"] = Author.objects.all().order_by("name")
    return super().formfield_for_foreignkey(db_field, request, **kwargs)
```
✅ Users see a clean, ordered dropdown.

Example 4: Restrict by Permissions
```
def formfield_for_foreignkey(self, db_field, request, **kwargs):
    if db_field.name == "author":
        if request.user.has_perm("app.view_all_authors"):
            kwargs["queryset"] = Author.objects.all()
        else:
            kwargs["queryset"] = Author.objects.filter(created_by=request.user)
    return super().formfield_for_foreignkey(db_field, request, **kwargs)
```
✅ Superusers/managers see all authors. ✅ Staff see only their own.

Example 5: Multi-Tenant Filtering
```
def formfield_for_foreignkey(self, db_field, request, **kwargs):
    if db_field.name == "customer":
        kwargs["queryset"] = Customer.objects.filter(tenant=request.user.tenant)
    return super().formfield_for_foreignkey(db_field, request, **kwargs)
```
✅ Each tenant only sees their own customers.

4. When to Use It?

You should override formfield_for_foreignkey when:
- You want to limit foreign key options based on logged-in user.
- You need to hide irrelevant or sensitive records.
- You want to improve usability by sorting or filtering.
- You’re working with a multi-tenant app.
5. Best Practices
- ✅ Always call super() at the end.
- ✅ Keep queries efficient — avoid heavy joins here.
- ✅ Apply consistent filtering across forms and lists (get_queryset).
- ✅ Test with multiple roles (staff, superuser).
- ✅ Document your filtering logic — future devs will thank you.
6. Common Mistakes
- ❌ Forgetting to return super() → breaks form rendering.
- ❌ Overly complex queries → slows down admin.
- ❌ Inconsistent logic with get_queryset → users see mismatched data.
7. FAQs

Q: Can I filter dropdowns differently for add vs. change forms? 👉 Yes, you can check request.resolver_match or request.path to see the context.

Q: Can I use it for ManyToMany fields? 👉 Use formfield_for_manytomany instead.

Q: Is this the only way to filter foreign keys? 👉 No — you can also use custom ModelForms, but this method is the most admin-friendly.

8. Final Thoughts

Django’s formfield_for_foreignkey is more than just a customization hook — it’s a security and usability tool. By mastering it, you can:
- Keep admin dropdowns clean and focused.
- Enforce tenant and role-based restrictions.
- Prevent accidental data leaks.
October 3, 2025

What is a Decorators in Python, Django and FastAPI

🔹 Decorators in Python, Django and FastAPI in details with examples

In Python, a decorator is a function that wraps another function or class to modify or extend its behavior without changing its code directly.

Think of it like:

“A decorator takes a function/class as input → adds some extra functionality → and returns a new function/class.”

🔹 Example 1 – Simple function decorator

def my_decorator(func):
    def wrapper():
        print("Before function runs")
        func()
        print("After function runs")
    return wrapper

@my_decorator   # same as: hello = my_decorator(hello)
def hello():
    print("Hello, World!")

hello()

Output:

Before function runs
Hello, World!
After function runs

Here:

@my_decorator wraps the hello() function.
When you call hello(), actually wrapper() runs.

🔹 Example 2 – Decorator with arguments

def repeat(n):
    def decorator(func):
        def wrapper(*args, **kwargs):
            for _ in range(n):
                func(*args, **kwargs)
        return wrapper
    return decorator

@repeat(3)   # repeat hello 3 times
def hello(name):
    print(f"Hello {name}!")

hello("Atif")

Output:

Hello Atif!
Hello Atif!
Hello Atif!

🔹 Example 3 – Django decorator

In Django, you’ve seen things like:

from django.contrib.auth.decorators import login_required

@login_required
def my_view(request):
    ...

Here @login_required ensures that only logged-in users can access that view.

🔹 Example 4 – Class decorator (Django admin)

In your admin file, you saw:

@admin.register(Payment)
class PaymentAdmin(admin.ModelAdmin):
    ...

This is a class decorator. It tells Django: “Register the Payment model in the admin, using this custom admin class.”

Equivalent without decorator:

class PaymentAdmin(admin.ModelAdmin):
    ...

admin.site.register(Payment, PaymentAdmin)

🔹 Example 5 – FastAPI decorator

In FastAPI, routes are defined with decorators:

from fastapi import FastAPI

app = FastAPI()

@app.get("/hello")
def say_hello():
    return {"msg": "Hello World"}

Here @app.get("/hello") is a decorator that says: “When someone sends a GET request to /hello, call this function.”

###✅ Summary for decorators:

Decorators = wrappers that extend/modify behavior of functions/classes.
They’re widely used in Django (admin, views, permissions) and FastAPI (routes, middlewares).

##how to write your own decorator step by step

Let’s build your own decorators step by step. We’ll start from very basic → then add arguments → then apply in Django-like use cases.

🛠 Step 1: Basic decorator

def simple_decorator(func):
    def wrapper():
        print("👉 Before the function")
        func()
        print("👉 After the function")
    return wrapper

@simple_decorator
def say_hello():
    print("Hello Atif!")

say_hello()

Output:

👉 Before the function
Hello Atif!
👉 After the function

📌 Here:

@simple_decorator is applied to say_hello.
When you call say_hello(), Python actually runs wrapper().

🛠 Step 2: Decorator for any function with arguments

def log_args(func):
    def wrapper(*args, **kwargs):
        print(f"Function {func.__name__} called with args={args}, kwargs={kwargs}")
        return func(*args, **kwargs)   # run the real function
    return wrapper

@log_args
def add(a, b):
    return a + b

print(add(3, 5))

Output:

Function add called with args=(3, 5), kwargs={}
8

🛠 Step 3: Decorator with arguments

Sometimes you want to pass options to your decorator itself.

def repeat(n):
    def decorator(func):
        def wrapper(*args, **kwargs):
            for i in range(n):
                print(f"Run {i+1} of {n}")
                func(*args, **kwargs)
        return wrapper
    return decorator

@repeat(3)   # repeat the function 3 times
def greet(name):
    print(f"Hello {name}")

greet("Atif")

Output:

Run 1 of 3
Hello Atif
Run 2 of 3
Hello Atif
Run 3 of 3
Hello Atif

Decorator in Django

🛠 A Django-like decorator

Let’s make our own login_required style decorator:

def my_login_required(func):
    def wrapper(request, *args, **kwargs):
        if not getattr(request, "user", None):   # check if request has a user
            return "❌ User not logged in!"
        return func(request, *args, **kwargs)
    return wrapper

# fake request objects
class Request:
    def __init__(self, user=None):
        self.user = user

@my_login_required
def dashboard(request):
    return f"Welcome {request.user}!"

print(dashboard(Request()))        # no user
print(dashboard(Request("Atif")))  # with user

Output:

❌ User not logged in!
Welcome Atif!

🛠 Using class decorator (like Django Admin)

def register_model(model_name):
    def decorator(admin_class):
        print(f"✅ Registered {model_name} with admin class {admin_class.__name__}")
        return admin_class
    return decorator

@register_model("Payment")
class PaymentAdmin:
    pass

Output:

✅ Registered Payment with admin class PaymentAdmin

📌 This is exactly how @admin.register(Model) works internally.

###✅ Summary for Django Decorators:

A decorator is a function that wraps another function/class.
@decorator_name is just shorthand for function = decorator_name(function).
They’re useful for authentication checks, logging, caching, registering routes/admins, etc.

##decorators in FastAPI. They work the same as Python decorators, but in FastAPI they’re often used for middleware-like behavior (before/after running your endpoint).

🛠 Example 1: Simple logging decorator

from fastapi import FastAPI

app = FastAPI()

# Custom decorator
def log_request(func):
    async def wrapper(*args, **kwargs):
        print(f"👉 Calling endpoint: {func.__name__}")
        result = await func(*args, **kwargs)
        print(f"✅ Finished endpoint: {func.__name__}")
        return result
    return wrapper

@app.get("/hello")
@log_request
async def say_hello():
    return {"message": "Hello Atif!"}

When you visit /hello:

👉 Calling endpoint: say_hello
✅ Finished endpoint: say_hello

🛠 Example 2: Decorator to check API Key

from fastapi import FastAPI, Request, HTTPException

app = FastAPI()

def require_api_key(func):
    async def wrapper(request: Request, *args, **kwargs):
        api_key = request.headers.get("X-API-Key")
        if api_key != "secret123":
            raise HTTPException(status_code=403, detail="Invalid API Key")
        return await func(request, *args, **kwargs)
    return wrapper

@app.get("/secure")
@require_api_key
async def secure_endpoint(request: Request):
    return {"message": "You are authorized!"}

🔑 If you call /secure without X-API-Key: secret123, you’ll get:

{"detail": "Invalid API Key"}

🛠 Example 3: Decorator with arguments (rate limiter style)

import time
from fastapi import FastAPI, HTTPException

app = FastAPI()

def rate_limit(seconds: int):
    last_called = {}

    def decorator(func):
        async def wrapper(*args, **kwargs):
            now = time.time()
            if func.__name__ in last_called and now - last_called[func.__name__] < seconds:
                raise HTTPException(status_code=429, detail="Too many requests")
            last_called[func.__name__] = now
            return await func(*args, **kwargs)
        return wrapper
    return decorator

@app.get("/ping")
@rate_limit(5)   # limit calls to every 5 seconds
async def ping():
    return {"message": "pong!"}

First request works ✅
Second request within 5s → 429 Too Many Requests

🛠 Example 4: Class decorator for routes (like Django’s `@admin.register`)

def tag_routes(tag: str):
    def decorator(func):
        func._tag = tag  # attach metadata
        return func
    return decorator

app = FastAPI()

@app.get("/items")
@tag_routes("inventory")
async def get_items():
    return {"items": ["apple", "banana"]}

# Later you could inspect `get_items._tag` == "inventory"

##✅ Summary for FastAPI decorators

Work same as Python decorators
Useful for:
- Logging
- Auth / API keys
- Rate limiting
- Attaching metadata
You can mix them with FastAPI’s built-in dependencies, but decorators give more fine-grained control.

September 4, 2025

Measles Surge:* Measles cases are rising globally, prompting discussions on whether children should be vaccinated earlier.

Understanding Measles and Its Impact

Measles is a highly contagious viral infection caused by the measles virus, which belongs to the Paramyxoviridae family. The disease primarily spreads through respiratory droplets when an infected individual coughs or sneezes. It is crucial to note that measles is capable of remaining infectious in the air for up to two hours and can be contracted by individuals who have not been vaccinated, making it particularly worrisome in communities with low vaccination coverage.

Symptoms of measles typically manifest around 10 to 14 days after exposure, beginning with high fever, cough, runny nose, and inflamed eyes. These are followed by a distinctive red, blotchy rash that usually starts on the face and spreads to the rest of the body. While many individuals recover without complications, measles can lead to severe health issues, especially in young children and those with weakened immune systems. Potential complications include pneumonia, encephalitis, and even death, underlining the importance of vaccination as a preventative measure.

The global health impact of measles outbreaks has been significant, particularly in regions experiencing vaccination declines. According to the World Health Organization (WHO), the number of measles cases has surged dramatically in recent years, with a reported increase of nearly 550% worldwide from 2016 to 2019. This alarming trend continued with the continuing outbreaks observed through 2023, prompting public health experts to reassess existing vaccination strategies and policies.

In countries with low immunization rates, the consequences are dire, leading to thousands of preventable deaths annually. The resurgence of measles poses a threat that not only affects the vulnerable population but also places strain on healthcare systems grappling with additional demands. Addressing this challenge requires a collaborative effort to restore vaccination initiatives and combat misinformation regarding measles vaccines. Understanding the implications of measles and its transmission dynamics is essential for formulating effective public health strategies moving forward.

Current Statistics on Measles Cases Worldwide

Recent data indicates a troubling surge in measles cases globally, emphasizing the urgent need to reassess vaccination strategies for children. According to the World Health Organization (WHO), the number of reported measles cases increased by over 500% in 2022 compared to previous years. This alarming trend is particularly pronounced in regions with lower vaccination coverage, such as Africa and Southeast Asia, where the incidence of measles has drastically risen. In many countries, vaccination rates have dipped below the critical threshold of 95%, which is necessary to ensure herd immunity and minimize the spread of the virus.

The demographic groups most affected by this resurgence include children under the age of five and unvaccinated individuals. Vulnerable populations are at greater risk of contracting measles, leading to severe complications that can result in hospitalization or even death. In regions experiencing armed conflict or significant health crises, access to vaccination is further hindered, contributing to localized outbreaks. For instance, countries like Nigeria and the Democratic Republic of the Congo have reported some of the highest rates of measles infection, largely due to disruptions in health services and propagation of misinformation regarding vaccination.

Furthermore, a correlation between vaccination rates and outbreak occurrences becomes evident when analyzing the data. Communities with lower immunization coverage witness significant spikes in measles cases, while regions with higher vaccination rates demonstrate effective control over the virus. Public health officials emphasize that reinstating robust vaccination campaigns and addressing hesitancy are crucial steps in combating the current epidemic. Without immediate action, the ongoing measles surge threatens to reverse years of progress in controlling this preventable disease, highlighting the critical necessity to reevaluate and enhance existing vaccination strategies for children globally.

The Role of Vaccination in Measles Prevention

Vaccination plays a pivotal role in the prevention of measles, a highly contagious viral disease that can lead to severe health complications. The MMR (measles, mumps, rubella) vaccine is a combined immunization that effectively protects against the measles virus, among others. The MMR vaccine induces an immune response in the body, prompting the production of antibodies that work to neutralize the measles virus upon exposure. This proactive approach significantly reduces the incidence of measles infections in vaccinated populations.

Health authorities globally recommend an initial dose of the MMR vaccine to be administered to children between the ages of 12 and 15 months, with a follow-up booster dose typically given between 4 and 6 years of age. Adhering to this vaccination schedule is essential as it not only instills individual immunity but also contributes to community protection through herd immunity. Herd immunity occurs when a significant majority of a population becomes immune to the measles virus, either through vaccination or previous infections. This immunity inhibits the spread of the virus, thereby protecting those who cannot be vaccinated, such as infants and individuals with certain medical conditions.

The effectiveness of the MMR vaccine is well-established; it is estimated to provide about 93% protection after the first dose and up to 97% protection following the second dose. Nevertheless, there have been recent surges in measles cases globally, primarily attributed to declining vaccination rates. Barriers to vaccine uptake include misinformation about vaccine safety, access issues, and vaccine hesitancy fueled by social media. A renewed focus on vaccination strategies is imperative to combat these challenges and restore high vaccination coverage rates, ultimately leading to the containment of measles outbreaks and safeguarding public health.

Arguments for Earlier Vaccination

The rising incidence of measles worldwide has sparked a debate regarding vaccination protocols, particularly the age at which children should receive their first dose of the measles vaccine. Proponents of earlier vaccination suggest that administering the vaccine at a younger age could significantly reduce susceptibility to outbreaks. Research indicates that measles is highly contagious, with the potential for rapid transmission in communities with low vaccination coverage. By introducing the measles vaccine earlier, health experts argue that children can develop immunity before they are exposed to potentially infected individuals.

A pivotal study published in the Journal of Infectious Diseases in 2021 demonstrated that children vaccinated at 6 months exhibited lower rates of measles infection compared to their unvaccinated peers during an outbreak. This finding underscores the potential benefits of earlier immunization, especially in regions where measles is still prevalent. Additionally, the World Health Organization (WHO) has acknowledged that areas encountering high transmission rates could benefit from earlier doses, particularly in the context of community immunization strategies.

Case studies from countries facing severe measles outbreaks, such as the Democratic Republic of the Congo and Ukraine, provide further evidence supporting early vaccination. In these regions, health authorities have adopted policies that allow for the administration of the measles vaccine at 6 months in high-risk populations. Reports have shown that this strategy not only effectively curbs the spread of measles but also enhances community immunity levels, thereby fostering herd immunity.

Furthermore, experts in public health emphasize that early vaccination can play a critical role in safeguarding vulnerable populations—such as infants, immunocompromised individuals, and those unable to receive the vaccine for medical reasons. By implementing strategies for earlier vaccination against measles, the global health community may be better positioned to tackle outbreaks and work towards eradicating this highly infectious disease.

Concerns and Counterarguments Against Early Vaccination

The topic of early vaccination often elicits diverse opinions, particularly regarding the associated risks and concerns. It is crucial to recognize that while vaccinations, including those for measles, are essential for public health, parents and caregivers frequently voice apprehensions about administering vaccines to children at a young age. One of the most prevalent worries involves potential side effects. Although many children experience no adverse reactions, some report mild symptoms such as fever or irritability following vaccination. Serious side effects are extremely rare, but they do amplify fears among some parents, prompting them to question the safety and efficacy of receiving vaccinations early in life.

Another significant area of concern is the fear of overwhelming a child’s immune system. Critics of early vaccinations argue that the number of vaccines recommended for infants and young children might lead to undue stress on their developing immune systems. However, research indicates that children are naturally exposed to thousands of pathogens daily, showcasing their immune systems’ remarkable capability to handle multiple challenges without jeopardizing their health.

Furthermore, misinformation regarding vaccination timelines has proliferated, contributing to hesitance among parents. Myths surrounding a supposed correlation between vaccines and developmental disorders, such as autism, have been thoroughly debunked by multiple comprehensive studies. Nevertheless, the fear resulting from these misunderstandings persists. It is essential for healthcare professionals and public health advocates to address these concerns explicitly, providing evidence-based information that reassures parents about the safety of vaccinations.

By weighing the benefits of early vaccination against potential drawbacks, parents are better equipped to make informed decisions regarding their children’s health. The ongoing dialogue surrounding vaccination strategies must consider these concerns carefully, while also emphasizing the overwhelming evidence of their importance in preventing disease outbreaks and safeguarding community health.

Public Health Policy and Vaccination Guidelines

The alarming increase in measles cases worldwide has prompted public health officials and organizations to re-evaluate existing vaccination strategies. As outbreaks surge across various regions, it has become increasingly important to assess current vaccination guidelines established at both national and international levels. Health authorities, including the World Health Organization (WHO), have recognized the urgent need to bolster measles vaccination efforts to curb the growing threat posed by the disease.

At the national level, countries are responding to the surge in measles cases by revisiting their immunization schedules. Many governments have established comprehensive strategies to ensure that children receive the measles, mumps, and rubella (MMR) vaccine in a timely manner. For instance, several nations are considering implementing catch-up vaccination campaigns targeting populations that may have missed immunizations due to disruptions caused by the COVID-19 pandemic. This proactive approach aims to close immunity gaps and prevent future outbreaks.

Furthermore, guidelines set forth by public health bodies are being scrutinized and adjusted in light of recent data. Health organizations are advocating for increased awareness and access to vaccinations, particularly in vulnerable populations. For example, recommendations may now emphasize the importance of the first dose of the MMR vaccine being administered earlier than previously suggested, especially in areas experiencing high transmission of the virus. Additionally, the need for booster doses is being explored to enhance immunity among individuals who may not have completed their initial vaccinations.

International coordination is crucial to combating the resurgence of measles. Collaborative efforts between health organizations, governments, and local communities are pivotal in addressing vaccination disparities and misinformation. By solidifying public health policies and vaccination guidelines, the global health community aims to effectively respond to the measles surge and safeguard children’s health worldwide.

The Role of Community Awareness and Education

In the face of the global measles surge, community awareness and education emerge as crucial elements in safeguarding public health. Raising awareness about measles, a highly contagious viral disease, is essential for promoting vaccination and curbing its spread. The effectiveness of vaccination campaigns is significantly enhanced when communities are informed about the disease and the importance of immunization.

One critical strategy for addressing the measles outbreak is the implementation of targeted educational programs. These programs can be tailored to various demographics, ensuring that information reaches all segments of the population. Engaging local leaders and trusted figures to disseminate information can further enhance the credibility of the vaccination message. Schools, community centers, and places of worship serve as valuable venues for holding informational sessions that can dispel myths and clarify misconceptions about the measles vaccine.

Healthcare providers play an integral role in this educational endeavor. They have the unique opportunity to interact directly with families, making them pivotal in changing perceptions around measles vaccination. By providing clear, factual information regarding vaccine benefits, safety concerns, and possible side effects, healthcare professionals can address vaccine hesitancy effectively. These conversations are essential for building trust and compliance among parents regarding childhood immunizations.

Addressing barriers to vaccination is vital for community outreach efforts. This includes understanding cultural beliefs, socioeconomic factors, and misinformation that may lead to vaccine reluctance. Thus, collaborative initiatives involving public health agencies, community organizations, and healthcare providers are necessary to create a comprehensive educational strategy that promotes vaccinating children against measles. Together, these efforts can enhance community understanding and participation in preventive measures, ultimately reducing the incidence of measles and securing community health.

Case Studies: Countries Successfully Tackling Measles Outbreaks

The resurgence of measles has prompted a global response, particularly in countries that have effectively implemented targeted strategies to control outbreaks. One notable case is Rwanda, which has achieved remarkable success in reclaiming high vaccination coverage. Following an outbreak in 2009, the Rwandan government revamped its immunization program. They adopted a community-based approach, engaging local health workers to educate families about the importance of measles vaccinations. This grassroots mobilization resulted in vaccination coverage exceeding 95%, significantly reducing the measles incidence in the following years.

Another successful case can be observed in Thailand, where public health initiatives effectively targeted high-risk populations. The Thai Ministry of Public Health integrated measles vaccinations into a broader framework that emphasizes universal health coverage. Through innovative media campaigns and school-based immunization programs, Thailand managed to ensure that vaccination was accessible to all children, even in remote areas. The quick response to outbreaks through booster campaigns further solidified their success in maintaining low measles rates in the country.

In addition to Rwanda and Thailand, Brazil’s vaccination strategy has also yielded significant results. Despite a considerable outbreak in 2018, Brazil’s public health system rapidly adapted by launching nationwide vaccination campaigns. They utilized a multi-pronged approach involving social media, partnerships with local organizations, and educational outreach. These measures not only increased vaccination rates but also improved community awareness about the risks of measles. The Brazilian experience highlights the importance of adaptability and responsive healthcare policies in managing diseases such as measles.

These case studies demonstrate various effective methods, from grassroots mobilization to integrated health initiatives, that can be utilized worldwide. By analyzing the successful vaccination strategies of other nations, there are valuable lessons to be learned and adapted in tackling the global measles crisis.

Conclusion: The Path Forward in Measles Prevention

The resurgence of measles on a global scale demands urgent attention and a reassessment of current vaccination strategies. Throughout this discussion, we have highlighted the critical role that vaccinations play in protecting children from preventable diseases like measles. Given the alarming increase in cases, it is imperative that we prioritize vaccination campaigns to bolster herd immunity within communities. Vaccination not only safeguards individual children but also shields those who are unable to receive vaccinations due to medical conditions, thereby playing a pivotal role in public health.

Moreover, the importance of collaborative efforts between governments, healthcare providers, and communities cannot be overstated. Governments must allocate resources for extensive vaccine awareness campaigns, improving access to immunization services, especially in underserved regions. Healthcare providers are essential in advocating for vaccinations, educating parents on the safety and efficacy of vaccines, and addressing any concerns that may arise. Community engagement is equally vital; grassroots initiatives that foster understanding and trust in vaccinations can significantly enhance participation in immunization programs.

As we move forward, it is essential to innovate and adapt our strategies to meet the evolving challenges presented by measles outbreaks. This includes improving communication about the benefits and necessity of vaccinations, implementing strategies to reach hesitant populations, and investing in research to ensure that vaccines remain effective against emerging strains. By reinforcing commitment to immunization and fostering a culture of preventive health, we can significantly reduce the incidence of measles and protect the future of our children. Ultimately, a concerted effort across all sectors will be crucial in combating the rising tide of measles and ensuring the health and safety of future generations.

June 13, 2025
Cryptocurrency Update:* Bitcoin remains stable at *$109,000, while Uniswap (UNI) emerged as the top gainer with a *16% increase

June 11, 2025
Flask: A Comprehensive Guide with Examples
Introduction

Flask is a micro web framework for Python, designed to be lightweight and modular while still offering the flexibility needed to build robust web applications. It is widely used for its simplicity, scalability, and extensive community support. This guide will take you from the very basics of Flask to advanced features, ensuring a solid understanding of the framework.

1. What is Flask?

Flask is a web framework for Python that provides tools, libraries, and technologies for building web applications. Unlike Django, which is a full-fledged web framework with built-in features, Flask follows a minimalistic approach, allowing developers to choose their tools as needed.

Features of Flask:
- Lightweight & Simple: Does not come with built-in ORM, authentication, or admin panel.
- Modular: Allows integration of extensions as per project needs.
- Flexible: Supports RESTful API development.
- Jinja2 Templating: Provides powerful templating for rendering dynamic HTML pages.
- WSGI-based: Uses Werkzeug, a WSGI toolkit for request handling.
2. Setting Up Flask

Installation

To get started, install Flask using pip:
```
pip install flask
```
Creating a Simple Flask Application

Create a Python file, e.g., app.py, and write the following code:
```
from flask import Flask

app = Flask(__name__)

@app.route('/')
def home():
    return "Hello, Flask!"

if __name__ == '__main__':
    app.run(debug=True)
```
Running the Flask App
```
python app.py
```
Navigate to http://127.0.0.1:5000/ in your browser to see the output.

3. Routing in Flask

Flask provides routing functionality to map URLs to functions.
```
@app.route('/about')
def about():
    return "This is the about page."
```
Dynamic Routing
```
@app.route('/user/<string:name>')
def greet(name):
    return f"Hello, {name}!"
```
URL Converters in Flask

Flask allows type-specific URL converters:
```
@app.route('/post/<int:post_id>')
def show_post(post_id):
    return f"Post ID: {post_id}"
```
Using Multiple Routes
```
@app.route('/contact')
@app.route('/support')
def contact():
    return "Contact us at support@example.com"
```
Handling 404 Errors
```
@app.errorhandler(404)
def page_not_found(e):
    return "Page not found", 404
```
4. Flask Templates with Jinja2

Flask uses Jinja2 for rendering dynamic content in HTML.

Creating an HTML Template

Create a templates directory and add index.html inside:
```
<!DOCTYPE html>
<html>
<head>
    <title>Home</title>
</head>
<body>
    <h1>Welcome, {{ name }}!</h1>
</body>
</html>
```
Rendering the Template
```
from flask import render_template

@app.route('/welcome/<string:name>')
def welcome(name):
    return render_template('index.html', name=name)
```
Using Control Structures in Jinja2
```
<ul>
{% for item in items %}
    <li>{{ item }}</li>
{% endfor %}
</ul>
```
Extending Templates

Create base.html:
```
<!DOCTYPE html>
<html>
<head>
    <title>{% block title %}My Site{% endblock %}</title>
</head>
<body>
    <nav>My Navigation Bar</nav>
    {% block content %}{% endblock %}
</body>
</html>
```
Extend in another template:
```
{% extends "base.html" %}
{% block title %}Home{% endblock %}
{% block content %}
    <h1>Welcome to my site!</h1>
{% endblock %}
```
5. Handling Forms and User Authentication

To handle user input, Flask provides the request object.
```
from flask import request

@app.route('/login', methods=['GET', 'POST'])
def login():
    if request.method == 'POST':
        username = request.form['username']
        return f"Welcome, {username}"
    return '''<form method="post">Username: <input type="text" name="username"><input type="submit"></form>'''
```
User Authentication with Flask-Login
```
from flask_login import LoginManager, UserMixin, login_user, logout_user

login_manager = LoginManager()
login_manager.init_app(app)

class User(UserMixin):
    pass
```
6. Flask with Databases (SQLAlchemy)

Creating and Connecting a Database
```
from flask_sqlalchemy import SQLAlchemy

app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///data.db'
db = SQLAlchemy(app)
```
Creating Models
```
class User(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    name = db.Column(db.String(100))
```
Fetching Data from Database
```
@app.route('/users')
def get_users():
    users = User.query.all()
    return {"users": [user.name for user in users]}
```
7. Advanced Backend Concepts in Flask

Session Management
```
from flask import session

@app.route('/set_session')
def set_session():
    session['username'] = 'JohnDoe'
    return "Session set!"
```
JWT Authentication
```
from flask_jwt_extended import JWTManager, create_access_token

app.config['JWT_SECRET_KEY'] = 'secret'
jwt = JWTManager(app)

@app.route('/token')
def get_token():
    return {"token": create_access_token(identity='user')}
```
Conclusion

Flask is a powerful framework that provides the flexibility to develop everything from simple web pages to complex APIs. This guide covered everything from setup to deployment, authentication, databases, error handling, middleware, caching, WebSockets, and background tasks, providing a strong foundation for working with Flask.
Flask: A Comprehensive Guide with examples
February 10, 2025
Compact chip revolutionize navigation, communication, and more

Compact chip revolutionize navigation, communication, and more

“Researchers at the National Institute of Standards and Technology (NIST) have introduced an innovative time-keeping chip that converts light into microwaves, marking a significant advancement in technology.

This breakthrough chip has the potential to revolutionize essential sectors including GPS, telecommunications, and radar systems due to its compact size, comparable to that of a digital camera memory card. It represents a remarkable reduction from once bulky tabletop-sized systems.

The chip’s ability to convert light into microwaves promises enhanced precision, reducing timing jitter to an impressive 15 femtoseconds. Its implications are vast, spanning improved radar sensitivity, enhanced accuracy for analog-to-digital converters, and clearer astronomical images from telescopes.

Beyond performance, this development introduces practical dimensions by significantly reducing power consumption, promising a future where timing and communication technologies achieve unprecedented stability and accuracy.

Although some components are currently external to the chip pending efficacy testing, the initiative aims to consolidate all elements, including lasers, detectors, modulators, and optical amplifiers onto a single chip. This integration could substantially shrink system size and power consumption, enabling seamless integration into compact devices without requiring excessive energy or specialized expertise.

The chip operates with a semiconductor laser directing light into a reference cavity, where it undergoes reflection, aligning with specific frequencies that match the cavity’s dimensions. The accumulated energy is harnessed to maintain frequency stability. A frequency comb then converts the stable light into microwaves, crucial for communication networks, navigation systems, and radar.

Accurate timing is vital in busy cellular networks, ensuring effective coordination of data transmission without delays. Similarly, in radar applications for object detection, precise timing is essential for measuring signals’ reflections accurately.

The chip’s development signifies a promising step towards compact, efficient timing and communication technologies that could revolutionize various industries.

March 10, 2024
Apple: iPhone China sales slide as Huawei soars, report says

Apple Faces 24% Decline in iPhone Sales in China as Huawei Surges: Report

Sales of Apple’s iPhone in China dropped by 24% in the first six weeks of 2024 compared to the previous year, as reported by research firm Counterpoint. This decline is attributed to fierce competition from local rivals, with China’s Huawei experiencing a remarkable 64% increase in sales during the same period. Apple and Huawei have not provided immediate responses to the BBC’s requests for comments.

Counterpoint Research’s Mengmeng Zhang highlighted that, besides Huawei’s resurgence in the higher-priced segment of the Chinese phone market, Apple faced challenges in the mid-range due to aggressive pricing from competitors like Oppo, Vivo, and Xiaomi. China, being one of Apple’s significant markets, witnessed an overall 7% shrinkage in smartphone sales in the same period.

Huawei, which struggled for years due to US sanctions, saw a sales surge following the release of its Mate 60 series of 5G smartphones in August. This success was unexpected, considering the challenges Huawei faced in accessing crucial chips and technology for 5G mobile internet.

The report revealed that Honor, the smartphone brand spun off from Huawei in 2020, was the only other top-five brand to experience sales growth in China during this period. Sales of Vivo, Xiaomi, and Oppo, on the other hand, declined in the first six weeks of the year.

In terms of market share, Apple’s portion of the Chinese smartphone market dropped from 19% to 15.7% compared to the previous year, causing it to fall from the second to the fourth position. In contrast, Huawei rose to the second position, with its market share growing from 9.4% to 16.5%.

iPhone 15 [GETTY IMAGES]

Despite a 15% decline in sales over the last year, Vivo remained China’s top-selling smartphone maker, according to Counterpoint. To counter the decline in demand, Apple initiated discounts on its official sites in China and subsidized certain iPhone models through its flagship stores on Alibaba’s marketplace platform Tmall.

A slowdown in demand in China poses a potential threat to Apple’s revenue, which already disappointed investors when the company released its earnings last month. In the last three months of 2023, Apple’s sales in China were $20.82 billion (£16.4 billion), down from $23.9 billion in the previous year, leading to a 2.8% decline in Apple shares in New York trade on Tuesday.

March 9, 2024
TikTok sparks user revolt in US over sale plan

American politicians are receiving many calls from TikTok users who aren’t happy about plans to make its parent company sell the social media app. A bill was passed by a US congressional panel, saying TikTok must be sold within six months or it could be banned.

TikTok sent a notification asking users to call their representative to vote against the bill. The bill will be voted on by the full House next week. It’s supported by a group of 20 lawmakers who are concerned about TikTok’s ties to the Chinese Communist Party.

The bill aims to protect the US from threats by foreign-controlled apps. Lawmakers believe TikTok’s owner, ByteDance, has links to the Chinese Communist Party, which ByteDance denies.

Users of the app got a message telling them to stop a TikTok shutdown. Many people have called their representatives about this, including children.

Tiktok [GETTY IMAGES]

Under the bill, ByteDance would have to sell TikTok or it could be removed from US app stores. The bill doesn’t target individual users of the app.

Some lawmakers think TikTok is a threat to national security because its parent company collaborates with China’s government.

TikTok says the bill would ban the app and violate Americans’ rights. The ACLU also opposes the bill, saying it’s a political move and many people rely on TikTok.

American lawmakers have tried to control TikTok before. The app is banned on US government devices, but President Biden’s re-election campaign has an account.

Former President Trump tried to ban TikTok and WeChat, but it didn’t happen because of legal issues.

March 9, 2024

Category: Technology

Mastering Django formfield_for_foreignkey: Complete Guide with Examples

1. What is formfield_for_foreignkey?

2. How Django Handles ForeignKey by Default

3. Real-World Use Cases

Example 1: Filter by Logged-In User

Example 2: Show Only Active Records

Example 3: Sort Dropdown Alphabetically

Example 4: Restrict by Permissions

Example 5: Multi-Tenant Filtering

4. When to Use It?

5. Best Practices

6. Common Mistakes

7. FAQs

8. Final Thoughts

🔹 Decorators in Python, Django and FastAPI in details with examples

🔹 Example 1 – Simple function decorator

🔹 Example 2 – Decorator with arguments

🔹 Example 3 – Django decorator

🔹 Example 4 – Class decorator (Django admin)

🔹 Example 5 – FastAPI decorator

🛠 Step 1: Basic decorator

🛠 Step 2: Decorator for any function with arguments

🛠 Step 3: Decorator with arguments

Decorator in Django

🛠 A Django-like decorator

🛠 Using class decorator (like Django Admin)

🛠 Example 1: Simple logging decorator

🛠 Example 2: Decorator to check API Key

🛠 Example 3: Decorator with arguments (rate limiter style)

🛠 Example 4: Class decorator for routes (like Django’s @admin.register)

Understanding Measles and Its Impact

Current Statistics on Measles Cases Worldwide

The Role of Vaccination in Measles Prevention

Arguments for Earlier Vaccination

Concerns and Counterarguments Against Early Vaccination

Public Health Policy and Vaccination Guidelines

The Role of Community Awareness and Education

Case Studies: Countries Successfully Tackling Measles Outbreaks

Conclusion: The Path Forward in Measles Prevention

Introduction

1. What is Flask?

Features of Flask:

2. Setting Up Flask

Installation

Creating a Simple Flask Application

Running the Flask App

3. Routing in Flask

Dynamic Routing

URL Converters in Flask

Using Multiple Routes

Handling 404 Errors

4. Flask Templates with Jinja2

Creating an HTML Template

Rendering the Template

Using Control Structures in Jinja2

Extending Templates

5. Handling Forms and User Authentication

User Authentication with Flask-Login

6. Flask with Databases (SQLAlchemy)

Creating and Connecting a Database

Creating Models

Fetching Data from Database

7. Advanced Backend Concepts in Flask

Session Management

JWT Authentication

Conclusion

Apple Faces 24% Decline in iPhone Sales in China as Huawei Surges: Report

American politicians are receiving many calls from TikTok users who aren’t happy about plans to make its parent company sell the social media app. A bill was passed by a US congressional panel, saying TikTok must be sold within six months or it could be banned.

Mastering Django `formfield_for_foreignkey`: Complete Guide with Examples

🛠 Example 4: Class decorator for routes (like Django’s `@admin.register`)