DEV Community: Kaushal Patel

Setting Up CELERY in Django

Kaushal Patel — Fri, 03 Jun 2022 09:16:57 +0000

What is CELERY

Celery is an open source asynchronous task queue or job queue which is based on distributed message passing. While it supports scheduling, its focus is on operations in real time.

Celery 5.0.x supports Django 1.11 LTS or newer versions. Please use Celery 4.4.x for versions older than Django 1.11.

Step 1: First You need to install celery using pip package manager

pip install celery

Step 2: Change Settings.py file and add below configuration details at end of file

CELERY_BROKER_URL = 'redis://127.0.0.1:6379'
CELERY_ACCEPT_CONTENT = ['application/json']
CELERY_RESULT_SERIALIZER = 'json'
CELERY_TASK_SERIALIZER = 'json'
CELERY_TIMEZONE = 'Asia/Kolkata' # Configure Time zone based on your webserver
CELERY_RESULT_BACKEND = 'django-db'

Step 3: Install redis using below link if you are using windows
Download for windows
Download for Linux

Step 4: Create celery.py file in project folder
eg:

- celery_with_django/
  - manage.py
  - celery_with_django/
    - __init__.py
    - settings.py
    - urls.py
    - celery.py

Step 5: Add following code for simple testing celery

from __future__ import absolute_import, unicode_literals
import os

from celery import Celery
from django.conf import settings

os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'PROJECT_NAME.settings')

app = Celery('celery_with_django')
app.conf.enable_utc = False

app.conf.update(timezone = 'Asia/Kolkata') # Configure Time zone based on your webserver

app.config_from_object(settings, namespace='CELERY')


app.autodiscover_tasks()

@app.task(bind=True)
def debug_task(self):
    print('Request: {0!r}'.format(self.request))

Step 6: Then create App using following code and add tasks.py file

- celery_with_django/
  - manage.py
  - celery_with_django/
    - __init__.py
    - settings.py
    - urls.py
    - celery.py
  - main_app
    - __init__.py
    - apps.py
    - admin.py
    - tests.py
    - tasks.py
    - models.py
    - views.py

Step 7: Add Below code Into the tasks.py file it it will create a shared task which will print 0 to 10

from celery import shared_task

@shared_task(bind=True)
def test_func(self):
    #operations
    for i in range(10):
        print(i)
    return "Done"

Step 8: Then change the init.py file in main_app

# This will make sure the app is always imported when
# Django starts so that shared_task will use this app.
from .celery import app as celery_app

__all__ = ('celery_app',)

Step 9: Then call the test_func() from the views.py file

from django.http.response import HttpResponse
from django.shortcuts import render
from .tasks import test_func

# Create your views here.
def test(request):
    test_func.delay()
    return HttpResponse("Done")

If you are using django inbuilt user modal install the other package for presenting the status in admin panel

pip install django-celery-results

Step 10: Then Create Super using command

python manage.py createsuperuser

Step 11: Then Start Server and celery worker

# Starting Django Sever
python manage.py runserver

# Staring Celery Worker
celery -A celery_with_django.celery worker --pool=solo -l INFO

Your Task status will look like below

Ecourge Innovations

Top 5 Creative Portfolio Website

Kaushal Patel — Fri, 24 Sep 2021 07:09:21 +0000

Website 01

Live Demo	Source Code
Demo	Source Code

Website 02

Live Demo	Source Code
Demo	Source Code

Website 03

Live Demo	Source Code
Demo	Source Code

Website 04

Live Demo	Source Code
Demo	Source Code

Website 05

Live Demo	Source Code
Demo	Source Code

Ecourge Innovations

Configure Django on a Linux shared hosting account (cPanel)

Kaushal Patel — Fri, 24 Sep 2021 04:30:42 +0000

Step 1: Create a Python application in cPanel

The first step is to create a Python application within cPanel that will host the Django project. To do this, follow these steps:

Log in to cPanel.
In the SOFTWARE section of the cPanel home screen, click Setup Python App:
Click CREATE APPLICATION and the following application form appears:
In the Python version list box, select 3.8.1.
In the Application root text box, type myapp.
In the Application URL list box, select the domain. Leave the rest of the URL blank.
Leave the Application startup file text box and Application Entry point text box blank.
When these text boxes are blank, cPanel automatically creates a passenger_wsgi.py startup file and default application object for you.
In the Passenger log file text box, you can optionally specify a log file for the application.
In the top right corner of the page, click CREATE.
At the top of the page, next to Enter to the virtual environment. To enter to virtual environment, run the command, copy the command. You will need this information in the following procedure.

Step 2: Configure the Django project

After you create the Python application in cPanel, you are ready to do the following tasks at the command line:

Install Django.
Create and configure the Django project.
Configure Passenger to work with the Django project.

To do this, follow these steps:

Log in to your account using SSH.
Activate the virtual environment, using the command you noted in step 10 above. For example: (Replace username with your own)

source /home/username/virtualenv/myapp/3.8/bin/activate && cd /home/username/myapp

The command prompt now starts with (myapp:3.8) to indicate that you are working in the myapp virtual environment with Python 3.8. All of the following commands in this article assume that you are working in the Python virtual environment. If you log out of your SSH session (or deactivate the virtual environment by using the deactivate command), make sure you reactivate the virtual environment before following any of the steps below.

3. To install Django, type the following commands:

cd ~
pip install django==3.1

4. To create a Django project, type the following command:

django-admin startproject myapp ~/myapp

5. To create directories for the static project files, type the following commands:

mkdir -p ~/myapp/templates/static_pages
mkdir ~/myapp/static_files
mkdir ~/myapp/static_media

6. Use a text editor to open the ~/myapp/myapp/settings.py file, and then make the following changes:

Locate the ALLOWED_HOSTS line, and then modify it as follows. Replace example.com with your own domain name:

ALLOWED_HOSTS = ['example.com']

Locate the TEMPLATES block, and then modify it as follows:

TEMPLATES = [
    {
        'BACKEND': 'django.template.backends.django.DjangoTemplates',
        'DIRS': [os.path.join(BASE_DIR,'templates')],
        'APP_DIRS': True,
        'OPTIONS': {
            'context_processors': [
                'django.template.context_processors.debug',
                'django.template.context_processors.request',
                'django.contrib.auth.context_processors.auth',
                'django.contrib.messages.context_processors.messages',
            ],
        },
    },
]

Locate the STATIC_URL line, and then add the following lines beneath it:

STATIC_URL = '/static/'
STATIC_ROOT = os.path.join(BASE_DIR, 'static_files')

MEDIA_URL = '/media/'
MEDIA_ROOT = os.path.join(BASE_DIR, "static_media")

7. Use a text editor to open the ~/myapp/myapp/urls.py file. Delete all of the existing text, and then copy the following text into the file:

from django.contrib import admin
from django.urls import path, include
from django.conf import settings
from django.conf.urls.static import static
from django.conf.urls import url
from django.views.generic.base import TemplateView

urlpatterns = [
    path('admin/', admin.site.urls),
    url(r'^$', TemplateView.as_view(template_name='static_pages/index.html'), name='home'),
] + static(settings.MEDIA_URL, document_root=settings.MEDIA_ROOT)

urlpatterns += static(settings.STATIC_URL, document_root=settings.STATIC_ROOT)

8. Use a text editor to open the ~/myapp/passenger_wsgi.py file. Delete all of the existing text, and then copy the following text into the file:

import os
import sys

import django.core.handlers.wsgi
from django.core.wsgi import get_wsgi_application

# Set up paths and environment variables
sys.path.append(os.getcwd())
os.environ['DJANGO_SETTINGS_MODULE'] = 'myapp.settings'

# Set script name for the PATH_INFO fix below
SCRIPT_NAME = os.getcwd()

class PassengerPathInfoFix(object):
    """
        Sets PATH_INFO from REQUEST_URI because Passenger doesn't provide it.
    """
    def __init__(self, app):
        self.app = app

    def __call__(self, environ, start_response):
        from urllib.parse import unquote
        environ['SCRIPT_NAME'] = SCRIPT_NAME
        request_uri = unquote(environ['REQUEST_URI'])
        script_name = unquote(environ.get('SCRIPT_NAME', ''))
        offset = request_uri.startswith(script_name) and len(environ['SCRIPT_NAME']) or 0
        environ['PATH_INFO'] = request_uri[offset:].split('?', 1)[0]
        return self.app(environ, start_response)

# Set the application
application = get_wsgi_application()
application = PassengerPathInfoFix(application)

9. Use a text editor to create a basic index.html file in the ~/myapp/templates/static_pages directory. The file can be as simple as a text file that says Hello world.
10. Type the following command:

python ~/myapp/manage.py migrate

11. Set up the superuser account:

Type the following command:

python ~/myapp/manage.py createsuperuser

At the Username prompt, type the administrator username, and then press Enter.
At the Email address prompt, type the administrator e-mail address, and then press Enter.
At the Password prompt, type the administrator password, and then press Enter. 12.Type the following command to collect the static files:

python ~/myapp/manage.py collectstatic

If you are asked if you want to overwrite existing files, type yes and then press Enter.

13. In cPanel, restart the Python application:

Log in to cPanel.
In the SOFTWARE section of the cPanel home screen, click Setup Python App.
Under WEB APPLICATIONS, locate the myapp application, and then click the Restart icon.

14. Test the Django site:

Use your browser to go to http://www.**example.com**, where example.com represents your domain name. The index.html file should load.
Use your browser to go to http://www.**example.com**/admin, where example.com represents your domain name. You should see the Django administration login page. To log in, use the superuser credentials that you created earlier.

If the web site does not appear in your browser, try running the passenger_wsgi.py file manually. To do this, type the following command:

python ~/myapp/passenger_wsgi.py

There should not be any text output to the console when you run this file. If there are any errors, check the syntax in the configuration files.

Ecourge Innovations

Jekyll with Netlify CMS — Tutorial

Kaushal Patel — Thu, 23 Sep 2021 16:38:42 +0000

Introduction

This section will help you integrate Netlify CMS with a new or existing Jekyll project.
Jekyll is a blog-aware static site generator built with Ruby. Github Pages are powered by Jekyll, making it a popular choice for developer blogs and project pages.
If you’re starting a new project, the fastest route to publishing on a Jekyll website with Netlify CMS is to deploy a template on Netlify.

This guide aims to be helpful for users in the following situations.

You have an existing Jekyll project and you want to add Netlify CMS
You have a Jekyll project with Netlify CMS integrated and want to make updates beyond adding content
You are starting a new Jekyll + Netlify CMS project and you want to start from scratch so you know how everything fits together.

Setup

Create a Jekyll Site

This guide will use the blog you get if you follow the really excellent official Jekyll step by step tutorial as a starting point. If you’re new to Jekyll — I recommended you start by following the tutorial so you know your way around your new blog.

Hosting and Serving

You have lots of options for hosting and serving your project, but to for the sake of simplicity, this guide will assume you follow this guide to create a remote git repository on Github and give Netlify access to build and serve the project when you push changes.

Why Not Stop Here?

At this point, you have a perfectly good Jekyll site published on the web. Congratulations! It looks great, and to update the content on your site you just open your favorite text editor, create or edit a markdown file, then commit your changes and push them to your remote git repository. But maybe you are tired of looking at a markdown, or you find yourself wanting to update your blog from computers without your favorite text editor and tools installed, or you want to make it easier for less technical individuals to contribute to your blog. This is where Netlify CMS comes in.

Add Netlify CMS

Add admin/index.html

Create a directory called admin in the root directory of your Jekyll project. Jekyll will copy this directory to the _site generated when the jekyll build command is run.

mkdir admin

Move into the admin directory and create the file index.html

cd admin && touch index.html

Copy the following HTML into index.html.
Run Jekyll server and open http://127.0.0.1:4000/admin in your browser. You should see a page with the following error message.

Error loading the CMS configuration
Config Errors:
Error: Failed to load config.yml (404)
Check your config.yml file.

Add config.yml

As indicated in the error message above, Netlify CMS requires a configuration file. When it runs, netlify-cms.js it will look for config.yml at the root of the admin directory. Let's add it now.

touch config.yml

Go back to your browser and you should see the following errors.

Error loading the CMS configuration
Config Errors:
config should have required property 'backend'
config should have required property 'collections'
config should have required property 'media_folder'
config should have required property 'media_library'
config should match some schema in anyOf
Check your config.yml file.

Before we really dig into the configuration for our project, we’ll start by setting the minimum configuration to satisfy Netlify CMS.

For the backend property we'll use the test-repo backend. It will let us see the cms interface without connecting to a git repository.
The media_folder property should be set to the path where you want the cms to save images. We'll follow the advice of the jekyll docs and create an assets/ directory. Setting the media_folder property will take care of the media_library property error as well.
The collections property requires an array of collection objects. We'll start with a collection with only the property name defined to see what else is required.

Copy and paste the following into config.yml

Back in the browser, you should see a new set of errors.

Error loading the CMS configuration

Config Errors:
'collections[0]' should have required property 'label'
'collections[0]' should have required property 'files'
'collections[0]' should have required property 'folder'
'collections[0]' should have required property 'fields'
'collections[0]' should match exactly one schema in oneOf
Check your config.yml file.

Great, now we’re getting somewhere. Netlify CMS is telling us we need to define some properties of collection.

The label property is the string used to identify the collection in the cms UI. We'll set it to "Blog"
folder should be set to the directory containing the files we want the cms to be able to create and edit. We'll start with "_posts/"
The fields property requires an array of field objects. We'll start with a collection with only the property name defined. Setting the fields property will take care of the files property error as well. Update config.yml like so. And in the browser, you should see. Netlify CMS signup.

Awesome, the CMS is running without errors! Great, but you might have noticed the CMS isn’t displaying data from the three markdown files in the _posts/ directory. The reason is test-repo uses local browser storage and doesn't have access to your file system. In fact, none of the Netlify CMS backends can interact with local git repositories. This is a common point of confusion and bears repeating: NETLIFY CMS CANNOT INTERACT WITH LOCAL GIT REPOSITORIES.

Next, we’ll be setting up the Backend and Authentication so you can start updating content on your Jekyll site.

Backend and Authentication

You have lots of options for giving Netlify CMS permission to push commits to your Jekyll blog repository. In this guide — we’re using Netlify’s Identity service.

Replace the test-repo backend configuration git-gateway

# config.yml
backend:
  name: git-gateway
  branch: master # Branch to update (optional; defaults to master)

In your browser, go to https://app.netlify.com/sites/{YOUR_PROJECT_NAME}/settings/identity
Click Enable Identity
Scroll down to the Registration section and add external OAuth providers (optional)
Scroll down to the Services section and click Enable Git Gateway
Make the following changes to your Jekyll project in admin/index.html and _layouts/default.html. You can read more about the purpose of these changes here
Add the netlify-identity-widget.js script to the head of admin/index.html and _layouts/default.html

<script src="https://identity.netlify.com/v1/netlify-identity-widget.js"></script>

Add the following redirect script to the bottom of the body in _layouts/default.html

Now in the browser, you should see a modal asking for the URL of your Netlify site.

Once you’ve set it you should see a Signup/Login modal.

And once you’ve logged in you should see the CMS UI, now populated with the Jekyll blog posts you created in the Jekyll tutorial.

Also note, when using the git-gateway backend you'll be redirected to your live site when you login, meaning if you want to test your changes you'll need to push to your remote repository.

Click on one of the posts and you’ll see the edit view.

Amazing! But the editor is missing some of the frontmatter fields in your markdown file, specifically the layout and author fields.

layout: post
author: jill
title: Bananas

Also, we still can’t create new blog posts from the CMS. We’ll address these issues and others in the next section.

Jekyll Blog Configuration

Blog Collection

We’ll start by updating the blog collection. Blogging is baked into Jekyll, and the _posts/ directory uses some special conventions we'll need to keep in mind as we configure Netlify CMS. Copy and paste the following into your config.yml.

A few things to note.

With create: true set you'll be able to create new posts
We set the slug to 'year-month-day-slug' because Jekyll requires this format for blog posts. year, month, and day will be extracted from the date field, and slug will be generated from the title field.
We added editor configuration with a field preview: false. This will eliminate the preview pane. Because Jekyll uses Liquid templates, there currently isn't a good way to provide a preview of pages as you update the content.
The layout field default is set to post so Jekyll knows to use _layouts/post.html when it renders a post. This field is hidden because we want all posts to use the same layout.
The date and title field will be used by the slug - as noted above, Jekyll relies on the filename a post's publish date, but - - Netlify CMS does not pull date information from the filename and requires a frontmatter date field. Note Changing the date or title fields in Netlify CMS will not update the filename. This has two implications...
If you change the date or title fields in Netlify CMS, Jekyll won't notice
You don’t necessarily need to change the date and title fields for existing posts, but if you don't the date in the filenames and frontmatter will disagree in a way that might be confusing
If you want to avoid these issues, use a regular Jekyll collection instead of the special _posts directory

Author Collection

In addition to _posts, the Jekyll tutorial blog includes a collection of authors in the _authors directory. Before we can configure Netlify CMS to work with the author's collection, we'll need to make a couple of tweaks to our Jekyll blog. Here's the front matter for one of the authors.

short_name: jill
name: Jill Smith
position: Chief Editor

name has special meaning as a unique identifier in Netlify CMS, but as set up now our Jekyll blog is using short_name as the unique identifier for authors. For each author, update the front matter like so.

name: jill
display_name: Jill Smith
position: Chief Editor

then update _layouts/author.html and staff.html accordingly.

Next, copy and paste the following into the collections array in config.yml below the blog collection.

Now that we have the author's collection configured, we can add an author field to the blog collection. We'll use the relation widget to define the relationship between blog posts and authors.

With that configuration added, you should be able to select the author for a post from a dropdown.

About Page

Our Jekyll blog includes an About page. It would nice to be able to edit that page just like we can edit our blog and author pages. Netlify CMS provides file collections to solve this problem.

Copy and paste the following into the collections array in config.yml

Navigation

The last aspect of our Jekyll blog we might want to bring under the control of Netlify CMS is our Navigation menu. Our Jekyll tutorial blog has a file _data/navigation.yml that defines the links rendered by _includes/navigation.yml. It looks like this.

# _data/navigation.yml
- name: Home
  link: /
- name: About
  link: /about.html
- name: Blog
  link: /blog.html
- name: Staff
  link: /staff.html

To make this file editable with Netlify CMS, we’ll need to make one minor tweak. The issue is this file contains a YAML array at the top level, but Netlify CMS is designed to work with YAML objects. Update _data/navigation.yml so it looks like so.

# _data/navigation.yml
items:
  - name: Home
    link: /
  - name: About
    link: /about.html
  - name: Blog
    link: /blog.html
  - name: Staff
    link: /staff.html

You’ll need to update _includes/navigation.html accordingly. for item in site.data.navigation should be changed to for item in site.data.navigation.items. When you're done, the nav html should look like this.

Finally, add the following to the collections array in config.yml

Now you can add, rename, and rearrange the navigation items on your blog.

Ecourge Innovations