Meet Gor - Tag: django

On not using Django in 2026 due to AI?

Thu, 08 Jan 2026 00:00:00 UTC

I don't quite get it. Maybe its true. Django provided a good start but then it was like a lock in. With LLMs its quite easy to generate the boilerplatey code that django provides out of the box, so that demand is lost? Its not the only reason django is here right? It has extensions, best python community and even more best documentation. I think it will be the best framework to build with LLMs in the future if the ecosystem continues to improve

Create a Non-Clustered Index in Django with Postgres as DB

Thu, 10 Nov 2022 00:00:00 UTC

## What is a non-clustered index? A non-clustered index is a seperate structure than an actual table in the database, it stores the non-clustered index key(the column which we want to sort in the table), and a pointer to the actual values based on the index key. So, non-clustered indexes do not change the physical order of the table records, instead it holds a structure that can provide a easier and distinct way to fetch objects based on a particular column as the primary key in the structure. ## How to create a non-clustered index in django In django, we can use the [db_index](https://docs.djangoproject.com/en/4.1/ref/models/indexes/) property on a field(s) to create a index on the table/model. ### Add the property to the field in the model Chose a field in which, you want to add a index. It can be a foreign key or any other normal field defined in your model. We have used the typical blog model, so used in the some of my [TILS](https://www.meetgor.com/tils/) in django, it is just convenient to explain and understand as well. We have a django project named `core` and it has a app `blog` with a model defined below. The model `Article` has a few attributes like `title`, `description`, `content` and `status`. ```python from django.db import models ARTICLE_STATUS = [ ("PUBLISHED", "Published"), ("DRAFT", "Draft"), ] class Article(models.Model): title = models.CharField(max_length=128, db_index=True) description = models.CharField(max_length=512) content = models.TextField() status = models.CharField(max_length=16, choices=ARTICLE_STATUS, default="DRAFT") def __str__(self): return self.title ``` So, we have added a `db_index` to the title column in the model as a property. This will be equivalent to creating a index in `SQL` as follows: ``` $ python manage.py makemigrations Migrations for 'blog': blog/migrations/0002_alter_article_title.py - Alter field title on article ``` ``` $ python manage.py migrate Operations to perform: Apply all migrations: admin, auth, blog, contenttypes, sessions Running migrations: Applying blog.0002_alter_article_title... OK ``` Indexes are not standard as in SQL, but each vendor(sqlite, postgres, mysql) have their own flavour of syntax and naunces. ```sql CREATE INDEX "blog_article_title_3c514952" ON "blog_article" ("title"); CREATE INDEX "blog_article_title_3c514952_like" ON "blog_article" ("title" varchar_pattern_ops); ``` The above index commands are specific to the field, as the title field is a varchar, it has two types of index, it can generate one with simple match and other for `LIKE` comparisons because of string comparison behaviour. So, we just created a simple index and now if we query the db for a particular `title` which now has its own index for the table `blog_article`. This means, we will be able to fetch queries quickly if we are specifically filtering for `title`. ### Adding some data records We can add a few data records to test the query from the databse, you can ignore this part as it would be just setting up a django project and adding a few records to the databse. This part won't make sense for people reading to get the actual stuff done, move to the next part please. ``` python manage.py createsuperuser # Create a super user and run the server python manage.py runserver # Locate to http://127.0.0.1:8000/admin # Create some records in the artilce model ``` So, after creating some records, you should have a simple database and a working django application. ```sql SELECT * FROM blog_article; ``` ``` blog_test=# SELECT * FROM blog_article; id | title | description | content | status ----+----------+-------------+---------------------------+----------- 1 | test | test 1 | test content | DRAFT 2 | testpost | test 2 | test content more content | DRAFT 3 | newpost | test 3 | test nothing | PUBLISHED (3 rows) ``` ## Testing Queries We can now use SQL queries or django filters to check if we get results by a sequential or an index scan. If we have a filter of `title` we will get the results after performing an `Index Scan` which means, it will look up in the index columns rather than scanning the entire table of records. This is a way **we can test the indexes are working, efficiency is a differnet topic.** We can't get a idea of performance with this little data and just one connection. A real time database and having multiple conncurrent requests and connections is a good environment to test(don't do it in a production db :) ```sql EXPLAIN SELECT * FROM blog_article WHERE description LIKE 'test 2'; ``` ``` blog_test=# EXPLAIN ANALYSE SELECT * FROM blog_article WHERE description LIKE 'test'; --------------------------------------------------------------------------------------------------------- Seq Scan on blog_article (cost=0.00..11.00 rows=1 width=880) (actual time=0.180..0.181 rows=0 loops=1) Filter: ((description)::text ~~ 'test'::text) Rows Removed by Filter: 3 Planning Time: 0.189 ms Execution Time: 0.217 ms (5 rows) ``` The above query selects the records whose `description` is like `test 2`, this performs a `Sequenitial Scan` in the database i.e. iterating over the records one by one of the order of the primary key / id of the records in the table. ```sql EXPLAIN SELECT * FROM blog_article WHERE title LIKE 'test 2'; ``` ``` blog_test=# EXPLAIN ANALYSE SELECT * FROM blog_article WHERE title LIKE 'test'; --------------------------------------------------------------------------------------------------------- Index Scan using blog_article_title_3c514952_like on blog_article (cost=0.14..8.16 rows=1 width=880) (actual time=0.043..0.048 rows=1 loops=1) Index Cond: ((title)::text = 'test'::text) Filter: ((title)::text ~~ 'test'::text) Planning Time: 0.208 ms Execution Time: 0.093 ms (5 rows) ``` In the above query, the select statement has a filter with the title being like `test 2`, and since we have a index for looking for like of title column, the database performs a index scan on that table and fetches the result. Here are some tradeoffs, the planning is more and the execution time is less, this is quite logical as it would take time to make decision because the database has more options than before creating indexes. In the query where we filtered the description, the planning time was less as it makes sense there was just one option to go for sequential scan, but it took time to perform the operation as it would scan the entire table one by one. ## Using Django to test queries We can even use django to filter out the objects in the table. We simply use the `filter` method to check with a particular value. We can use the shell, to perform some queries. You can use this in your views or viewsets as per your requirements and constraints. We can even use `explain` to see what the underlying `sql` got executed out from the ORM. The [explain](https://docs.djangoproject.com/en/3.1/ref/models/querysets/#explain) function is similar to the `EXPLAIN ANALYSE` command in the `sql` queries. It gives a bit of context on how the query was executed. ``` $ python manage.py shell ``` ```python >>> from blog.models import Article >>> Article.objects.filter(description='test 1') ]> >>> Article.objects.filter(description='test 1').explain() "Seq Scan on blog_article (cost=0.00..11.00 rows=1 width=880)\n Filter: ((description)::text = 't est 1'::text)" >>> Article.objects.filter(title='test') ]> >>> Article.objects.filter(title='test').explain() "Index Scan using blog_article_title_3c514952_like on blog_article (cost=0.14..8.16 rows=1 width=8 80)\n Index Cond: ((title)::text = 'test'::text)" ``` We can use `__contains` for replicating the behaviour of `LIKE` in python/django from SQL. The below example will check if the title has a word `test` in any records of the database. ``` >>> Article.objects.filter(title__contains='test') , ]> ``` BONUS: We can even get the underlying SQL with the `.query.__str__()` method. ``` articles = Article.objects.filter(title__contains='test') articles.query.__str__() ``` ``` 'SELECT "blog_article"."id", "blog_article"."title", "blog_article"."description", "blog_article"." content", "blog_article"."status" FROM "blog_article" WHERE "blog_article"."title"::text LIKE %test %' ``` Here, we are able to see that clearly, that the django orm used the `LIKE` clause for comparing the title. Further readings and references: - [Indexing in Postgres](https://medium.com/geekculture/indexing-in-postgres-db-4cf502ce1b4e) - [Indexing refernece Django docs](https://docs.djangoproject.com/en/4.1/ref/models/indexes/) - [Non-Clustered indexing](https://gudevsoc.com/what-is-non-clustered-index-in-sql-with-example/)

Django Bulk Update QuerySet objects

Mon, 31 Oct 2022 00:00:00 UTC

Let's say, I have a lots of objects which I want to update with a particular field or fields. We can use the [bulk_update](https://docs.djangoproject.com/en/4.1/ref/models/querysets/#bulk-update) method with the model name. ```python # blog/models.py from django.db import models ARTICLE_STATUS = [ ("PUBLISHED", "Published"), ("DRAFT", "Draft"), ] class Article(models.Model): title = models.CharField(max_length=128) description = models.CharField(max_length=512) content = models.TextField() status = models.CharField(max_length=16, choices=ARTICLE_STATUS, default="DRAFT") def __str__(self): return self.title ``` Let's say we have a simple model `Article` with a few typical attributes like `title`, `description`, `content`, and `status`. We have the status as a choice field from two options as `Draft` and `Published`. It could be a boolean field, but that looks too gross for a article status. ```python from blog.models import Article articles = Article.objects.filter(status="draft") for i in range(len(articles)): articles[i].status = "published" Article.objects.bulk_update(articles, ["status",]) ``` In the above code, the `Articles` model is filtered by the status of `draft`. We iterate over the `QuerySet` which will contain the objects of the articles, by setting the object's properties to the value we want to set. We are jsut setting the value of the property of the object for each object. This just makes a changes to the `QuerySet`, by using the `bulk_update` method, the two parameters required are the `QuerySet` and the list of `fields` which are to be updated. The function returns the number of objects/records updated. ```python >>> from blog.models import Article >>> articles = Article.objects.filter(status="DRAFT") >>> articles , ]> >>> for i in range(len(articles)): ... articles[i].status = "PUBLISHED" ... >>> articles , ]> >>> >>> Article.objects.bulk_update(articles, ['status',]) 2 >>> Article.obejcts.get(title="test 1").status 'PUBLISHED' >>> Article.objects.filter(status="DRAFT") >>> ``` As, we can see here there were two obejcts `test 1` and `test 2` objects with the status as `Draft`. By iterating over the queryset and assigning the status of the object to published, the query set was changed and modified locally. By using the `bulk_update` method, we parsed the queryset and the list of attributes to be updated into the function. This gives us the number of objects which were updated, in this case `2`. We then look into the article actual record in the database and it has indeed updated to the value we set in this operation.

Django-Mermaid

Wed, 03 Aug 2022 00:00:00 UTC

Create ER Diagrams (Entity Relationship Diagrams) of your Django projects related to different models of associated applications in Mermaid. Tech Stack: - Python - Django

Django: Get list of all models and associated fields in a django project

Tue, 02 Aug 2022 00:00:00 UTC

## Context Let's say we want the list of all the models and associated attributes in all the applications of a django project, we can do that using the [django.apps](https://docs.djangoproject.com/en/4.0/ref/applications/) with apps method. ## Get all the models in a project To fetch all the models, we can use the [get_models](https://docs.djangoproject.com/en/4.0/ref/applications/#django.apps.AppConfig.get_models) methods, it will return a list of model classes in all the entire project(all applications). We can import all the models in the django project with the command: ```python from django.apps import apps models = apps.get_models() ``` ``` [, , , , , , , , , , , , , , , ] ``` We are importing the apps and creating a list of the models in our django project. The Django app command will load all the applications in the project, and the [get_models]() method will fetch the associated models. This has resulted in a list of model class objects, we can iterate over them and fetch the required details, we want. For instance, If I am interested in the name of these models, I can use the `__name__` property to fetch the model's name. ```python from django.apps import apps model_list = apps.get_models() for model in model_list: print(model.__name__) ``` ``` LogEntry Permission Group ContentType Session EmailAddress EmailConfirmation SocialApp SocialAccount SocialToken TimeStampedModel User Tags Series Article Blog ``` So, from the above example, we can see we have accessed all the model names in our entire django project. ## Access Application name associated with a model For accessing the name of the application from the model class, we can use the `_meta` attribute followed by the `app_label` property to get the `app_name` associated with the model. ```python from django.apps import apps model_list = apps.get_models() for model in model_list: print(f"{model._meta.app_label} -> {model.__name__}") ``` ``` admin -> LogEntry auth -> Permission auth -> Group contenttypes -> ContentType sessions -> Session account -> EmailAddress account -> EmailConfirmation socialaccount -> SocialApp socialaccount -> SocialAccount socialaccount -> SocialToken user -> TimeStampedModel user -> User articles -> Tags articles -> Series articles -> Article blog -> Blog ``` In the above example, we can see we have printed all the models with their associated application names. ## Accessing all the attributes associated with a model To access all the fields/property/attributes associated with a model, we can again use the `_meta` attribute followed by the `get_fields` method. This method will return a list of field objects. For accessing the name of those attributes/fields, we have to iterate over the list and then further use `name` property. ```python from django.apps import apps model_list = apps.get_models() for model in model_list: print(model.__name__) field_list = model._meta.get_fields() for field in field_list: print(field.name) ``` ``` LogEntry id action_time user content_type object_id object_repr action_flag change_message Permission group user id ... ... Blog article id name description authors ``` So, that is how we get all the associated field names in the associated models in our django projects. Also, there are a lot of attributes, we can access with the apps property. The `__dict__.keys()` can be used to get the list of all associated properties or other methods in a class instance. ``` >>> m[14]._meta.get_fields()[4].__dict__.keys() dict_keys(['name', 'verbose_name', '_verbose_name', 'primary_key', 'max_length', '_unique', 'blank', 'null', 'remote_field', 'is_relation', 'default', 'editable', 'serialize', 'unique_for_date', 'unique_for_month', 'unique_for_year', 'choices', 'help_text', 'db_index', 'db_column', '_db_tablespace', 'auto_created', 'creation_counter', '_validators', '_error_messages', 'error_messages', 'db_collation', 'validators', 'attname', 'column', 'concrete', 'model']) ``` In the above example, I am using a list of models and getting the list of all the attributes associated with a field of a model. This can be applied and other properties can be accessed. ## Get Models with a specific app Let's say we want all the models associated with a particular application in the project, we can do that by specifying the name of the application. ```python from django.apps import apps app_info = apps.get_app_config('articles') print(app_info.__dict__.keys() print(app_info.verbose_name) print(app_info.models) print(app_info.models['article'].__dict__.keys()) ``` ``` dict_keys(['name', 'module', 'apps', 'label', 'verbose_name', 'path', 'models_module', 'models']) 'Article' {'tags': , 'series': , 'article': } dict_keys(['__module__', 'Article_Status', '__str__', 'get_absolute_url', '__doc__', '_meta', 'DoesNotExist', 'MultipleObjectsReturned', 'title', 'description', 'content', 'status', 'get_status_display', 'blog_id', 'blog', 'author_id', 'author', 'timestampedmodel_ptr_id', 'timestampedmodel_ptr']) ``` So, we can see that we have got the information about the app `articles` in the proejct where we can get the `verbose_name` property to fetch the human-readable format of the article model. Further, we can get all the models associated with the `articles` application. We get back a dict with the model name as the key and the class reference as the value. We have accessed the `article` model in the `articles` application and fetched all the associated properties or methods in the model. For further references, you can visit the [django apps documentation](https://docs.djangoproject.com/en/4.0/ref/applications/) to get more relevant methods and properties.

Django Blog DevLog: Load Frontmatter data into Template/Model Form Fields

Mon, 01 Aug 2022 00:00:00 UTC

## Introduction I have an Article Form where I load my post into it directly, it might have frontmatter. So what I wish to achieve is when I paste in the content, the frontmatter should be picked up and it should render the form fields like `title`, `description`, and then also remove the frontmatter from the content. To do that, we will require a model to work with and a form based on that model. We will exclude a few fields from that model so as to process these attributes on the server side. I am working on my Blog project which is a simple Django application. You can get the source code for the project on the [GitHub repository](https://github.com/mr-destructive/techstructive-blog/). ## Django Project Context The techstructive-blog is a django project, which has a couple of applications currently, not in a good situation. There are apps like `article`, `blog`, and `user`. This project has templates and static folder in the base directory. The project is deployed on [railway](https://www.railway.app) this is an always under development project, you can check out the [techstructive-blog](https://django-blog.up.railway.app). We can get the bits and pieces of the project details required for understanding what I want to do with the following sections. ### Article Model We have an `Article` model with attributes like `title`, `description`, `author` as a Foreign Key to the user model, and a few other attributes which is not related to what we are trying to achieve right now or at least don't require an explanation. We have a model method called `get_absolute_url` for getting a URL in order to redirect the client when the model instance is created or updated from the backend. You can definitely check out the details of these small components or templates in the project repository. ```python # articles/models.py class Article(TimeStampedModel): class Article_Status(models.TextChoices): DRAFT = ( "DRAFT", _("Draft"), ) PUBLISHED = ( "PUBLISHED", _("Published"), ) title = models.CharField(max_length=128) description = models.CharField(max_length=256) content = models.TextField(default="", null=False, blank=False) status = models.CharField( max_length=16, choices=Article_Status.choices, default=Article_Status.DRAFT, ) blog = models.ForeignKey(Blog, on_delete=models.CASCADE, null=True, blank=True) author = models.ForeignKey(User, on_delete=models.CASCADE, related_name="author") def __str__(self): return self.title def get_absolute_url(self): return reverse('articles:article-detail', args=[str(self.id)]) ``` In the below snippet, we have the forms defined in the article application for creating or updating of article instance. We will be using model forms as our form data should contain fields related to a model in this case the `Article` model. So when we inherit the `forms.ModelForm` in our custom `ArticleForm` we simply need to specify the model and it will take in all the attributes of that model by default, but if we specify the `fields` or `exclude` tuples, it will include only or exclude only the provided list of attributes from the model. We have also added the widgets for the form fields which will allow us to customize the way the fields in the template/form will render. We can specify the HTML attributes like `width`, `height`, `style`, etc. ### Article Form ```python # article/forms.py from django import forms from .models import Article class ArticleForm(forms.ModelForm): class Meta: model = Article exclude = ( "created", "updated", "author", ) widgets = { "title": forms.TextInput( attrs={ "class": "form-control", "style": "max-width: 450px; align: center;", "placeholder": "Title", } ), "description": forms.TextInput( attrs={ "class": "form-control", "style": "max-width: 900px; ", "placeholder": "Description", } ), "content": forms.Textarea( attrs={ "class": "form-control post-body", "id": "text-content", "style": "max-width:900px;", "hx-post": "/article/meta/", "placeholder": "Content", } ), "blog": forms.Select( attrs={ "class": "form-control", "placeholder": "Blog Publication", } ), } ``` So, these are my models and form files in the article app. Using htmx and without any javascript I want to update the form so that it picks up the front matter in the content field which is a text area and fills the title, description other attributes automatically for me. This can be done in a lot of ways, but I will be sharing one of the ways that I recently used in my blog project. This process involves creating a class-based view and adding a `POST` method that won't post any data to the backend but will send necessary data to the view. Let's see the process before diving into any of the code: ## Gist of the Process - Attach a `hx-post` attribute to the form field for sending the request to a view - When the request is sent, the data is loaded with `request.POST`, it is cleaned and converted in python-readable format with json. - Once we have the data, we try to use the `frontmatter.loads` function that will load the content and if we have a frontmatter in the text, it will load it as a `frontmatter.POST` object. - We will extract `title`, `description`, and other data fields from the object. - We will initialize a Form instance of Article, with the initial data values as the extracted data from the frontmatter. - Now we have two options: - If the article instance already exists i.e. we are updating the article - Else we are creating a new article Accordingly, we will load the form in the respective templates i.e. `update.html` for updating the existing articles and `article-form.html` for a new article. ## Adding HTMX Magic If you'd have seen we have a `hx-post` attribute in the `article/forms.py` file, the `content` widget has a `hx-post` attribute which sends a post request to the `article/meta/` URL route. This route we will bind to the `ArticleMetaView` which we will define in a few moments. This is usually sent once we change a certain text in the content field, so we can modify it as per your requirement with `hx-trigger` that can enable us to specify the trigger event or the type of trigger we want. Further, you can read from the [htmx docs](https://htmx.org/docs/#trigger-modifiers) about these triggers and other attributes. ```python # article/urls.py from django.urls import path from . import views app_name = "articles" urlpatterns = [ path("", views.ArticleCreateView.as_view(), name="article-create"), path("/", views.ArticleDetailView.as_view(), name="article-detail"), path("delete//", views.ArticleDetailView.as_view(), name="article-delete"), path("edit/", views.ArticleDetailView.as_view(), name="article-update"), # the new view that we will create path("meta/", views.ArticleMetaView.as_view(), name="article-meta"), ] ``` ## Capture Frontmatter Meta-data View Along with the Create, Detail/List, Update, Delete View, I will create a separate class called `ArticleMetaView` that will fetch the form fields and render the templates again but this time it will fill in the frontmatter meta-data in the fields if the content is parsed with the relvant frontmatter. ```python # articles/view.py class ArticleMetaView(View): model = Article def post(self, request, *args, **kwargs): data = json.loads(json.dumps(dict(request.POST))) loaded_frontmatter = frontmatter.loads(data['content'][0]) # frontmatter has keys i.e. attributes like title, description, etc. if dict(loaded_frontmatter): article_title = loaded_frontmatter['title'] article_description = loaded_frontmatter['description'] form = ArticleForm(initial={'title': article_title, 'description': article_description, 'content': loaded_frontmatter.content}) context = {'form': form} article_list = Article.objects.filter(title=article_title) if article_list: article = article_list.last() context['article'] = article return render(request, 'articles/edit_article.html', context) return render(request, 'articles/article_form.html', context) article_list = Article.objects.filter(title=data['title'][0]) # if the article title has been already taken i.e. we are updating an article if article_list: article = article_list.last() form = ArticleForm(data=request.POST) context = {'form': form} context['article'] = article return render(request, 'articles/edit_article.html', context) form = ArticleForm(data=request.POST) context = {'form': form} return render(request, 'articles/article_form.html', context) ``` In the above `ArticleMetaView` we have created a `post` method as we want to get hold of the content from the form. So, we start by extracting and converting the `request.body` data into an appropriate type for easily working with python. So, the `request.body` will contain the data like `csrf_token`, `form_data`, etc. received from the frontend template. We store the received data as `data` and now from this data, we can load the content field which will have the content information. Firstly we will extract the `request.body` which will contain the data from the form as we have made a `POST` request to this endpoint. For doing that we need to parse the content in a apropriate format such that it is python friendly. So we wrap the `request.body` into json format and then decode it back into the json string. This will give us the dict of the request data. ```python data = json.loads(json.dumps(dict(request.POST))) ``` ``` {'csrfmiddlewaretoken': ['bSYJxD39XH509tD1tZGd0WU21PUaKaLeqjjGbyzRvLXF4P8iIxb5l0fmTWVFjELQ'], 'title': ['test2'], 'description': ['test'], 'content': ['test something'], 'status': ['DRAFT'], 'blog': ['']} ``` So, this will grab the request data as a dict, we can then extract the data from this as it has data from the Form fields. We are interested in the content field in the Form, so we can get it by specifying the key `content` from the extracted data. But as we can see the data doesn't contain the actual data instead it is wrapped in a list i.e. `['test something']`, so we will have to index it and then fetch it. ```python content_string = data['content'][0] ``` This will give us the exact content field as a string. So, we can now move into extracting the frontmatter from the fields. Now, we can use the [frontmatter](https://python-frontmatter.readthedocs.io/en/latest/index.html) library to parse the content into the [loads](https://python-frontmatter.readthedocs.io/en/latest/api.html#frontmatter.loads) funciton and extract the frontmatter if it is present in the content field. The frontmatter library has a `loads` function which takes in a string and can give out a [frontmatter.Post](https://python-frontmatter.readthedocs.io/en/latest/api.html#post-objects) object. The loads function is differnet from the [load](https://python-frontmatter.readthedocs.io/en/latest/api.html#frontmatter.load) function as the load frunciton is for reading data from a stream of bytes i.e. a file or othe related byte object. The differnece is subtle but it took a read at the [documentation](https://python-frontmatter.readthedocs.io/en/latest/api.html#module-frontmatter). ```python post = data['content'][0] loaded_frontmatter = frontmatter.loads(post) ``` This wil load the content and give us a `frontmatter.Post` as said earlier. This will contain a dict with all the frontmatter if it has any and will by default parse the non-frontmatter data i.e. the remaining text into the `content` key. We need a chack if the Form field had any fronmatter this can be checked by the `dict(loaded_frontmatter)` which will return None if it cannot load the frontmatter. ```python loaded_frontmatter = frontmatter.loads(data['content'][0]) if dict(loaded_frontmatter): print(loaded_frontmatter.keys()) ``` ``` dict_keys(['templateKey', 'title', 'description', 'date', 'status']) ``` So once we have the frontmatter loaded we can get specific keys from it and initialize the form vaues to them. But we have made clear distictions that we want to perform a specific task if we have frontmatter keys in the content field of the Form else we can do something else. First let's handle the loading of the frontmatter into the form. For doing that we will get all the required attributes from the frontmatter like `title`, `description`, `content`, etc which can be accessed normally as we extract the value from a key in a dict. Once we have got those keys, we can start filling in the Form data with initial values. The [Django Model form](https://docs.djangoproject.com/en/4.0/topics/forms/modelforms/) takes in a parameter like [initial](https://docs.djangoproject.com/en/4.0/topics/forms/modelforms/#providing-initial-values) which can be a dict of the fiields along with the value that can be used for rendering the form initially when we load the template. ```python article_title = loaded_frontmatter['title'] article_description = loaded_frontmatter['description'] form = ArticleForm(initial={'title': article_title, 'description': article_description, 'content': loaded_frontmatter.content}) ``` This will take in a `ArticleForm` and fill the initial values like `title`, `description`, etc which we have provided in the dict with the values. Now, we need to parse this form in the current template or re-render the template. But before that, we need to parse this context into the template. We will create a dict with `form` as the key which can be used to render in the template. Also, we have a two ways here, either the user is creating a new article or it is updating a existing article. We need to make sure that we preserve the initial fields in the form as we are updating the existing article. So, we can filter the article objects as per the title of the current title and then if we find a article with that title, we will parse the context with that article object. ```python article_list = Article.objects.filter(title=article_title) if article_list: article = article_list.last() context{ 'form': form, 'article': article } return render(request, 'articles/edit_article.html', context) context = {'form': form} return render(request, 'articles/article_form.html', context) ``` Now, we have form data along with the article instance used for rendering the form with appropriate content. So, this will work for editing an already existing article. For a new article, we have to simply parse the form to the template and it will render the title picked from the fotnmatter or leave it empty. Similarly, for the article with no frontmatter we will iterate over the article and if the article's title already exist, we will render the article data with the form else render the form with the parsed title and other meta-data in the form. So that is how we render the form data with frontmatter into appropriate meta-data in the form. We have used Django forms and make use of HTMX for the dynamic updation of form.

DJ Notes

Sat, 25 Jun 2022 00:00:00 UTC

A note taking application with features like markdown, syntax highlighting and filtering. Tech Stack: - Django

Django App from Scratch Using Docker with Debian Base Image

Tue, 24 May 2022 00:00:00 UTC

## Pull a Fresh Debian Image Create a docker container from a Debian image, the following command can be used to pull a debain 11-slim image and create a container of it, also enter into the container in a interactive environment `-it` mode. ``` docker run -v $(pwd):/var/www --rm -it -p 8001:80 debian:11-slim ``` ## Create a Django App from Shell script Now, since we are inside a Debian container, we can enter a few commands, you can refer to the Mark Gibney's [GitHub repository](https://github.com/no-gravity/web_app_from_scratch) for the script. ``` apt update apt install wget wget https://raw.githubusercontent.com/no-gravity/web_app_from_scratch/main/django.sh ``` Also, if you want to do a few adjustments, you can install an editor, get used to vim or use nano. ``` apt install vim OR apt install nano ``` ``` chmod +x django.sh bash django.sh ``` I also have a few adjustment of the original script, that accepts a project name and creates a django project based on the positional parameter given to it. You can get it from the [quick-setup-script repository](https://github.com/Mr-Destructive/quick-setup-scripts/blob/main/django_docker.sh) or directly the [script](https://raw.githubusercontent.com/Mr-Destructive/quick-setup-scripts/main/django_docker.sh). To use the above file, you need to execute the command as : ``` chmod +x django_docker.sh bash django_docker.sh ``` This will generate the project in the `/var/www/` folder with the name of the project. The script will prompt you with a few things for setting up at some iterations like basic application setup , `static file` configuration, `basic tempalte` setup and the `user authentication` setup. ## Copy the contents from the docker container You can copy the contents of the folder into your local machine by entering the [cp](https://docs.docker.com/engine/reference/commandline/cp/) command in docker. ``` docker cp :/var/www/ /path/in_local_machine/ ``` This will copy the project in the docker container into the local machine for you to extend and tweak it as per your needs. That's a basic Django Project Setup by using Docker with a Debian Image.

Dockerize a Django project

Wed, 02 Mar 2022 00:00:00 UTC

## Dockerize a Django project We can run our Django projects in a Docker Container by creating a Docker image for our project. It is really easy and intuitive to create a Dockerfile for any given application as it really is a matter of writing commands in a file and basically running it is a isolated environment. To create a Docker image, we first need a Dockerfile. A Dockerfile is simply a Blueprint to create a image in Docker. In this file we specify the instructions/commands/environment variables to create a image for our app to run. ### Create a Docker File To create a dockerfile, simply create a file named as `Dockerfile` without any extension(not a .txt file). We need to then add the following code into the file. ```dockerfile FROM python:3.9-buster ENV PYTHONUNBUFFERED=1 WORKDIR /code COPY requirements.txt . RUN pip install -r requirements.txt COPY . . EXPOSE 8000 CMD ["python","manage.py","runserver","0.0.0.0:8000"] ``` - Let's see what are we doing here, first we are pulling a base image of Python in this case it is [3.9-buster](https://github.com/docker-library/python/blob/a4b368154b7e3c33c76385f1be7a998fcf3123eb/3.9/buster/Dockerfile), but it can be any of the [Official Python images](https://hub.docker.com/_/python) from [dockerhub](https://hub.docker.com). It is simply a environment for our Django project to run. You can even use linux environments like ubuntu, debian or alpine. - Next we add a `PYTHONUNBUFFERED` as a environment variable and initialize it to `1`, which basically allows to parse python output straight into the terminal without actually buffering first. - We set the `WORKDIR` as the `code` directory, this sets the provided directory as the base to run any command or instructions in the Dockerfile. - We then `COPY` the `requirements.txt` file in the current(`.`) directory which is `code` as mentioned earlier. We simply want the `requirements.txt` file in the current directory so we can proceed with the next step which is to install the dependencies for the Django project - After copying the `requirements.txt` file, we simply install the packages mentioned int the file with `pip` we use the `RUN` command to execute any shell commands in the environment. - Next step is to `COPY` all the files from the current folder(local machine) into the docker environment image. So, we have the source code files in the Container. - Expose the port `8000`(default) or any other port you would want to run Django in the image. We use the expose command in complement to the `-p` argument when we want to create the container. I have explained the [port-forwarding](https://mr-destructive.github.io/techstructive-blog/docker-port-forward) concept in the previous TIL. - Finally we can run the server. We need to parse every command as a comma separated string in the list to the `CMD` which the container actually executes the command when the image is build. So, all the commands previously were to build an image for the django project, the `CMD` will actually run the server in a container after building the image of the django project. ### Build the image Using the Dockerfile, we can create the image for the Django project by a simple command. ``` docker build . -t django-app ``` Assuming the Dockerfile is in the same folder from which you are running this command. ![Build the django-app image](https://res.cloudinary.com/techstructive-blog/image/upload/v1646230907/blog-media/jj04subyvkuvfb5obytu.png) ![Build Complete Success](https://res.cloudinary.com/techstructive-blog/image/upload/v1646230988/blog-media/ugjoakqgyhiwelqkyaat.png) ### Run the Image and Create a Container ``` docker run -p 8000:8000 django-app ``` ![Create Container](https://res.cloudinary.com/techstructive-blog/image/upload/v1646231023/blog-media/yneuz46burorz4b5vzp4.png) You can use any port like `3000` or `4000` on your local system by changing the first port number as `3000:8000` and so on. So, the first port number is the local system's port number and the port number followed by a `:` is the port number for the environment inside the container of the django project. The container port is the same which we have `exposed` while creating the image. You can now go to [127.0.0.1:8000](http://127.0.0.1:8000) or your chosen port in your local environment and see the django app running. If you are using a Docker as a Virtual Machine, you need to find the IP-address of that Virtual-Machine(`docker-machine ip`) and use that instead of `localhost` or `127.0.0.1`. ### Cleaning the Container for iterations We need to stop the container to run it again after making a few changes in the app if any. Simply pressing the `CTRL + D` option wont stop the container here. We need to stop the container by executing: ``` docker ps docker stop ``` This will stop the container. Also if you want to remove the images you built, you can run the command: ``` docker image ls docker rmi -f ``` So, we now have a image of our Django project, this image can be used by anyone inside a docker environment and thus creating much more easier to test/work on a given project irrespective of the system is being used.

BackChat

Mon, 31 Jan 2022 00:00:00 UTC

A simple chat/messaging app created for exploring HTMX and django-channels. Tech Stack: - Django - Django-Channels - Daphne - HTMX

DevQuotes

Wed, 25 Aug 2021 00:00:00 UTC

A simple quote/post sharing app created for exploring Django. Tech Stack: - Django - Bootstrap

World Atlas

Sun, 25 Jul 2021 00:00:00 UTC

A simple word game using some django in the backend and javascript for frontend. Tech stack: 1. Django 2. Django-Rest-Framework 3. Javascript Django rest framework as an api for most of the operations in the game like: 1. Validating a user input place from database 2. Listing out all places from a given letter 3. Get a random place from a given letter 4. CRUD endpoint for the places in the database. API Link: https://djangonaut.pythonanywhere.com/world-atlas/api/