DEV Community: Arjun Adhikari

Lost in a Forest of Tabs? Here’s Your Friendly Guide Out!

Arjun Adhikari — Thu, 29 May 2025 14:41:41 +0000

Picture this: you’re on your computer, looking up something really interesting. Maybe you're learning about dinosaurs, planning a trip, or trying to fix something around the house. You open one internet page, then another, then another. Soon, the top of your screen is packed with so many little tabs, it looks like a crowded bus!

You find a great picture on one tab, an important fact on another, and a cool video on a third. Then, the phone rings, or someone calls your name. You step away for a bit.

When you come back, you stare at the screen. Oh no! Which tab had that amazing dinosaur picture? Where was that important fact? It’s all a muddle. You click one tab, then another, feeling a bit grumpy and lost. It’s like trying to find your favorite toy in a messy room.

If this sounds like you, don’t worry! So many of us feel this way. But what if there was a magic button to tidy up all those tabs for you?

Meet Your New Helper: The Tab Sorter!

There's a super simple tool for your Chrome internet browser called Tab Sorter. Think of it as a helpful little robot that lives in your computer. Its main job is to neatly line up all your open tabs, like books on a shelf.

And the best part? It does this with just one click!

Why This Little Helper is a Big Deal

When you have too many tabs open, it’s not just messy; it can make your brain feel tired. It’s hard to focus when you’re always hunting for the right page. Tab Sorter helps to:

See Clearly: Suddenly, all your tabs are lined up by their website names (like all the "https://www.google.com/search?q=google.com" pages together, all the "youtube.com" pages together). It’s like sorting your crayons by color!
Find Things Fast: Need to get back to that recipe on "https://www.google.com/search?q=supercookingsite.com"? Now you can spot it much quicker.
Stay on Your Page: When you click the sort button, you won’t suddenly jump to a different page. You’ll stay right where you were, but everything else will be neatly organized.
Feel Calm: A tidy screen means a calmer mind. You can get back to your fun research or important work without the "where did it go?!" frustration.

It’s like having a friend who quickly straightens up your desk while you’re still working, so you can find everything easily.

How to Welcome Tab Sorter to Your Chrome (It’s Like a Mini Treasure Hunt!)

Getting this helper is easy. You just need to tell Chrome it’s okay to use tools that aren't from its main store, using something called "Developer Mode." It sounds fancy, but it's just like flipping a special switch.

Get the Tool's Files: First, you need to download the Tab Sorter files. You can find them on a website called GitHub (ask a grown-up or a tech-savvy friend if you need help finding the "Download ZIP" button for "theArjun/tab-sorter"). Once downloaded, you’ll have a zipped folder. You need to "unzip" it (most computers can do this by right-clicking the folder and choosing "Extract All" or "Unzip"). Remember where you save the unzipped folder!
Open Chrome's Special Page: In Chrome, type this into the address bar at the top (where you type website names): chrome://extensions/ and press Enter.
Flip the Special Switch: On this new page, look for a switch that says "Developer mode." It’s usually in a corner. Click it to turn it ON. Some new buttons will appear.
Tell Chrome Where Your Tool Is: Click the button that says "Load unpacked." A window will pop up, asking you to find the tool’s files.
Show Chrome the Folder: Find the Tab Sorter folder you unzipped earlier (the one with files like manifest.json inside) and select it. Click "Open" or "Select Folder."
All Set! You should now see the Tab Sorter icon (it might be a simple square or puzzle piece at first) in your Chrome toolbar, usually near the top right. It's ready to help!

(The person who made this tool says you might need to add your own pictures for the icon if you want it to look a certain way. These would be tiny picture files named icon16.png, icon32.png, and so on, placed in an "icons" folder inside the Tab Sorter folder.)

Using Your New Tab Helper: Easy Peasy!

This is the simplest part of the story:

Are your tabs looking like a wild jungle?
Just click the Tab Sorter icon in your Chrome toolbar.
Poof! Like magic, all your tabs in that window will line up neatly, from A to Z based on their website address. You’ll still be looking at the same page you were on, but now everything is tidy!

What Makes it Work? (The Simple Version)

Inside that folder you downloaded, there are a few instruction files. One called manifest.json is like a label that tells Chrome what the tool is. Another, background.js, has the main instructions that tell Chrome how to sort your tabs. It also needs permission to look at your tabs so it can sort them, which is perfectly normal for a tab helper.

No More Tab Troubles!

Imagine going back to your computer after a break. Instead of a confusing jumble, you see all your tabs neatly arranged. You easily spot the dinosaur page, the important fact, and the cool video. You smile, take a deep breath, and dive back into your exciting discoveries, feeling clear and calm.

That's what Tab Sorter can do for you. It’s a small change that makes a big difference, especially when you're trying to learn, explore, or create. Give it a try, and say goodbye to that lost-in-a-forest-of-tabs feeling!

The 5 Levels of Machine Learning Projects: From Kaggle to Cutting-Edge AI

Arjun Adhikari — Tue, 27 May 2025 02:57:06 +0000

Have you ever wondered what truly distinguishes an entry-level machine learning project from the sophisticated AI systems powering tech giants like Google and Amazon? The gap might seem immense, but there's a clear, progressive path that most successful ML practitioners follow.

This guide maps out the five distinct levels of machine learning projects, showing you exactly where you stand on this journey and the specific skills you need to advance. Understanding these levels is crucial, as many aspiring machine learning engineers get stuck building the wrong types of projects that never lead to their desired roles. We'll also cover what level of project is expected for various positions, from entry-level to research-focused roles at leading AI companies.

Level 1: The Jupyter Notebook Explorer

Every machine learning journey begins here. At Level 1, you're working with clean, structured datasets primarily within a Jupyter notebook on your local machine.

What you're doing:

Downloading pre-cleaned datasets from platforms like Kaggle.
Using libraries such as Pandas for data manipulation, and Matplotlib, Seaborn, or Plotly for visualizations.
Experimenting with Scikit-learn to train basic models like linear or logistic regression.

A typical project: You load a CSV into a DataFrame, perform exploratory data analysis with simple visualizations, handle missing values by dropping or filling them, encode categorical features using one-hot encoding, train a model with default hyperparameters, and evaluate with basic metrics like accuracy.

This environment is perfect for learning and getting immediate feedback. However, these pristine Kaggle datasets rarely mirror the messy realities of real-world data. You're not yet considering issues like data leakage, sophisticated imputation, or scalability. When you start feeling limited by these boundaries, it's time to move up.

Level 2: Structured Data Science Projects

At Level 2, things get more interesting and challenging. You're now working with messier, more realistic data and structuring your projects like a professional data scientist, moving beyond isolated notebook experiments.

Your evolving workflow and tools:

Organized Python projects: You transition from a single notebook to separate modules for data processing, feature engineering, model training, and evaluation.
Version control: You use Git to track changes and collaborate.
Reproducibility: Configuration files help ensure your experiments can be replicated.
Robust validation: Instead of random shuffling, you use proper train-validation-test splits, often with techniques like walk-forward validation for time series data.
Addressing data issues: You tackle challenges like class imbalance using techniques like SMOTE or adjusting class weights.
Advanced models: You might use LightGBM, simple neural networks, or even integrate AI APIs.
Hyperparameter tuning: You start thinking about and experimenting with advanced options like Bayesian search.
Basic pipelines: You might begin using tools like Prefect to build simple data pipelines.

An example project: Building a customer churn prediction pipeline that uses data from multiple sources (transaction records, support interactions, usage logs). This involves handling imbalanced classes, performing feature selection, and evaluating the model using precision-recall curves, ROC curves, and business-specific metrics.

At this stage, your work becomes more structured and robust. But when asked, "When can we use this model in production?" you realize there's a whole new set of challenges awaiting you. This leads to Level 3.

Level 3: Machine Learning in Production

Level 3 marks the shift from pure data science to machine learning engineering, where your models must work in production, serve real users, and drive business outcomes.

New tools and practices:

Containerization: You use Docker to package your models, ensuring consistency between development and production environments.
API development: You create APIs with FastAPI or Flask to serve predictions, or explore frameworks like BentoML for simplification.
Load testing: Setting up tests to ensure your system can handle real-world traffic.
Monitoring: Deploying logging and dashboards using tools like Grafana to track system performance.
Versioning: Using tools like DVC, MLflow, and model registries for versioning both data and models.

An example project: A content recommendation engine for a small media platform. The model is packaged in a Docker container and deployed as a microservice, offering both batch predictions and a real-time API. You track metrics like click-through rates, latency percentiles, and monitor for feature distribution shifts. You also implement shadow deployments or circuit breakers to ensure system resilience.

At this level, the focus expands beyond just accuracy to include inference latency, throughput, and reliability. As your system scales, you'll inevitably face the challenges that push you to Level 4.

Level 4: Scalable ML Systems & MLOps

Level 4 is about building robust, scalable machine learning systems that can thrive in complex, ever-changing environments. You're dealing with industrial-scale challenges and implementing sophisticated solutions.

Advanced infrastructure and tooling:

Cloud platforms: Leveraging services like AWS SageMaker, Google Vertex AI, or Azure ML for deployment and scaling.
Orchestration: Using Kubernetes and workflow tools like Airflow or Prefect for managing complex pipelines.
Deep learning frameworks: Employing PyTorch or TensorFlow for custom model development.
Model optimization: Using methods like quantization, knowledge distillation, and LoRA for efficiently fine-tuning large models.
Experiment tracking: Advanced hyperparameter optimization with tools like Weights & Biases or MLflow.
Advanced AI models: Incorporating techniques like Retrieval Augmented Generation (RAG), prompt tuning, in-context learning, and Mixture of Experts models.
Distributed training: Training models across GPU clusters using techniques like pipeline parallelism.
Feature stores: Implementing feature stores and automated retraining pipelines triggered by data drift.
Comprehensive monitoring: Developing robust AB testing frameworks.

An example project: Developing a real-time fraud detection system for a global financial institution. This involves utilizing advanced anomaly detection algorithms and ensemble methods, deploying on a cloud platform with autoscaling, and implementing comprehensive monitoring and alerting mechanisms to detect system anomalies, model drift, and ensure regulatory compliance.

At this level, you're balancing innovative research techniques with practical production constraints, creating systems that are both cutting-edge and reliable. This naturally sets the stage for pushing into research-level innovation, which is Level 5.

Level 5: Frontier Machine Learning Systems

Level 5 takes us to the absolute cutting edge of the field, where you are actively defining the future of AI. This isn't just about applying existing solutions; it's about inventing brand-new approaches.

What you're exploring:

Custom neural network architectures and self-supervised learning systems leveraging vast amounts of unlabeled data.
Novel applications of reinforcement learning.
Development of hybrid models combining symbolic reasoning with neural networks.
Designing custom hardware accelerators to optimize performance.

An example project: Building an autonomous scientific discovery system that leverages Retrieval Augmented Generation with neuro-symbolic reasoning to form and test hypotheses in molecular biology. This system might use a large language model fine-tuned on biomedical literature for hypothesis generation, employ symbolic logic modules for experiment design, integrate a reinforcement learning agent to simulate outcomes, and collaborate with human researchers by suggesting novel gene interactions.

These frontier projects are often experimental, pushing theoretical boundaries while hinting at the transformative potential of AI.

What Level Project Do You Need for a Job?

The honest answer is, it depends on the role!

Entry-Level Data Science Positions: Aim for solid Level 2 projects. Employers want to see you go beyond tutorial notebooks. Your GitHub should showcase projects where you've handled messy real-world data, applied proper validation techniques, and documented your process clearly. Proficiency with Pandas, Scikit-learn, and visualization libraries on a self-motivated, end-to-end problem is essential.
Mid-Level Data Scientist or Entry-Level Machine Learning Engineer Roles: Level 3 projects are table stakes. Employers expect an understanding of deploying models in production environments. Projects should demonstrate containerization with Docker, API development, and monitoring systems. Experience with CI/CD and version control for both code and data is a significant plus.
Senior Roles or MLOps/ML Platform Engineer Positions: Level 4 projects are critical. You need to prove you can build and maintain complex ML systems at scale using cloud platforms, orchestration tools, feature stores, and automated retraining pipelines. Demonstrating how you handle distribution shifts, implement sophisticated monitoring, or design A/B testing frameworks will be required.
Research-Focused Roles at AI-First Companies: Level 5 capabilities are expected. Publications at conferences and projects that push the boundaries of model architecture or training methodology are highly valued.

It's important to remember that you don't need to hit the highest level to have a rewarding career in machine learning. The vast majority of ML jobs in the industry fall between Level 3 and Level 4. One comprehensive Level 3 project that solves a real problem end-to-end is often worth more than a dozen hastily implemented Level 1 notebooks.

Your Machine Learning Journey

This progression highlights the evolution of machine learning projects from simple notebook experiments to frontier systems that push the boundaries of what's possible. Each level builds on the skills from the previous one. You don't need to jump straight to Level 5; start where you're comfortable, master those skills, and move up when you're ready.

What level do you feel like you're currently working at, and what challenges are you facing? Share your thoughts in the comments below!

Supercharge Your Python Types with Annotated

Arjun Adhikari — Mon, 19 May 2025 10:15:34 +0000

Imagine you're labeling boxes. You might label a box "Kitchen Utensils." That's a basic type hint. But what if you also want to add a sticky note saying, "Fragile" or "Open First"? That’s where typing.Annotated comes in. It lets you add extra information, or metadata, to your type hints without changing the fundamental type itself.

Why Bother with Extra Info?

Standard type hints (like user_id: int) are great for telling Python "this should be an integer." But often, you have more to say:

"This integer must be positive."
"This string should be a valid email address."
"This function parameter is coming from a web request's query string."

Annotated provides a neat, built-in way to attach these extra details right where you define the type.

Let's See It in Action: The Basics

First, you'll need to be on Python 3.9 or newer (or use from typing_extensions import Annotated for older versions).

The syntax looks like this: Annotated[TheActualType, Metadata1, Metadata2, ...].

from typing import Annotated, get_type_hints

# A simple variable with an annotation
user_pin_code: Annotated[int, "Must be a 4-digit positive number"] = 1234

# A function parameter with an annotation
def process_order(order_id: Annotated[str, "Internal order tracking ID, UUID format preferred"]):
    print(f"Processing order with ID: {order_id}")
    # ... actual processing logic ...

process_order("abc-123-def-456")

# How tools *could* see this metadata (you usually don't do this manually)
class Customer:
    email: Annotated[str, "Primary contact email, must be validated"]
    loyalty_points: Annotated[int, "Cannot be negative"]

# Let's peek at the annotations for the Customer class
customer_hints = get_type_hints(Customer, include_extras=True)
for field_name, hint in customer_hints.items():
    print(f"\nField: {field_name}")
    print(f"  Full Hint: {hint}")
    # The 'include_extras=True' gives us access to __metadata__
    if hasattr(hint, '__metadata__'):
        print(f"  Extra Info (Metadata): {hint.__metadata__}")

In this snippet, Annotated[int, "Must be a 4-digit positive number"] tells us user_pin_code is an integer, but also carries the string "Must be a 4-digit positive number" as extra info. For Python itself and standard type checkers (like MyPy), user_pin_code is still just an int. The magic happens when other libraries or tools are designed to read and use this metadata.

Making Annotated Shine: With Libraries like Pydantic and FastAPI

This is where Annotated truly comes alive. Libraries like Pydantic (for data validation) and FastAPI (for building web APIs) use it extensively.

Example 1: Pydantic for Smarter Data Classes

Pydantic lets you define data structures with validation. Annotated makes this super clean.

from typing import Annotated
from pydantic import BaseModel, Field, ValidationError

class ProductReview(BaseModel):
    rating: Annotated[int, Field(gt=0, le=5, description="Star rating from 1 to 5")]
    comment: Annotated[str | None, Field(default=None, max_length=500, description="Optional user comment")]
    reviewer_id: Annotated[str, Field(description="Unique ID of the reviewer")]

# Let's try creating a review
try:
    good_review = ProductReview(rating=5, reviewer_id="user123", comment="Loved it!")
    print(f"\nValid Review: {good_review.model_dump_json(indent=2)}")

    # This one will fail validation
    bad_review = ProductReview(rating=7, reviewer_id="user456") # rating > 5
    print(bad_review)
except ValidationError as e:
    print(f"\nOops, something's wrong with the review data:\n{e}")

Here, Field(gt=0, le=5) isn't changing rating from an int. It's metadata Pydantic uses to say "this integer must be greater than 0 and less than or equal to 5." This is much clearer than some older ways of doing things!

Example 2: FastAPI for Robust Web APIs

FastAPI uses Annotated to define details about your API parameters – whether they come from the path, query string, request body, etc., along with validation.

from typing import Annotated
from fastapi import FastAPI, Query, Path # Body, Depends could also be used
# (Assuming Pydantic BaseModel from previous example if we need request bodies)

app = FastAPI()

@app.get("/items/{item_id}")
async def read_item(
    item_id: Annotated[int, Path(title="The ID of the item to get", ge=1)],
    short_description: Annotated[str | None, Query(default=None, max_length=50)] = None,
):
    """
    Fetches an item by its ID.
    Optionally, a short_description can be queried.
    """
    item_data = {"item_id": item_id, "name": f"Sample Item {item_id}"}
    if short_description:
        item_data["description_snippet"] = short_description
    return item_data

# To run this: save as myapi.py, then run: uvicorn myapi:app --reload
# Then open your browser to http://127.0.0.1:8000/items/42?short_description=cool
# Or check out the auto-docs at http://127.0.0.1:8000/docs

Here, Annotated[int, Path(...)] tells FastAPI that item_id is part of the URL path, is an integer, and must be greater than or equal to 1. Annotated[str | None, Query(...)] says short_description is an optional string from the query parameters with a max length.

So, Annotated is like giving your type hints superpowers, making your intentions clearer and enabling powerful library integrations.

LangGraph: Managing Information Flow Like a Champ (The "Reducer" Way)

Now, let's switch gears to LangGraph. It's a library for building complex applications, often involving multiple steps and AI models (think "agents"). One of its clever aspects is how it manages the information, or "state," that flows through your application.

The Challenge: Keeping Everyone on the Same Page

In a multi-step process, each step might produce some information or need information from previous steps. How do you keep track of all this evolving data in an organized way? LangGraph uses a central "state object."

LangGraph's State: Your Central Hub

Think of the LangGraph state as a shared whiteboard. Every step (or "node") in your process can read from this whiteboard and then propose an update to it.

What's a "Reducer" Got to Do With It?

If you've ever worked with state management in web development (like Redux) or some functional programming patterns, the term "reducer" might ring a bell. A reducer is essentially a function that takes the current state and some new information, and produces a new state.

It's like a recipe:

Current state = What's already in your mixing bowl.
New information = The next ingredient you're adding.
Reducer = The instruction for how to combine them (e.g., "stir in," "fold gently," "add to list").
New state = The updated contents of your mixing bowl.

LangGraph uses this idea to manage its state updates.

How Nodes Update the State in LangGraph

A node (a function in your graph) gets the current state.
It does its job (calls an AI, runs a tool, etc.).
It then returns a dictionary indicating which parts of the state it wants to update and with what new values. It doesn't change the state directly.

The "Reducer" Magic in LangGraph

When you define your state in LangGraph (often as a special kind of Python dictionary called a TypedDict), you can specify how updates to each piece of information (each key in your state dictionary) should be handled.

Default: Just Replace It: If you don't specify anything special, a new value from a node will simply overwrite the old value for that key in the state.
Be Specific: Use a Reducer Function! For more complex updates, you define a reducer. For example, if a key in your state holds a list of messages (like in a chatbot), you don't want a new message to replace the whole list. You want to add it to the existing list.

Example: Building Up a List of Actions (Reducer Style)

Let's say our LangGraph state needs to keep a list of actions an agent has taken.

from typing import TypedDict, Annotated, List
import operator # We'll use operator.add for list concatenation

# 1. Define our State with a reducer for 'action_history'
class AgentWorkflowState(TypedDict):
    current_task: str
    # When a node returns an update for 'action_history',
    # the new list items will be appended to the existing list.
    action_history: Annotated[List[str], operator.add]
    final_summary: str | None # Default: an update will overwrite

# (Imagine this is part of a LangGraph StateGraph setup)
# graph_builder = StateGraph(AgentWorkflowState)
# ... add nodes and edges ...

# 2. A node that performs an action and updates the history
def perform_research_node(state: AgentWorkflowState) -> dict:
    task = state['current_task']
    print(f"Node: Performing research for task: {task}")

    # Simulate research and identify actions taken
    action1 = f"Looked up '{task}' on web."
    action2 = f"Summarized top 3 results for '{task}'."

    # This node returns *only the changes* it wants to make to the state.
    return {
        "action_history": [action1, action2], # These will be appended
        "current_task": f"Next step for {task}" # This will overwrite
    }

# 3. Another node might add more to the history
def generate_report_node(state: AgentWorkflowState) -> dict:
    actions_so_far = state['action_history']
    print(f"Node: Generating report based on {len(actions_so_far)} actions.")

    report_action = "Compiled all findings into a draft report."
    summary = f"Report generated based on task: {state['current_task']} and actions: {'; '.join(actions_so_far + [report_action])}"

    return {
        "action_history": [report_action], # This will also be appended
        "final_summary": summary # This will overwrite
    }

# --- How LangGraph might use this (simplified) ---
# Initial state
current_state_values = {
    "current_task": "Impact of AI on climate change",
    "action_history": ["Task initiated"], # Start with an initial history item
    "final_summary": None
}
print(f"Initial State: {current_state_values}")

# Simulate running the first node
updates_from_research = perform_research_node(current_state_values)

# LangGraph applies updates using reducers
# For 'action_history', it uses operator.add (current_history + new_items)
current_state_values["action_history"] = operator.add(current_state_values["action_history"], updates_from_research.get("action_history", []))
current_state_values["current_task"] = updates_from_research.get("current_task", current_state_values["current_task"])
print(f"\nState after research: {current_state_values}")

# Simulate running the second node
updates_from_report = generate_report_node(current_state_values)
current_state_values["action_history"] = operator.add(current_state_values["action_history"], updates_from_report.get("action_history", []))
current_state_values["final_summary"] = updates_from_report.get("final_summary", current_state_values["final_summary"])
print(f"\nState after report: {current_state_values}")

In this LangGraph scenario:

We defined action_history: Annotated[List[str], operator.add]. The operator.add (which works for concatenating lists) is the reducer function.
When perform_research_node returns {"action_history": [action1, action2]}, LangGraph doesn't just replace the old action_history. It takes the current action_history, takes the new list [action1, action2], and uses operator.add to combine them.
This is super handy because if multiple parts of your graph contribute to the same list or need to modify a value in a cumulative way, reducers handle this merge logic cleanly and predictably. LangGraph even has a built-in add_messages reducer specifically for managing lists of chat messages, which is a common use case.

So, when you see state updates in LangGraph, especially with Annotated in the state definition, think "reducer"! It's how LangGraph ensures that information from different parts of your application comes together in a controlled and predictable way.

Wrapping Up

Both typing.Annotated and LangGraph's reducer-like state management are about making your Python code more expressive, robust, and easier to reason about.

Annotated lets you embed rich, contextual information directly into your type hints, which libraries can then use for things like validation, serialization, or API documentation.
LangGraph’s approach to state updates, using node outputs and defined reducers for state keys, ensures that complex flows of information are handled gracefully and predictably.

By understanding these patterns, you can build more sophisticated and maintainable Python applications. Give them a try in your next project!

Django Models Anti Patterns

Arjun Adhikari — Sat, 15 May 2021 08:17:44 +0000

Hello pals,

While working with Django, we all write code that does the job, but some code may be performing excessive computations or operations that we are unaware of. These operations may be ineffective and/or counterproductive in practice.

Here, I am going to mention some anti-patterns in Django models.

A. Using len(queryset) instead of queryset.count()

The queryset in Django are lazily evaluated which means that records in database aren't read from database until we interact with the data.
len(queryset) performs the count of database records by Python interpreter in application level. For doing so, all the records should be fetched from the database at first, which is computationally heavy operation.

Whereas, queryset.count() calculates the count at the database level and just returns the count.

For a model Post :

from django.db import models

class Post(models.Model):
    author = models.CharField(max_length=100)
    title = models.CharField(max_length=200)
    content = models.TextField()

If we use len(queryset), it handles the calculation like SELECT * FROM post which returns a list of records (queryset) and then python interpreter calculates the length of queryset which is similar to list data structure. Imagine the waste in downloading many records only to check the length and throw them away at the end! But, if we need the records after reading the length, then len(queryset) can be valid.

If we use queryset.count(), it handles the calculation like SELECT COUNT(*) FROM post at database level. It makes the code execution quicker and improves database performance.

B. Using queryset.count() instead of queryset.exists()

While we kept praising the use of queryset.count() to check the length of a queryset, using it may be performance heavy if we want to check the existence of the queryset. For the same model Post, when we want to check if there are any post written by author Arjun, we may do something like:

posts_by_arjun: Queryset = Post.objects.filter(author__iexact='Arjun')

if posts_by_arjun.count() > 0:
    print('Arjun writes posts here.')
else:
    print('Arjun doesnt write posts here.)

The posts_by_arjun.count() performs an SQL operation that scans every row in a database table. But, if we are just interested in If Arjun writes posts here or not ? then, more efficient code will be:

posts_by_arjun: Queryset = Post.objects.filter(author__iexact='Arjun')

if posts_by_arjun.exists():
    print('Arjun writes posts here.')
else:
    print('Arjun doesnt write posts here.)

posts_by_arjun.exists() returns a bool expression that finds out if at least one result exists or not. It simply reads a single record in the most optimized way (removing ordering, clearing any user-defined select_related() or distinct() methods.)

Also, checking existence / truthiness of queryset like this is inefficient.

posts_by_arjun: Queryset = Post.objects.filter(author__iexact='Arjun')

if posts_by_arjun:
    print('Arjun writes posts here.')
else:
    print('Arjun doesnt write posts here.)

This does the fine job in checking if there are any posts by Arjun or not but is computationally heavy for larger no of records. Hence, use of queryset.exists() is encouraged for checking existence / truthiness of querysets.

C. Using signals excessively

Django signals are great for triggering jobs based on events. But it has some valid cases, and they shouldn't be used excessively. Think of any alternative for signals within your codebase, brainstorm on its substitution and try to place signals logic in your models itself, if possible.
They are not executed asynchronously. There is no background thread or worker to execute them. If you want some background worker to do your job for you, try using celery.
As signals are spread over separate files if you're working on a larger project, they can be harder to trace for someone who is a fresh joiner to the company and that's not great. Although, django-debug-toolbar does some help in tracing the triggered signals.

Let's create a scenario where we want to keep the record of Post writings in a separate model PostWritings.

class PostWritings(models.Model):
    author = models.CharField(max_length=100, unique=True)
    posts_written = models.PositiveIntegerField(default=0)

If we want to automatically update the PostWritings record for a use based on records created on Post model, there are ways to achieve the task with / without signals.

A. With Signals

from django.db.models.signals import post_save
from django.db.models import F
from django.dispatch import receiver
from .models import Post

@receiver(sender=Post, post_save)
def post_writing_handler(sender, instance, created, **kwargs):
if created:
    writing, created = PostWritings.objects.get_or_create(author=instance.author)
    writing.update(posts_written=F('posts_written') + 1)

B. Without Signals

We need to override the save() method for Post model.

from django.db import models
from django.db.models import F

class Post(models.Model):
    author = models.CharField(max_length=100)
    title = models.CharField(max_length=200)
    content = models.TextField()

    def save(self, *args, **kwargs:
        # Overridden method.
        author = self.author
        if self.id:
            writing, created = PostWritings.objects.get_or_create(author=author)
            writing.update(posts_written=F('posts_written') + 1)
        super(Post, self).save(*args, **kwargs)

As the same job can be accomplished without signals, the code can be easily traced and prevent unnecessary event triggers.

If someone feels about not having readability on save() method here, breaking up code is always great. Let's do that.

from django.db import models
from django.db.models import F

class Post(models.Model):
    author = models.CharField(max_length=100)
    title = models.CharField(max_length=200)
    content = models.TextField()

    def _update_post_writing(self, created=False, author=None):
        if author is not None and created:
            writing, created = PostWritings.objects.get_or_create(author=author)
            writing.update(posts_written=F('posts_written') + 1)

    def save(self, *args, **kwargs:
        # Overridden method.
        author = self.author
        created = self.id is None
        super(Post, self).save(*args, **kwargs)
        self._update_post_writing(created, author)

Looks like we've learned how to mitigate some Django Model Anti Patterns. For now, thank you everyone for having me here. I'll be continuing with more stuffs about Django very soon.
You can also find me on GitHub. Till then keep coding :)

Implement Autocomplete in Django

Arjun Adhikari — Sat, 19 Dec 2020 17:49:20 +0000

Hello pals,
In this blog, I am going to guide you to implement autocomplete in Django admin interface. I chose admin interface because it provides CRUD ( CREATE-READ-UPDATE-DELETE ) view for defined models out of the box.

For implementing auto completion feature, I am going to use django-ajax-selects currently maintained by crucialfelix.

Setup

Let's start by creating a django project.
First of all, I'll create a virtual environment .venv. You can create virtual environment just by python -m venv .venv.
Let's activate the virtual environment .venv\Scripts\activate as I am currently on Windows environment.

After that, install django and django-ajax-selects using pip.

pip install django django-ajax-selects

Following installing libraries, let's create django project named autocomplete_demo_project.

django-admin startproject autocomplete_demo_project

Subsequently, Let's create a django app named blog .

python manage.py startapp blog

And register the app 'blog' and 'ajax_select' in INSTALLED_APPS inside settings.py.

# autocomplete_demo_project/settings.py
INSTALLED_APPS  = [
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
    'ajax_select', # new apps
    'blog.apps.BlogConfig',
]

Thereafter, let's define URLConfs for ajax_select so it may load the necessary javascripts, stylesheets for autocompletion.

# autocomplete_demo_project/urls.py
from django.contrib import admin
from django.urls import path, include
from django.conf import settings
from django.conf.urls.static import static
from ajax_select import urls as ajax_select_urls

urlpatterns = [
    path('ajax_select/', include(ajax_select_urls)),
    path('admin/', admin.site.urls),
] + static(settings.STATIC_URL, document_root=settings.STATIC_ROOT)

Models and Lookups

We have to start through defining models which will later be used for observing auto completion in admin panel.
Without adding any complexity, I'll just start with a single field name in Blog model.

# blog/models.py
from django.db import models
from django.utils.translation import gettext_lazy as _

class Blog(models.Model):
    name = models.CharField(_("Blog"), max_length=50)

def  __str__(self):
    return  self.name

Let's also create a lookup for the field name which fetches the most suitable result by matching the query entered while entering a record in admin panel. For doing so, let's create LookupChannel for our field name (NameLookup) in lookup.py inside blog app directory.

# blog/lookups.py
from ajax_select import register, LookupChannel

from .models import Blog

@register('names')
class  NameLookup(LookupChannel):
    model = Blog

    def  get_query(self, q, request):
        return  self.model.objects.filter(name__icontains=q).order_by('name')[:50]

    def  format_item_display(self, item):
        return  u"<span class='blog_name'>%s</span>"  % item.name

Here, we've observed two methods inside our NameLookup class. Let's dig into both of them:

get_query method takes q parameter as query which will be used to filter the record in database. Here, we've used the name__icontains approach which will filter the matched records in DB with sub string query q and return the filtered records.
We may also proceed with name__startswith approach which only tries to match the starting string with the records in DB with sub string query q and return the filtered records. But, let's just stick into one approach ( name__icontains approach) to implement the auto completion.
format_item_display methods takes each filtered records and displaysblog.name (data) which is the need in our case with proper styling. We can override the display properties to make it look better and match with our preferences.

Also notice that we've registered a lookup name names with register decorator which will later be used with form to match with required form field i.e. The form field with the property names will match with the above lookup.

ModelAdmin and Forms

Ensuing step will be to create Django forms which will be provided as property to our ModelAdmin which we'll later create in admin.py .

# blog/forms.py
from ajax_select.fields import AutoCompleteField
from django import forms

from .models import Blog

class  BlogForm(forms.ModelForm):

    name = AutoCompleteField('names')
    class  Meta:
        model = Blog
        fields = [
            'name'
        ]

It's worth noticing that the field name is an AutoCompleteField with the property names which is a lookup name we've registered in NameLookup class inside blog/lookups.py. It's how we interlink forms and lookups using django-ajax-selects.

Following this, let's create ModelAdmin inside admin.py.

# blog/admin.py
from ajax_select.admin import AjaxSelectAdmin
from django.contrib import admin

from .forms import BlogForm
from .models import Blog

@admin.register(Blog)
class  BlogAdmin(AjaxSelectAdmin):

    form = BlogForm

What we've done here is overriding the default form property provided by Django Admin and get it replaced by our BlogForm form object.

Also note that, the use of BlogForm isn't limited to ModelAdmin for auto completion. It can also be used in used defined templates by passing form inside context parameter from views.py.
For doing so,

{{ form.media }}
{{ form }}

We need to load ((form.media}} to load the necessary JS and CSS files defined by ajax_selects app.

Observation

After defining lookups, models, forms and modeladmin, now we can make migrations and run the migration files.
python manage.py makemigrations blog
Post hoc, let's run those migration files.
python manage.py migrate
Then, create a superuser for accessing admin interface,
python manage.py createsuperuser

Then, log into 127.0.0.1:8000/admin to access admin interface and navigate to Blog model.

Try adding some records and you'll notice auto completion making work easy for you.

Demo

I've added some records in my models.

Let's try to add another record to observe auto-completion.

Notice that, when I am typing A, the records with the letter A in their name appeared as dropdown so user may autocomplete the record.

Thank you for reading.

Integrate Django Jazzmin theme to Django Admin | AdminLTE Dashboard

Arjun Adhikari — Fri, 13 Nov 2020 20:15:58 +0000

Hello Geeks,
First of all, I would like to thank you for reaching here. No doubt you're gonna be a successful Django developer ahead.

Introduction
Instructions
- Setup Virtual Environment (Optional)
- Installing libraries
- Create Django Project
- Register Apps
- Create Model and ModelAdmin
- Make Migrations and Migrate Models
- Enjoy the output

Introduction

In this blog, I am guiding to integrate django-jazzmin theme to the Django project.
According to their documentation :

Django Jazzmin is intended as a drop-in app to jazz up your Django admin site, with plenty of things you can easily customise, including a built-in UI customizer.

The default admin dashboard provided by Django isn't best fitted for our need every time and we need to customize a lot to match the theme with our need. And some of us may not prefer to go with the default theme which looks like this :

For the developers who want to get the customized and better-looking admin dashboard for Django, django-jazzmin is the one which has better UI components with features like :

Drop-in admin skin, all configuration optional
Select2 drop-downs
Bootstrap 4 & AdminLTE UI components
Search bar for any given model admin
Modal windows instead of popups
Customisable side menu
Customisable top menu
Customisable user menu
Responsive
Customisable UI (via Live UI changes, or custom CSS/JS)
Based on the latest adminlte + bootstrap

which looks like this:

To achieve a good looking AdminLTE dashboard on our Django project, we need to follow a sequence of instructions.

Instructions

Navigate to your workspace:

# Terminal
# =========

$ mkdir - ~/workspace/integrate-django-jazzmin
$ cd ~/workspace/integrate-django-jazzmin

Setup Virtual Environment (Optional)

# Terminal
# =========

$ python -m virtualenv venv

created virtual environment CPython3.8.6.final.0-64 in 116ms
  creator CPython3Posix(dest=/home/ubuntu/workspace/integrate-django-jazzmin/venv, clear=False, global=False)
  seeder FromAppData(download=False, pip=bundle, setuptools=bundle, wheel=bundle, via=copy, app_data_dir=/home/ubuntu/.local/share/virtualenv)
    added seed packages: pip==20.2.4, setuptools==50.3.2, wheel==0.35.1
  activators BashActivator,CShellActivator,FishActivator,PowerShellActivator,PythonActivator,XonshActivator

This will set up a virtualenv named venv which isolates libraries and dependencies from the global installation.
Now, activate the virtual environment.

$ source venv/bin/activate

Installing libraries

Now, we are good to install the libraries we need to set up the Django project.

$ pip install django django-jazzmin

This will install the django and django-jazzmin library.

Create Django Project

It's time to create a Django project.

$ django-admin startproject dj_jazzmin_demo .

For a better demonstration of the theme, I'm going to create a Django app named blog.

$ python manage.py startapp blog

which created directory structure like this:

# Directory Structure
# ====================
.
├── blog
│   ├── admin.py
│   ├── apps.py
│   ├── __init__.py
│   ├── migrations
│   │   └── __init__.py
│   ├── models.py
│   ├── tests.py
│   └── views.py
├── dj_jazzmin_demo
│   ├── asgi.py
│   ├── __init__.py
│   ├── __pycache__
│   │   ├── __init__.cpython-36.pyc
│   │   └── settings.cpython-36.pyc
│   ├── settings.py
│   ├── urls.py
│   └── wsgi.py
└── manage.py

Register Apps

Now, let's register the blog app inside INSTALLED_APPS in settings.py.
Add blog.apps.BlogConfig after the pre-registered django apps.
Also, we are good to add our theme to the django project. For that, register jazzmin theme to INSTALLED_APPS.
But, we're registering jazzmin on the top of other pre-registered apps because we want the theme to load earlier than other apps.

# dj_jazzmin_demo/settings.py
# =============================

INSTALLED_APPS = [
    # Pre-loading Third Party apps
    'jazzmin', 

    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',

    # Local Apps
    'blog.apps.BlogConfig',

]

Create Model and ModelAdmin

Now, we have our app and theme registered in our project. Then, we can write models for the app blog.
Let's write a model named Post in models.py inside blog app.

# blog/models.py
# ================

from django.db import models
from django.utils.translation import ugettext_lazy as _

class Post(models.Model):
    '''Model definition for Post.'''

    title = models.CharField(_('Post'), max_length=50)
    content = models.TextField(_('Content'))
    is_publishable = models.BooleanField(_('Is Publishable ?'), default=False)
    created_at = models.DateTimeField(_('Created at '),auto_now_add=True)
    updated_at = models.DateTimeField(_('Updated at '),auto_now=True)

    class Meta:
        '''Meta definition for Post.'''

        verbose_name = 'Post'
        verbose_name_plural = 'Posts'

    def __str__(self):
        '''Unicode representation of Post.'''
        return self.title

For making our app accessible via the admin dashboard, we're going to register the model Post in admin.py.

# blog/admin.py
# ==============

from django.contrib import admin
from .models import Post


@admin.register(Post)
class PostAdmin(admin.ModelAdmin):
    '''Admin View for Post'''

    list_display = (
        'title',
        'is_publishable',
        'created_at',
        'updated_at',
    )
    list_filter = (
        'is_publishable',
        'created_at',
        'updated_at',
    )

Make Migrations and Migrate Models

Now, we're good to make migrations and migrate the model we created.

# Terminal
# =========

$ python manage.py makemigrations blog
Migrations for 'blog':
  blog/migrations/0001_initial.py
    - Create model Post

# Terminal
# =========

$ python manage.py migrate
Operations to perform:
  Apply all migrations: admin, auth, blog, contenttypes, sessions
Running migrations:
  Applying contenttypes.0001_initial... OK
  Applying auth.0001_initial... OK
  Applying admin.0001_initial... OK
  Applying admin.0002_logentry_remove_auto_add... OK
  Applying admin.0003_logentry_add_action_flag_choices... OK
  Applying contenttypes.0002_remove_content_type_name... OK
  Applying auth.0002_alter_permission_name_max_length... OK
  Applying auth.0003_alter_user_email_max_length... OK
  Applying auth.0004_alter_user_username_opts... OK
  Applying auth.0005_alter_user_last_login_null... OK
  Applying auth.0006_require_contenttypes_0002... OK
  Applying auth.0007_alter_validators_add_error_messages... OK
  Applying auth.0008_alter_user_username_max_length... OK
  Applying auth.0009_alter_user_last_name_max_length... OK
  Applying auth.0010_alter_group_name_max_length... OK
  Applying auth.0011_update_proxy_permissions... OK
  Applying auth.0012_alter_user_first_name_max_length... OK
  Applying blog.0001_initial... OK
  Applying sessions.0001_initial... OK

For accessing the admin panel, we need to create a superuser which has the privilege to access the admin dashboard and perform operations over there.

# Terminal
# =========

$ python manage.py createsuperuser
Username (leave blank to use 'ubuntu'): ubuntu
Email address: 
Password: 
Password (again): 
Superuser created successfully.

Enjoy the output

Finally, we've completed the procedure to create a basic Django project and integrate django-jazzmin theme.
Now, we can run our django project.

# Terminal
# =========

$ python manage.py runserver

Watching for file changes with StatReloader
Performing system checks...

System check identified no issues (0 silenced).
November 13, 2020 - 19:46:51
Django version 3.1.3, using settings 'dj_jazzmin_demo.settings'
Starting development server at http://127.0.0.1:8000/
Quit the server with CONTROL-C

We have our Django project running. To access it through a web browser, visit the URL http://127.0.0.1:8000/admin/ on a web browser. It loads to a different login interface than default login UI provided by Django.

After entering credentials, we're navigated to a jazzy looking admin interface provided by django-jazzmin.

Let's surf through beautiful interfaces provided by django-jazzmin.

Add Post UI
List Display UI
Delete Post UI
Filtering through fields

For now, we've successfully integrated django-jazzmin theme to our django_project. In the next part of the blog, we will be customizing admin dashboard through API provided by django-jazzmin.

Thanks for reading.

Download required folder only from GitHub with Subversion

Arjun Adhikari — Sun, 03 May 2020 16:51:29 +0000

Hello pals,
We all have experienced a situation where we need to download a folder from GitHub but we are forced to clone a whole bulky repository and then access the required folder. Well, no more reason to fear to worry of these situations. Through this blog tutorial I'm going to guide you to download only the required folder from GitHub without cloning the whole repository.

Navigate the repository and directory you want

First of all, navigate to the repository you want to access the folder. Here, I am taking my Machine Learning repository as example.

Then, I am navigating to the directory named data-visualization which I want to download. Then copy the URL from the browser address bar which is https://github.com/theArjun/machine-learning/tree/master/data-visualization in my case. Note this or get it stored in clipboard.

Install Subversion

I am using subversion to download the required directory. For doing so, make sure you've installed it on your system.

apt-get install subversion

Tweak URL

I hope you've noted the directory URL from GitHub or get it stored on clipboard which was https://github.com/theArjun/machine-learning/tree/master/data-visualization in my case.
Now replace the tree/master with trunk which results to https://github.com/theArjun/machine-learning/trunk/data-visualization and note it again. Good going pals, we're now at the final stage.

Download the Directory

Open the terminal and execute the following command :

svn checkout https://github.com/theArjun/machine-learning/trunk/data-visualization

The URL was the tweaked URL which I guided in Tweak URL section. The execution of command looks like following in terminal.

$ svn checkout https://github.com/theArjun/machine-learning/trunk/data-visualization

A    data-visualization/Data Generation - Classification.ipynb
A    data-visualization/Data Generation - Regression Data.ipynb
A    data-visualization/Data Normalization and Standardization.ipynb
A    data-visualization/Data Visualization - Subplots.ipynb
A    data-visualization/Exploring Sklearn Datasets.ipynb
A    data-visualization/Generating Data using Sk-Learn.ipynb
A    data-visualization/Matplotlib Basics.ipynb
A    data-visualization/Multivariate Normal Distribution  .ipynb
A    data-visualization/Normal Distribution & Histogram.ipynb
A    data-visualization/Numeric Spacing.ipynb
A    data-visualization/PyCharts, BarCharts and Legends.ipynb
A    data-visualization/Template.ipynb
A    data-visualization/Working with Pandas - MNIST Dataset.ipynb
A    data-visualization/Working with Pandas.ipynb
A    data-visualization/csv
A    data-visualization/csv/linearX.csv
A    data-visualization/csv/linearY.csv
A    data-visualization/csv/movie_data.csv
Checked out revision 103.

and a directory named data-visualization gets created on the working folder.

$ ls

data-visualization

This folder contains all the files which are on the data-visualization folder on the GitHub i.e. totally synced with the remote (GitHub).

So, no worries, create as many folders you need and download them as required without cloning whole bulky repository.
I hope you enjoyed learning a new trick. I will be back with similar tricks soon. Till then keep coding :).

Create Django App and Migrations

Arjun Adhikari — Sun, 19 Apr 2020 17:31:43 +0000

Hello pals,
I hope you're following me through the first installment of the series 'Create Django Project'. Upto then, I've created a django project named weather_project.

The typical next step is to start adding apps, which represent discrete areas of
functionality. A single Django project can support multiple apps.
So, I am creating an app inside the Django project for managing my application logic conveniently.

It may seem confusing with the project that I've created and the app I'm going to create now.
The main difference between app and project in Django is well illustrated as :

A project refers to the entire application and all its parts.
An app refers to a submodule of the project. It's self-sufficient and not intertwined with the other apps in the project such that, in theory, you could pick it up and plop it down into another project without any modification.
The main thing to keep in mind is this level of interdependence between the apps. In practice it's all one project, so there's no sense in going overboard, but keep in mind how co-dependent two apps are. If you find one app is solving two problems, split them into two apps. If you find two apps are so intertwined you could never reuse one without the other, combine them into a single app.

Now, let's create an app named weather inside the project. For creating the app, we are using startapp command .

python manage.py startapp weather

Executing the startapp command, Django will automatically create the app for us and we can visualize the directory structure which looks like:

weather
├── admin.py
├── apps.py
├── __init__.py
├── migrations
│   └── __init__.py
├── models.py
├── tests.py
└── views.py

1 directory, 7 files

Don't worry, pal. I will be guiding you through each of the files.

Each app has a __init__.py file identifying it as a Python package. There are 6 new
files created:
• admin.py is a configuration file for the built-in Django Admin app.
• apps.py is a configuration file for the app itself.
• The migrations directory stores migrations files for database changes.
• models.py is where we define our database models.
• tests.py is for our app-specific tests.
• views.py is where we handle the request/response logic for our web app.
Typically developers will also create an urls.py file within each app too for routing.

For now, we're going to add the app we created into the INSTALLED_APPS inside the settings.py.

# weather_project/settings.py
-----------------------------
INSTALLED_APPS  = [
'django.contrib.admin',
'django.contrib.auth',
'django.contrib.contenttypes',
'django.contrib.sessions',
'django.contrib.messages',
'django.contrib.staticfiles',

# Local
'weather.apps.WeatherConfig',
]

Notice that, I've separated the 'weather.apps.WeatherConfig' from the rest for the convenience. It makes easier to look after the apps we created.

After adding the app to INSTALLED_APPS, now I'm defining the database requirements. For storing the database information, we need following fields.

city_name
updated_at - You'll know why I created this field afterwards. Just stick to it.

After analysing the database requirements, let's define those fields in models.py Django ORM helps us to create the schema without writing the SQL commands. That's the power of fully featured web framework.

# weather/models.py
--------------------
from django.db import models

class  WeatherModel(models.Model):

    city_name = models.CharField(max_length=100)
    updated_at = models.DateTimeField(auto_now=True)

    def  __str__(self):
        return  self.city_name

The city_name can be maximum of 100 characters and the updated_at fields get updated to the latest timestamp when we make any update to the record afterwards. We also include a __str__ method so that the city name is appeared in the Admin Panel later.

Thenceforth, run the makemigrations to generate the DDL(Data Definition Language ) commands for your database.
Don't get intimidated by two similar words: makemigrations and migrate. The difference in simple words seems to be :
python manage.py makemigrations: Create the migrations (generate the SQL commands).
python manage.py migrate: Run the migrations (execute the SQL commands).

Always remember you're making migrations first and then running the migration.

While making the migrations:

Terminal
---------
$ python manage.py makemigrations
Migrations for 'weather':
  weather/migrations/0001_initial.py
    - Create model WeatherModel

And while running the migration,

Terminal
------------
$ python manage.py migrate
Operations to perform:
  Apply all migrations: admin, auth, contenttypes, sessions, weather
Running migrations:
  Applying weather.0001_initial... OK

Now, you've successfully created the app and migration with Django. In next installment of the series, I'll be guiding to fetch the weather data from the public API and building beautiful frontend afterwards, Till then, keep coding :)

Create Django Project

Arjun Adhikari — Sun, 19 Apr 2020 17:16:55 +0000

Hello pals,
In this blog tutorial, I am guiding you to create a Django web application from stratch.

Like every other Python Developers, we start a project by creating a virtual environment at first. A virtual environment is a tool that helps to keep dependencies required by different projects separate by creating isolated python virtual environments for them.
So, create a virtual environment on your system. If you don't have it installed, install from PyPi:

pip install virtualenv

Now, create the virtualenv like:

virtualenv VIRTUAL_ENV_NAME

Here, I'm naming it .env for sake of simplicity:

virtualenv .env

Now, activate the virtual environment you've created:

source .env/bin/activate

Now, install the Django using the pip :

pip install Django

Then, create a workspace folder to store the source code while you're writing this guide. Here, I'm creating a directory named django_workspace.

mkdir django_workspace

And change your current working directory to django_workspace.

cd django_workspace

Now, create the Django project here with the command :

django-admin startproject YOUR_PROJECT_NAME .

The main objective of the project I'm gonna create is to fetch the weather data from public API of various cities and display on web.
So, let's name it weather_project .

django-admin startproject weather_project

Django automatically generates a new project for us. We can visualize the file structure of the directory django_workspace which looks like :

django_workspace
├── manage.py
└── weather_project
    ├── asgi.py
    ├── __init__.py
    ├── settings.py
    ├── urls.py
    └── wsgi.py

We notice that, manage.py gets created at the root of the project folder. Every Django project starts with a manage.py file in its root. It's a convenience script that allows you to run administrative tasks .
Using the manage.py, I'm creating a app inside the project named weather which will contain the logic that our project carries.

The files have the following roles:
• asgi.pyis a spiritual successor to wsgi, intended to provide a standard interface between async-capable Python web servers, frameworks, and applications.
• __init__.py is a Python way to treat a directory as a package; it is empty.
• settings.py contains all the configuration for our project.
•urls.py controls the top-level URL routes.
• wsgi.py stands for web server gateway interface and helps Django serve the
eventual web pages.
• manage.py executes various Django commands such as running the local web
server or creating a new app.

Open the command prompt and run the Django Development Server using the following command:

python manage.py runserver

This may result something like this:

Watching for file changes with StatReloader
Performing system checks...

System check identified no issues (0 silenced).

You have 17 unapplied migration(s). Your project may not work properly until you apply the migrations for app(s): admin, auth, contenttypes, sessions.
Run 'python manage.py migrate' to apply them.

April 19, 2020 - 16:20:04
Django version 3.0.5, using settings 'weather_project.settings'
Starting development server at http://127.0.0.1:8000/
Quit the server with CONTROL-C.

We have a message regarding the unapplied migrations. Run migrate to sync the database with Django’s default settings and reload the local Django web server.

python manage.py migrate

and

python manage.py runserver

which results in :

Watching for file changes with StatReloader
Performing system checks...

System check identified no issues (0 silenced).
April 19, 2020 - 16:23:37
Django version 3.0.5, using settings 'weather_project.settings'
Starting development server at http://127.0.0.1:8000/
Quit the server with CONTROL-C.

We notice that the message for unapplied migrations has disappeared after running migrate.
Now, open a web browser to http://127.0.0.1:8000/ to confirm our project is successfully
installed.

Congrats, pal. You've successfully installed Django on your system.

In next tutorial, I will be guiding to create an app inside the Django Project.

Locally Host Website using Apache2 Ubuntu Server

Arjun Adhikari — Sun, 19 Apr 2020 10:17:33 +0000

Hello geeks, In this tutorial I'm guiding you how to host a simple website locally in Apache Web Server in Linux. So, let's get started.

Install Apache

First, let's install Apache from the apt repository in Linux. Enter the following command on your terminal to install the Apache web server:


 apt install apache2

After successful installation, here are some commands that may come handy while running Apache web server.

To start Apache 2, run:


 sudo service apache2 start

To restart Apache 2, run:


 sudo service apache2 restart

To stop Apache 2, run:


 sudo service apache2 stop

To gracefully reload Apache 2, run:


 sudo service apache2 reload

After starting the Apache Web Server, you may go into any browser and type http://127.0.0.1/ on Address Bar.
The resulting web page looks like:

The web page rendered is the default web page provided by the Apache itself. Now, we'll learn to replace by our website.

Create Website

For maintaining the simplicity, I'm creating a simple web project darkweb with the following file structure.



darkweb/
├── css
│   └── style.css
└── index.html

1 directory, 2 files

Inside index.html :



<!DOCTYPE  html>
<html  lang="en">
<head>
    <title>Website on Dark Web</title>
    <link  rel="stylesheet"  href="./css/style.css">
</head>
<body>
    <h1>This is my first web site on Dark Web.</h1>
</body>
</html>

And inside css/style.css:



body{
    margin: 0px;
    color: red;
    background-color: darkslateblue;
}

which results to form a webpage like :

Host Website on Apache Web Server

Going through the default configuration provided by the Apache, we're going to add website we just created to the Apache web server.

Assuming our web project name is darkweb, let's move the project to /var/www/html.


 sudo mv darkweb/ /var/www/html

Now, we've hosted our website on Apache Web Server. To access the website from the Apache, first start the Apache Web Server:


 sudo service apache2 start

And type http://127.0.0.1/darkweb/ on address bar on your browser. Now, you should see the website we just created on the browser. Here, my project name was darkweb, but the generalized URL for accessing your project is http://127.0.0.1/YOUR_PROJECT_NAME/.

After hosting on Apache, the website looks like:

I hope that now you're able to host website on Apache web server.

In next tutorial of this series, I'll be guiding you through how to install SSL certificate on Apache2 Ubuntu Server.

Till then, keep coding :)

Git 101 - Installation and First Commit

Arjun Adhikari — Sun, 02 Feb 2020 15:07:25 +0000

Imagine you people are familiar with Microsoft Office, Dropbox and Facebook. Obviously, everyone is.

Let's use those as references:

You know that button in Microsoft Word that says "Edit, Undo"? Git does that but for every change that has ever been made to a project and by any member of your team.

You know that Track Changes feature in Word with all the red and blue lines showing who changed what? Git does that and it includes comments so you can explain why things were changed.

You know how Dropbox backs up your files in the cloud, but you still have a local copy on your computer (and maybe your iPhone, too)? GitHub does that for your code.

You know how Facebook has Like buttons and threaded comments and pictures of your friends and their adventures? While non-programmers find Git to be about as exciting as a fax machine, GitHub makes the process of working with a project through Git feel like using Facebook.

Now, let's conclude this.
Git is a version control system for tracking changes in files enabling coordination with multiple people working on a project.

That's how we make software, right ? Coordinating with the people. I feel like it's useful in software development. I'll be checking it. I hope you are following me.

Installation

For Linux :

apt install git

For Mac (with brew) :

brew install git

For Windows :

Visit https://git-scm.com/download/win and download.

Usage

For the proper demonstration of the Git, I'm creating a directory (folder) named learning-git. I am assuming this folder as my project folder where I will be working on.
Now I'm opening the folder we created, on the Terminal or Command Prompt. I am assuming you're familiar with basic Terminal commands.

cd learning-git
Now we are on the folder root we just created. Let's initialize our folder as a Git Project.

git init


         arjun@techy:~/workspace/learning-git$ git init
         Initialized empty Git repository in /home/arjun/workspace/learning-git/.git/

Now I'm creating a file name hello_world.c to work on.

touch hello_world.c

This command creates a file on Linux Based systems. I am assuming you can create file on Windows OS too.

Let's write some code on the file hello_world.c we recently created.

        #include  <stdio.h>

        int main()  {
            printf("Hello, World!");
            return  0;
        }

Now, I am checking does writing some code on the file results to some changes in Git Project or not. For this, I am checking the status of the Git Project.

git status


        arjun@techy:~/workspace/learning-git$ git status
        On branch master

        No commits yet

        Untracked files:
          (use "git add <file>..." to include in what will be committed)

            hello_world.c

        nothing added to commit but untracked files present (use "git add" to track)

We can observe that Git System is labelling our file as untracked. Let's keep the file on track by adding.

git add hello_world.c

In Git, every update needs to be committed with a message. This helps us in recognizing the changes we made. So, let's commit the file with a message we added earlier.

git commit -m " This is the first program I wrote. "


        arjun@techy:~/workspace/learning-git$ git commit -m " This is the first program I wrote. "
        [master (root-commit) 170953b]  This is the first program I wrote.
        1 file changed, 6 insertions(+)
        create mode 100644 hello_world.c

Let's check the status of the project I'm working on.

git status

        arjun@techy:~/workspace/learning-git$ git status
        On branch master
        nothing to commit, working tree clean

Now I want to see what series of changes (log) I have made. Don't get intimidated, it's not mathematical log.

git log



        arjun@techy:~/workspace/learning-git$ git log
        commit 170953be4e6fb8f1acdebe6c7c0bd6b897c839ca (HEAD -> master)
        Author: thearjun <mailarjunadhikari@gmail.com>
        Date:   Sun Feb 2 20:29:56 2020 +0545

             This is the first program I wrote.

Looks like we've learned how to add files on the Git System. I am practising what I've learnt on projects. I hope you're doing the same.

I will be back with next part of the series.

You can explore more on my GitHub repository to feed your curiosity.

theArjun / cheatsheet

Contains cheatsheets and slides frequently used for development purposes.

Till then, happy coding :)