Forem: Taranjeet Singh

Behind the Scenes: How LangChain calculates OpenAI's pricing?

Taranjeet Singh — Thu, 01 Jun 2023 11:38:35 +0000

tl;dr

This post covers how LangChain calculates pricing when one uses OpenAI’s LLM.
There are two functions that help in this. The first function maintains the model cost mapping. The second function calculates the cost given a response from OpenAI’s API.
Some insights on why LangChain exists and how it is helpful for developers.

Today’s post is a dive into the source code of a popular open-source package called LangChain. It’s a framework for developing applications powered by language models.

We will cover how LangChain calculates the OpenAI cost given the response.

There is a get_openai_callback function from langchain.callbacks

This page in LangChain docs lists how it can be used

from langchain.llms import OpenAI
from langchain.callbacks import get_openai_callback

llm = OpenAI(model_name="text-davinci-002", n=2, best_of=2)

with get_openai_callback() as cb:
    result = llm("Tell me a joke")
    print(cb)


Tokens Used: 42
    Prompt Tokens: 4
    Completion Tokens: 38
Successful Requests: 1
Total Cost (USD): $0.00084

Here the model name is text-davinci-002 (LangChain team if you are reading this - doc needs an update), but the same will work with gpt-3.5-turbo or gpt-4 .

I was more interested in the source code, so I started digging into the code base. The source code for this function exists in langchain/callbacks/openai_info.py

Here is the first function defined in the file - get_openai_model_cost_per_1k_tokens. Below you can find its source code:

def get_openai_model_cost_per_1k_tokens(
    model_name: str, is_completion: bool = False
) -> float:
    model_cost_mapping = {
        "gpt-4": 0.03,
        "gpt-4-0314": 0.03,
        "gpt-4-completion": 0.06,
        "gpt-4-0314-completion": 0.06,
        "gpt-4-32k": 0.06,
        "gpt-4-32k-0314": 0.06,
        "gpt-4-32k-completion": 0.12,
        "gpt-4-32k-0314-completion": 0.12,
        "gpt-3.5-turbo": 0.002,
        "gpt-3.5-turbo-0301": 0.002,
        "text-ada-001": 0.0004,
        "ada": 0.0004,
        "text-babbage-001": 0.0005,
        "babbage": 0.0005,
        "text-curie-001": 0.002,
        "curie": 0.002,
        "text-davinci-003": 0.02,
        "text-davinci-002": 0.02,
        "code-davinci-002": 0.02,
    }

    cost = model_cost_mapping.get(
        model_name.lower()
        + ("-completion" if is_completion and model_name.startswith("gpt-4") else ""),
        None,
    )
    if cost is None:
        raise ValueError(
            f"Unknown model: {model_name}. Please provide a valid OpenAI model name."
            "Known models are: " + ", ".join(model_cost_mapping.keys())
        )

    return cost

So this is the function which is maintaining the entire cost given a model name. Let’s say OpenAI adds a new model ( gpt-5 maybe? or gpt-4-turbo), then this is the place its pricing will get stored.

Also, note that this function has a is_completion flag. This flag is used to pick the cost of completion or other models.

For ease, you can consider that the above function is maintaining a mapping of model_name and its cost per 1000 tokens, called as model_cost_mapping here onwards

model_cost_mapping = {
    "gpt-3.5-turbo": 0.002,
    "gpt-4": 0.03
}

Let’s see the other code in this file. There is a class called OpenAICallbackHandler and in it, there is a function called on_llm_end . I think that this function must be called at the end when the response from LLM is generated completely. Let’s verify this. I searched for the reference of this function and found out that on_llm_end is called in generate function in BaseLLM class defined in llms/base.py. It gets called after the response from LLM is generated.

Now, let’s dig into on_llm_end and see how it’s using the model_cost_mapping

def on_llm_end(self, response: LLMResult, **kwargs: Any) -> None:
        """Collect token usage."""
        if response.llm_output is not None:
            self.successful_requests += 1
            if "token_usage" in response.llm_output:
                token_usage = response.llm_output["token_usage"]
                if "model_name" in response.llm_output:
                    completion_cost = get_openai_model_cost_per_1k_tokens(
                        response.llm_output["model_name"], is_completion=True
                    ) * (token_usage.get("completion_tokens", 0) / 1000)
                    prompt_cost = get_openai_model_cost_per_1k_tokens(
                        response.llm_output["model_name"]
                    ) * (token_usage.get("prompt_tokens", 0) / 1000)

                    self.total_cost += prompt_cost + completion_cost

                if "total_tokens" in token_usage:
                    self.total_tokens += token_usage["total_tokens"]
                if "prompt_tokens" in token_usage:
                    self.prompt_tokens += token_usage["prompt_tokens"]
                if "completion_tokens" in token_usage:
                    self.completion_tokens += token_usage["completion_tokens"]

Let’s understand what the above function is doing. Before proceeding, let’s see how a sample response from OpenAI API looks like

>>> import openai

>>> openai.api_key = 'sk-<your key here>'
>>> response = openai.ChatCompletion.create(model="gpt-3.5-turbo", messages=[{"role":"user", "content": "hey, how are you?"}], temperature=0.7)

>>> print(response)
{
  "choices": [
    {
      "finish_reason": "stop",
      "index": 0,
      "message": {
        "content": "As an AI language model, I do not have emotions, but I'm functioning properly. How can I assist you today?",
        "role": "assistant"
      }
    }
  ],
  "created": 1685475109,
  "id": "chatcmpl-7LzMLNGeUTvJsi0eJYrdrZow0DRnU",
  "model": "gpt-3.5-turbo-0301",
  "object": "chat.completion",
  "usage": {
    "completion_tokens": 25,
    "prompt_tokens": 14,
    "total_tokens": 39
  }
}

This is interesting. In the response received from OpenAI, I am getting token details in usage key whereas in LangChain, the code is looking for token_usage.

I did a little digging here and found out that LangChain extracts the usage key only but puts it in a token_usage key in chat_models/openai.py. Here is the relevant code snippet

# langchain/chat_models/openai.py

def _create_chat_result(self, response: Mapping[str, Any]) -> ChatResult:
    generations = []
    for res in response["choices"]:
        message = _convert_dict_to_message(res["message"])
        gen = ChatGeneration(message=message)
        generations.append(gen)
    llm_output = {"token_usage": response["usage"], "model_name": self.model_name}
    return ChatResult(generations=generations, llm_output=llm_output)

An interesting piece of thought here is why LangChain does this.

LangChain does this so that it can easily maintain interoperability between various LLM providers and expose a unified interface to all the developers. This is one of the main reasons why developers love LangChain a lot.

Imagine Anthropic’s model started performing better one day than GPT-4, all you have to do is just change the provider from LangChain and everything continues to function as normal. If you are not using LangChain, then you will have to implement a lot of logic, input, and output format changes at your end, thereby increasing your work and introducing more errors in a production environment.

Coming back to the cost calculation piece now, we can see the function on_llm_end is very straightforward. It checks for relevant keys in the response and then calculates the cost using model_cost_mapping.

I am sharing a Python code snippet on the basis of the above code. This will be helpful in case you want to just use the cost calculation logic given an OpenAI response at your end.

# credits: https://github.com/hwchase17/langchain/blob/master/langchain/callbacks/openai_info.py

>>> import openai

>>> def get_openai_model_cost_table(model_name='gpt-3.5-turbo', is_completion=False):
    model_cost_mapping = {
        "gpt-4": 0.03,
        "gpt-4-0314": 0.03,
        "gpt-4-completion": 0.06,
        "gpt-4-0314-completion": 0.06,
        "gpt-4-32k": 0.06,
        "gpt-4-32k-0314": 0.06,
        "gpt-4-32k-completion": 0.12,
        "gpt-4-32k-0314-completion": 0.12,
        "gpt-3.5-turbo": 0.002,
        "gpt-3.5-turbo-0301": 0.002,
        "text-ada-001": 0.0004,
        "ada": 0.0004,
        "text-babbage-001": 0.0005,
        "babbage": 0.0005,
        "text-curie-001": 0.002,
        "curie": 0.002,
        "text-davinci-003": 0.02,
        "text-davinci-002": 0.02,
        "code-davinci-002": 0.02,
    }
    cost = model_cost_mapping.get(
        model_name.lower()
        + ("-completion" if is_completion and model_name.startswith("gpt-4") else ""),
        None,
    )
    if cost is None:
        raise ValueError(
            f"Unknown model: {model_name}. Please provide a valid OpenAI model name."
            "Known models are: " + ", ".join(model_cost_mapping.keys())
        )
    return cost


>>> def get_openai_cost(response):
    """
    Pass openai response object and get total cost.
    """
    total_cost = 0
    if "usage" in response:
        completion_cost = get_openai_model_cost_table(
            model_name=response["model"],
            is_completion=True,
        ) * (response["usage"].get("completion_tokens", 0) / 1000.0)
        prompt_cost = get_openai_model_cost_table(
            model_name=response["model"]
        ) * (response["usage"].get("prompt_tokens", 0) / 1000.0)
        total_cost = prompt_cost + completion_cost
    return total_cost



>>> openai.api_key = 'sk-<your key here>'
>>> response = openai.ChatCompletion.create(model="gpt-3.5-turbo", messages=[{"role":"user", "content": "hey, how are you?"}], temperature=0.7)

>>> print("Total cost: ", get_openai_cost(response))

If you want to read any past issues, check them out here.

If you have any feedback/issues etc, reply here or DM me on Twitter.

How to build your own OpenAI cost calculator

Taranjeet Singh — Wed, 31 May 2023 06:33:42 +0000

tl;dr

This post covers 2 network calls made on platform.openai.com
The first network call gives the subscription details and can be made using an OPENAI_API_TOKEN
The second network call gives the cost details for a particular period and can be made using an OPENAI_API_TOKEN
There is a curl call, python code, and a bonus curl call for Credit grant details (but it only works from the browser)
GitHub code

In this post, we will learn how you can build your own OpenAI cost calculator.

OpenAI Subscription Details

I discovered a subscription network call from the Network tab of Chrome Dev tools.
There is a call being made to the subscription endpoint. Here is a curl.

curl 'https://api.openai.com/dashboard/billing/subscription'
  -H 'authority: api.openai.com'
  -H 'accept: */*'
  -H 'accept-language: en-GB,en-US;q=0.9,en;q=0.8'
  -H 'authorization: Bearer sess-${SESSION_ID}'
  -H 'openai-organization: org-${ORG_ID}'
  -H 'origin: https://platform.openai.com'
  -H 'referer: https://platform.openai.com/'
  -H 'sec-fetch-dest: empty'
  -H 'sec-fetch-mode: cors'
  -H 'sec-fetch-site: same-site'
  -H 'sec-gpc: 1'
  -H 'user-agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/103.0.5060.53 Safari/537.36'
  --compressed

and here is the response from the above curl

{
  "object": "billing_subscription",
  "has_payment_method": true,
  "canceled": false,
  "canceled_at": null,
  "delinquent": null,
  "access_until": 1685249945,
  "soft_limit": 1000000,
  "hard_limit": 2000000,
  "system_hard_limit": 2000000,
  "soft_limit_usd": 100.0,
  "hard_limit_usd": 120.0,
  "system_hard_limit_usd": 120.0,
  "plan": {
    "title": "Pay-as-you-go",
    "id": "payg"
  },
  "account_name": null,
  "po_number": null,
  "billing_email": null,
  "tax_ids": null,
  "billing_address": {
    "city": "city_name",
    "line1": "address line 1",
    "line2": "address line 2",
    "state": "state",
    "country": "IN",
    "postal_code": "111111"
  },
  "business_address": null
}

Note the session sess-{session_id} in the curl call is obtained from the login call. This is a bit complicated process where in you first have to make the login call and then get the session id. Also, high chance that your login call won’t get the correct response because of the bot prevention mechanism applied.

I started playing around and the first thing that I did was replacing sess-{session_id} with my OPENAI_API_KEY. And it worked like magic!

So, here is the subscription call curl with OPENAI_API_KEY (eg: sk-)

curl 'https://api.openai.com/dashboard/billing/subscription'
  -H 'authority: api.openai.com'
  -H 'accept: */*'
  -H 'accept-language: en-GB,en-US;q=0.9,en;q=0.8'
  -H 'authorization: Bearer ${OPENAI_API_KEY}'
  -H 'openai-organization: org-${ORG_ID}'
  -H 'origin: https://platform.openai.com'
  -H 'referer: https://platform.openai.com/'
  -H 'sec-fetch-dest: empty'
  -H 'sec-fetch-mode: cors'
  -H 'sec-fetch-site: same-site'
  -H 'sec-gpc: 1'
  -H 'user-agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/103.0.5060.53 Safari/537.36'
  --compressed

The response for this curl call is the same.

The subscription call is useful to get billing limits (soft and hard), plan details, and billing account details and addresses.

Python code to get subscription details

Here is a Python function that you can call from your app. You just need to pass the OPENAI_API_TOKEN. ORG_ID is optional

import requests

def get_openai_subscription_details(api_key, org_id=None):
    '''
    Get subscription details from OpenAI
    '''
    headers = {
        'authority': 'api.openai.com',
        'accept': '*/*',
        'accept-language': 'en-GB,en-US;q=0.9,en;q=0.8',
        'authorization': f'Bearer {api_key}',
        'origin': 'https://platform.openai.com',
        'referer': 'https://platform.openai.com/',
        'sec-fetch-dest': 'empty',
        'sec-fetch-mode': 'cors',
        'sec-fetch-site': 'same-site',
        'sec-gpc': '1',
        'user-agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/103.0.5060.53 Safari/537.36',

    }
    if org_id:
        headers['openai-organization'] = f'org-{org_id}'
    response = requests.get('https://api.openai.com/dashboard/billing/subscription', headers=headers)
    return response.json()

OPENAI_API_KEY = ''     # set the one for which you want to calculate cost

print(get_openai_subscription_details(OPENAI_API_KEY))

OpenAI Cost Details

But how do I get the cost that I have spent so far?

So I went to the Usage tab, where OpenAI shows a graph and tabular view of all the API calls being made, usage, and credit details. From this tab, I discovered an usage endpoint. This is exactly what we need to build the OpenAI cost calculator.

Here is the curl call:

curl 'https://api.openai.com/dashboard/billing/usage?end_date=2023-06-01&start_date=2023-05-01'
  -H 'authority: api.openai.com'
  -H 'accept: */*'
  -H 'accept-language: en-GB,en-US;q=0.9,en;q=0.8'
  -H 'authorization: Bearer ${OPENAI_API_KEY}'
  -H 'openai-organization: org-${ORG_ID}'
  -H 'origin: https://platform.openai.com'
  -H 'referer: https://platform.openai.com/'
  -H 'sec-fetch-dest: empty'
  -H 'sec-fetch-mode: cors'
  -H 'sec-fetch-site: same-site'
  -H 'sec-gpc: 1'
  -H 'user-agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/103.0.5060.53 Safari/537.36'
  --compressed

and the response from the above call

{
  "object": "list",
  "daily_costs": [
    {
      "timestamp": 1682899200.0,
      "line_items": [
        {
          "name": "Instruct models",
          "cost": 0.00144
        },
        {
          "name": "Chat models",
          "cost": 26.369
        },
        {
          "name": "GPT-4",
          "cost": 111.978
        },
        {
          "name": "Fine-tuned models",
          "cost": 0.0
        },
        {
          "name": "Embedding models",
          "cost": 0.0002
        },
        {
          "name": "Image models",
          "cost": 0.0
        },
        {
          "name": "Audio models",
          "cost": 0.0
        }
      ]
    },
    {
      "timestamp": 1685145600.0,
      "line_items": [
        {
          "name": "Instruct models",
          "cost": 0.0
        },
        {
          "name": "Chat models",
          "cost": 0.0144
        },
        {
          "name": "GPT-4",
          "cost": 0.0
        },
        {
          "name": "Fine-tuned models",
          "cost": 0.0
        },
        {
          "name": "Embedding models",
          "cost": 0.0
        },
        {
          "name": "Image models",
          "cost": 0.0
        },
        {
          "name": "Audio models",
          "cost": 0.0
        }
      ]
    }
  ],
  "total_usage": 649.65
}

The response has a daily_costs object where each object contains a timestamp for the day and then the individual cost for each model like:

Instruct models
Chat models
GPT-4
Fine-tuned models
Embedding models
Image models
Audio models.

You can use this API call to get the total cost for any period. If you want the cost from the start, you can keep start_date as 2020-06-11 (the date when GPT-3 was launched)

The best part here is that this API call works at the token level, so you can use this to calculate cost at a token level. You can create multiple tokens for various apps or clients and then maintain a limit at your end for each token. This is something that is totally missing in OpenAI’s current platform.

Python code to get cost details

Here is a Python function that you can call from your app. You just need to pass the OPENAI_API_KEY, start_date and end_date. ORG_ID is optional.

def get_openai_cost_details(api_key, start_date, end_date, org_id=None):
    '''
    Get cost details from OpenAI.
    start_date and end_date format: 2023-05-28
    '''
    headers = {
        'authority': 'api.openai.com',
        'accept': '*/*',
        'accept-language': 'en-GB,en-US;q=0.9,en;q=0.8',
        'authorization': f'Bearer {api_key}',
        'origin': 'https://platform.openai.com',
        'referer': 'https://platform.openai.com/',
        'sec-fetch-dest': 'empty',
        'sec-fetch-mode': 'cors',
        'sec-fetch-site': 'same-site',
        'sec-gpc': '1',
        'user-agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/103.0.5060.53 Safari/537.36',
    }
    if org_id:
        headers['openai-organization'] = f'org-{org_id}'
    params = {
        'end_date': end_date,
        'start_date': start_date
    }
    response = requests.get(
      'https://api.openai.com/dashboard/billing/usage',
        params=params,
        headers=headers
    )
    return response.json()

OPENAI_API_KEY = ''     # set the one for which you want to calculate cost

print(get_openai_cost_details(OPENAI_API_KEY, '2023-05-01', '2023-06-01'))

OpenAI Grant Details

There is another API call to credit_grants the endpoint. It gives the detail of how many credits have been used. Here is the curl call

curl 'https://api.openai.com/dashboard/billing/credit_grants>'
  -H 'authority: api.openai.com'
  -H 'accept: */*'
  -H 'accept-language: en-GB,en-US;q=0.9,en;q=0.8'
  -H 'authorization: Bearer ${OPENAI_SESSION_KEY}'
  -H 'openai-organization: org-${ORG_ID}'
  -H 'origin: https://platform.openai.com'
  -H 'referer: https://platform.openai.com/'
  -H 'sec-fetch-dest: empty'
  -H 'sec-fetch-mode: cors'
  -H 'sec-fetch-site: same-site'
  -H 'sec-gpc: 1'
  -H 'user-agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/103.0.5060.53 Safari/537.36'
  --compressed

and here is the response

{
  "object": "credit_summary",
  "total_granted": 100.0,
  "total_used": 100,
  "total_available": 0,
  "grants": {
    "object": "list",
    "data": [
      {
        "object": "credit_grant",
        "id": "",
        "grant_amount": 100.0,
        "used_amount": 100.0,
        "effective_at": 1685249945.0,
        "expires_at": 1685249945.0
      }
    ]
  }
}

Note that this API call can be made using session_key only. I tried the above curl OPENAI_API_KEY and got the following error:

{'error': {'message': 'Your request to GET /dashboard/billing/credit_grants must be made with a session key (that is, it can only be made from the browser). You made it with the following key type: secret.', 'type': 'server_error', 'param': None, 'code': None}}

If you really want to get the credit details, you will have to first get the session key using a login call.

Few things to note

The endpoints listed above are internal endpoints and may change from time to time. I remember the subscription and billing endpoint use to take OPENAI_API_KEY some time back. Now it’s taking OPENAI_SESSION_KEY . So they can be changed or removed without any prior notice.
Please note that the content, findings, interpretations, and conclusions expressed in this document are solely my own and do not reflect the views or policies of OpenAI. This document is intended for informational purposes only and should not be considered as an official statement or endorsement from OpenAI.

Follow me on Twitter

Learning Path for a Computer Science Student

Taranjeet Singh — Sat, 08 Jun 2019 13:35:30 +0000

Note: this is cross-posted from my blog

This article is written for a student pursuing graduation in computer science for a duration of 4 years. It provides a learning path for a good career in software development, which can be either of the following:

Working for an early stage or high growth startup
Working for a big MNC

This article assumes the following:

There can be many achievements for a computer science student, but it mainly focuses on a good career in software development.
A good career in software development means either working for an early stage or a high growth startup or working for a big MNC.
This article does not suggest to skip the college syllabus. In fact, it suggests how to put efforts alongside your college curriculum.
This article does not provide a learning path for any specialized roles like Machine Learning Engineer, or Data Scientist. However, it tries providing an optimum path for students interested in Software engineering roles.
This article is written keeping in mind Computer Science graduates, but it is not strict about it. It can be used by anyone interested in pursuing a career in software development.
It does not provide any suggestion for "resources". You can find the resources by doing a Google search for "how to learn X".
Last, this article is just a suggestion of how should you structure yourself, so that you are more aware of how to plan and put your efforts during your graduation course.

In most of the tech companies, an entry-level software engineer role expects the following:

Good knowledge of algorithms and data structures, so that you can pick up things on the fly and are able to comprehend most of the logical things.
An understanding and knowledge of the language and frameworks used in the company. It's better if you know.

Before we begin, let's understand how is the graduation course generally structured. A 4-year programme is divided into 8 semesters, with a break of 1–3 months in between. Most of the courses run the class(around 8 hours) 6 days a week, with some half days(4 hours). This also includes the practical implementation part a.k.a Labs related to the courses you take.

Let's first plan out the time of how and when can you spend your time in following this learning path. We will call this as your additional time. You can spend your time in the following way:

2 hours per day, on weekdays(Monday - Friday)
4 hours per day, on weekends(Saturday, Sunday)

For each day, you can split it into shifts, like morning and evening.

1 hour per day, on weekdays, in Morning
1 hour per day, on weekdays, in Evening
2 hours per day, on weekends, in Morning
2 hours per day, on weekends, in Evening.

However, this is just an outline and you are free to structure your day/week in whatever way you want to.

Also, for better understanding and be clear with your goals, the semesters are divided into the following categories

Maker - This means that the entire focus is on building a product. The product can be as simple as a static web page to as complex as a chat application. It is also important to understand that here learning will be there, but it will be mainly driven towards building a product.
Learner - This means that the entire focus is on learning new stuff. It will focus less on creating products and more on building your base and depth about concepts.
Exposure - This will consist mainly of interactions with the community and learning/making by observing others or collaborating with others.

Let's us begin of how you should put additional efforts alongside your semester syllabus to have a better career in software development.

First Semester [Maker]

In this semester, learn HTML, CSS. You should learn how to build static web pages. If you are running out of ideas, of what to build, then start creating static pages of popular and frequently used websites, like Twitter, GitHub, Medium, HackerNews.

Next, you should learn how to use git and GitHub. It's very important and will be used throughout your entire career in software development. Also, commit all the code that you create during this semester to your GitHub account.

You can learn JavaScript and jQuery if you want to add some interactivity to the pages. This is additional.

You can participate in international challenges like 100 days of code. This gives you a community of like minded people willing to learn and helps you in case you get stuck.

Time: Spend all of your additional time in learning frontend development.

Second Semester[Maker]

In this semester, learn Backend development. You can pick up any language like Javascript, Php, Python, Ruby or Java. The choice of framework is also yours. But the main focus here should be able to create fully functional dynamic apps.

At this point, you can also start participating in hackathons with your fellow peers and learn more about building products in a time restricted manner and working in a team.

Time: Spend all of your additional time in learning backend development

Third Semester[Learner + Maker]

This semester, you should focus on learning data structures and algorithms. You can try competitive programming to learn. It gives you an environment and a community. Or you can learn algorithms by reading and implementing them.

Apart from this, also focus on your web development projects. Keep participating in hackathons and building side projects on ideas that fascinate you.

Time:

Spend 30% of your time in making products(3 hours per day on weekends).
Spend 70% of your time in algorithms(rest of the additional time).

Fourth Semester[Exposure]

This semester, start contributing to open source projects on framework/language of your own choice. You can use GitHub trending projects or GSOC past projects to select a project.

Also, you should participate in GSoC. At least, spend some time with an organization, understand their codebase and fix some issues. If you are excited by what they are solving, then write a GSOC proposal on a project idea. This will help you learn more about how to plan out the development, how to manage yourself, and how to be an efficient communicator.

Apart from this, keep sharpening your algorithm skills.

Time:

Spend 30% of your time in algorithms(1 hour a day, for 6 days a week)
Spend 70% of your time in open source(rest of the additional time)

Fifth Semester [Learner + Maker]

This semester, you need to balance and focus on most of the things you have done until now. Spend some of your time(30%) in refining your algorithm skills. Spend 40% of your time in going deep in maker skills(frontend or backend development or both).

Spend the last 30% in open source stuff. For open source, you can contribute to some projects or publish packages of your own. In fact, one suggestion for this can be to create an open source repo of algorithms in a language of your own choice. This will deepen your knowledge of algorithms, help you learn more about the caveats of a language and help understand how to collaborate and maintain an open source project.

Time:

Spend 30% of your time in algorithms(1 hour a day, for 6 days a week, in the morning).
Spend 30% of your time in open source(1 hour a day, for 6 days a week, in the evening).
Spend the remaining 40% of your time in maker stuff(rest of the additional time).

Sixth Semester[Learner + Maker]

This semester, spend time(50%) in preparing and practising algorithms, the next 40% time in building stuff. In fact, this time can be used to apply to GSoC as well.

At last, spend remaining 10% of your time in learning essentials skills for an interview like resume and portfolio building, and preparing for managerial round interview questions.

Time:

Spend 50% of your time in algorithms(1 hour per day on weekdays, 2 hours per day on weekends).
Spend 40% of your time in building stuff(1 hour per day on weekdays, 2 hours on Saturday).
Spend 10% of your time in essential skills(2 hours on Sunday).

Seventh Semester[Exposure]

This semester, spend entire of your time in preparing for job interviews and securing a job. This will require you to visit each of the skills learned above and balance them.

Time: Spend all of your additional time in this.

Eight Semester[Exposure]

This semester, spend time preparing for interviews if not placed. If you are placed, then you should spend time expanding your overall knowledge about software development. You should learn Test Driven Development and Object-Oriented Programming(if not learned until now). You should learn Deploying applications on cloud providers like AWS or Heroku. You should participate in local meetups of your preferred language and should give a talk. You can also use this time to explore other frontend frameworks like React, Vue or Angular.

Time: Spend all of your additional time in this.

Conclusion

This article suggests a leaning path for a career in software development, which can be followed alongside the curriculum of the college. It is written keeping in mind the experiences and observations of the author, in solving the industry-academia gap.

Special Thanks to Avi Aryan and Pragati Verma for reading draft of this article and suggesting improvements.

Class-Based Views in Django

Taranjeet Singh — Sat, 25 May 2019 11:39:27 +0000

Creating CRUD interfaces with DRY patterns in Django.

In this tutorial, we will learn how to use Class-based views to create CRUD interfaces for any model.

At the end of this tutorial, we will be able to add, list, view, update and delete a particular model(here Book and the project is based on library). This tutorial can be extended to create CRUD based interfaces for any model.

Gif showcasing CRUD interfaces for Book model

Django has 5 class based views

ListView — to view the list of objects
CreateView — to create a particular object
DetailView — to view a particular object
UpdateView — to update a particular object
DeleteView — to delete a particular object

Let’s consider that we are creating a library project. We will have a Book model in an app called store.

We will create a Django application, which will use Class based Views to create CRUD interfaces around the Book model. The complete code for the repo can be found here

We will start by creating a list of all the Book objects stored in the database.

ListView

We will use ListView to create a new view called BookListView which will also have support for pagination.

In the above code, we can see that we are overriding get_context_data to add support for pagination, by passing in an additional query parameter called page.

We will add a URL for BookListView in store/urls.py

We need to make sure that the store app URLs are included in the project URLs. If not, we will have to include it.

We will now write the template code. We are using Bootstrap v4 and have a base template called __base.html from which we extend every other template. The __base.html looks like

We will now create book/list.html .

We can see that book/list.html includes a generic template _pagination.html .

With this, our first Class-Based View ListView is complete.

Listview for Books

CreateView

Next, we will add support for creating a new Book by using CreateView.

We will add the following code in the views.

We will add a new URL for the above view.

We will now add a template book/create.html .

This completes our second Class based View CreateView. We can see that Class-Based Views helps us achieve DRY code pattern.

CreateView for Book

DetailView

We will now create a detail view using DetailView class-based view. We will add the following code in views.

We will add the following URL to include the above detail view.

We will now add a new template book/detail.html

This completes our detail view.

DetailView for Book

UpdateView

Now we will add a UpdateView for this.

We will add the following code in the views.

We will add a URL for this view.

We will add book/update.html template.

This completes our UpdateView.

UpdateView for Book

DeleteView

We will now add the last DeleteView.

We will add the following code in the views.

We will add a URL for the above view

We will add a template book/delete.html for the above view

This completes our DeleteView.

DeleteView for Book

Conclusion

In this tutorial, we learned how to use Django Class-Based Views to create CRUD interfaces for a given model. This tutorial touched on the basics and focussed very little on styling and extensibility.

Extensions

A new repo is created using this tutorial and Argon Design System. Most of the code changes are in templates only.

Django Migrations: A Primer

Taranjeet Singh — Mon, 12 Feb 2018 18:28:34 +0000

Migrations in Django are a way of propagating changes made in the model into the database schema.

Official Django docs summarizes Migration as

Migrations are Django’s way of propagating changes you make to your models (adding a field, deleting a model, etc.) into your database schema

Migrations were introduced as a built-in functionality in Django version 1.7. Migrations are created manually by running certain commands but they automate the task of applying changes to the database. We can create a migration for any changes in the model, like

Add a new model.
Add a particular field in a model
Update field attributes in a model
Delete a field in a model
Rename a field in a model

Automatically generated migrations are used to apply changes to the database schema. To apply changes in data, one needs to manually write the data migrations.

Let’s consider an example of a Library system and walk through the whole example of creating and applying migrations. Consider that our project is django_library and there is an app called library in it. We are right now focussing only on the Book model.

How to create migrations

To create the migration, Django provides a management command called makemigrations. It can be run as

Here name_of_app is optional.

Consider our library app, migrations for it can be created by running the following command.

A file called 0001_initial.py will be created in library/migrations directory.

Since this is the first migration for an app, Django names it as initial migration.

For every other migration, Django names it using date and time like 0007_auto-20180208_1613.py

It is always advised to create a named migration since it becomes easier to infer just by looking at the name of what the migration is about.

We can create named migration by running the following command

A small note here, the name of migration should not exceed 50 characters.

Let’s add another field named publisher in our Book model. Our model will now look like

To create named migration for this, we need to run makemigrations as

How to apply a migrations

Once the migration, we need to apply them, so that changes can be reflected in the databases as well.

To apply migration, we need to run migrate command as follows

By running this command, all the unapplied migration are applied to the database.

In our case for Book model, both 0001_initial and 0002_add_publisher will be applied.

Whenever any migration is applied, Django records this in a table called django_migrations.

How to undo migrations

Many times, we need to undo the migration as well. Or in simple words, we need to undo the changes which are done to the database schema by undoing that migration

Undoing a migration can be done by using migrate command, but we need to pass app name as well as the name of migration at which we want to rollback.

Let’s remove publisher field from our Book model. This can be done by undoing 0002_add_publisher migration.

Since we need to undo this migration, we will pass 0001_initial as an argument to migrate. The command will look like

By running this command, publisher field will be removed from book table in the database schema.

How to fake migrations

Many times, We just need to run the migration without actually changing the database schema. It happens when we have taken a dump from our staging or production database.

To deal with such cases, Django provides a way called fake migration , which applies the migration but does not affect the database schema.

In simpler words, for each migration which is faked, an entry is created in django_migrations table but no changes are done in the database schema.

How to clear migration for an app

Django provides with a built-in functionality, which allows us to clear all the migration for a particular app. To clear migration for an app, we need to run the following command

Here zero tells migrate command to clear the migration for a particular app.

How to list all migrations

Django provides a built-in command called showmigrations to list and display all migrations. It can be run as

When this command is run for our django_library application, we get the following output.

Here [X] indicates that the migration has been applied and [] indicates that the migration has not been applied. In our case, 0002_add_publisher is not applied.

Workflow

The basic process of creating and applying migration is the following.

First, make changes to the model. This can be adding a new model or updating/removing any fields from the model.
Create migrations by running makemigrations.
Apply migration by running migrate.

Role of django_migrations table

Whenever any migration is applied or unapplied, Django records this in a table called django_migrations. This table stores the name of the app, name and of migration and a datetime field, which tells when the migration was applied.

This table is used by Django to keep track of which migration to apply and which migrations have been applied.

A very likely doubt that arises is no changes are reflected in the database schema when a migration file is manually changed and applied again. This happens because Django has already created an entry for it in django_migrations table. One way to deal with this situation can be deleting the concerned row and then running the migrations again(this is not the official way, but it works).

What is a migration file?

Whenever makemigrations is run, a python file is created. This file contains a class called Migration which contains two attributes

dependencies

This is an important attribute, which tells that this migration depends on the previous one. It actually allows the migration to be applied in a linear fashion.

operations

This is an array, which contains all the changes that need to be applied to the database schema.

One important thing to note here is that this migration file needs to be added to the Version Control System(git) as well.

Practical Use Cases

Migrations gives us the flexibility of propagating database related changes easily across a team. Migration created by a developer can be added to VCS, which later can be applied by another dev, simply by running the migrate command.
Another way of using migration can be to apply changes in the development environment and fake migrations on the production environment. This is especially helpful in a large organization, where the database is managed specifically by Database Administrators.

Advantages

Migration gives us the flexibility to track database changes in a version control system. This way it becomes easier for us to see how the database changed over a period of time.
Migration offloads the process of manually applying a set of changes to the database. More than one migration can be applied at once by simply running the migrate command.

Summary

Django provides a built-in functionality of propagating changes made in the model to the database schema. Migrations first need to be created using makemigrations. Once created, migrations can be applied by running migrate command. Creating a migration and applying a migration both are two different processes. Automatically generated migrations are used to apply changes only to the database schema. Migrations for data needs to be manually written and applied.