Cutting the videos based on start and end time using ffmpeg ¶

ffmpeg -ss 00:01:00 -to 00:02:00 -i input.mp4 -c copy output.mp4

References:

https://stackoverflow.com/questions/18444194/cutting-the-videos-based-on-start-and-end-time-using-ffmpeg/42827058#42827058

  PostgreSQL: log slow queries ¶

Example:

# cat /etc/postgresql/14/main/conf.d/slow_query_logging.conf

log_min_duration_statement = 5000   # expressed in [ms]
logging_collector = on

# log_directory is an absolute path, or relative to the cluster data directory,
# which can be discovered as follows:
# sudo -u postgres psql -c "SHOW data_directory"
log_directory = '/var/log/postgresql/'

log_filename = 'postgresql-14-slow-queries.log'
log_file_mode = 0644

  How to serialize Django queryset.values() into json? ¶

Django's serializers can't handle a ValuesQuerySet.

However, you can serialize by using a standard json.dumps() and transforming your ValuesQuerySet to a list by using list().

If your set includes Django fields such as Decimals or UUIDs, you will need to pass in DjangoJSONEncoder.

Thus:

import json
from django.core.serializers.json import DjangoJSONEncoder
from django.http import HttpResponse

queryset = myModel.objects.filter(foo_icontains=bar).values('f1', 'f2', 'f3')
serialized_q = json.dumps(list(queryset), cls=DjangoJSONEncoder)

return HttpResponse(serialized_q, content_type='application/json')

Or just convert the ValuesQuerySet into a Python list, so you can further manipulate it:

import json
from django.core.serializers.json import DjangoJSONEncoder

queryset = myModel.objects.filter(foo_icontains=bar).values('f1', 'f2', 'f3')
data = list(queryset)

...

return JsonResponse(data, safe=False)

References:

• https://stackoverflow.com/questions/7650448/how-to-serialize-django-queryset-values-into-json#31994176

  html_element_toggle: toggle visibility of any HTML fragment ¶

Purpose: toggle visibility of one or more HTML fragments in a page

First, in the HTML page we need to sorround the fragment with a few tags; we do this with a Python helper:

from django.utils.translation import gettext_lazy as _
from django.utils.safestring import mark_safe

@register.filter
def html_element_toggle(html_fragment, start_hidden=True):
    if start_hidden:
        html = """
<div class="html_element_toggler">
    <a class="show" href="#"><i class="fa fa-eye"></i>&nbsp;%s</a>
    <a class="hide" href="#" style="display: none;"><i class="fa fa-eye-slash"></i>&nbsp;%s</a>
    <div class="data" style="display: none;">
        %s
    </div>
</div>
""" % (_('Show'), _('Hide'), html_fragment)
    else:
        html = """
<div class="html_element_toggler">
    <a class="show" href="#" style="display: none;"><i class="fa fa-eye"></i>&nbsp;%s</a>
    <a class="hide" href="#"><i class="fa fa-eye-slash"></i>&nbsp;%s</a>
    <div class="data">
        %s
    </div>
</div>
""" % (_('Show'), _('Hide'), html_fragment)

return mark_safe(html)

Then, after page loading is completed, we schedule toggling;

with either jQuery:

$(document).ready(function() {

    $('.html_element_toggler .show,.html_element_toggler .hide').on('click', function(event) {
        event.preventDefault();
        var target = $(event.target);
        target.parent().find('.show,.hide,.data').toggle();
    });

});

or vanilla Javascript:

function ready(fn) {
    if (document.readyState !== 'loading') {
        fn();
    } else {
        document.addEventListener('DOMContentLoaded', fn);
    }
}

function toggle(el) {
    if (el.style.display == 'none') {
        el.style.display = '';
    } else {
        el.style.display = 'none';
    }
}

function register_html_element_togglers() {
    let links = document.querySelectorAll('.html_element_toggler .show,.html_element_toggler .hide');
    for (let i = 0; i < links.length; ++i) {
        links[i].addEventListener('click', function(event) {
            event.preventDefault();
            let parent = event.target.parentNode;
            var children = parent.querySelectorAll('.show,.hide,.data');
            for (let j = 0; j < children.length; ++j) {
                toggle(children[j]);
            }
        });
    }
}

ready(register_html_element_togglers);

  Sample usage of Django’s in-built cache framework ¶

from django.core.cache import cache
from .models import Article

def get_articles():
    cached_data = cache.get('articles')
    if cached_data is not None:
        return cached_data
    data = Article.objects.all()
    cache.set('articles', data, 3600)

    return data

In the code above, I first checked if articles is cached using cache.get(). If it's in the cache, return the cached articles. Otherwise, retrieve the articles from the database, store it in the cache using cache.set(), and then return it. The articles will remain in the cache for 1 hour (3600 seconds).

References:

https://python.plainenglish.io/django-optimization-guide-make-your-app-run-10x-faster-8c2f6d49ff27

  Python timezone test (with pytz and/or zoneinfo) ¶

Note that: Support for pytz is deprecated in Django 4.0 will be removed in Django 5.0

#!/usr/bin/env python3
import datetime
try:
    import pytz
except:
    pytz = None
try:
    import zoneinfo
except:
    zoneinfo = None


def get_system_tz():
    """
    "Get time zone information of the system in Python?"
    https://stackoverflow.com/questions/1111056/get-time-zone-information-of-the-system-in-python#51296984

    Example:

        print(get_system_tz())
        'CEST'

    """
    return datetime.datetime.now(datetime.timezone.utc).astimezone().tzname()


def is_tz_aware(dt):
    """
    "How to check if a datetime object is localized with pytz?"
    https://stackoverflow.com/questions/5802108/how-to-check-if-a-datetime-object-is-localized-with-pytz#27596917
    """
    return dt.tzinfo is not None and dt.tzinfo.utcoffset(dt) is not None


def print_dt(dt):
    tz_aware = is_tz_aware(dt)
    print("%s ... %s tzaware" % (dt.isoformat(), "is" if tz_aware else "is not"))


print("\nNaive:")
now_naive = datetime.datetime.now()
print_dt(now_naive)

print("\nApply system tz:")
now_tzaware = now_naive.astimezone()
print_dt(now_tzaware)

if pytz:
    print("\nApply specific tz using pytz:")
    now_pacific = now_naive.astimezone(pytz.timezone('US/Pacific'))
    print_dt(now_pacific)

if zoneinfo:
    print("\nApply specific tz using zoneinfo:")
    now_santo_domingo = now_naive.astimezone(zoneinfo.ZoneInfo(key='America/Santo_Domingo'))
    print_dt(now_santo_domingo)

Results:

Naive:
2023-07-25T16:00:26.781075 ... is not tzaware

Apply system tz:
2023-07-25T16:00:26.781075+02:00 ... is tzaware

Apply specific tz using pytz:
2023-07-25T07:00:26.781075-07:00 ... is tzaware

Apply specific tz using zoneinfo:
2023-07-25T10:00:26.781075-04:00 ... is tzaware

  Form rendering with Django 4.1 ¶

...

"as_*" methods to allow for customisation of the form layout:

• as_table (the default)
• as_ul
• as_p
• as_div (new in 4.1)

Sample form rendering by looping over each field in the form:

{% for field in form %}
<div class="mb-3">
    {% if field.use_fieldset %}
        <fieldset>
        {% if field.label %}{{ field.legend_tag }}{% endif %}
    {% else %}
        {% if field.label %}{{ field.label_tag }}{% endif %}
    {% endif %}
        <p class="text-muted">{{ form.day.help_text }}</p>
        {{ field.errors }}
        {{ field }}
    {% if field.use_fieldset %}
        </fieldset>
    {% endif %}
</div>
{% endfor %}

Tip: you can use field_order on the form to customize the order the fields

However, we'd just lie to write:

{{ form }}

Set template_name on your class. Ensure the template loader can find the template.

class ContactForm(forms.Form):
    template_name = "form_template.html"

or call render() on your form in a view and providing a template_name to customize the template per instance:

def my_view(request):
    form = ContactForm()
    context = {
        'form': form.render(template_name="form_template.html"),
    }

You can also use FORM_RENDER setting to use the template site wide:

from django.forms.renderers import TemplateSetting

class CustomFormRenderer(TemplateSetting):
    form_template_name = "form_template.html"

    # also works for formset tool
    formset_template_name = ...


FORM_RENDERER = "main.forms.CustomFormRenderer"

Finally:

• Templates are also available for:

  • Labels via template_name_label on your Form
  • Errors via a custom error_class on your Form

  Inline JavaScript onclick function with event ¶

<a href="#" onClick="(function(e){
    console.log(e);
    alert('Hey i am calling');
    return false;
})(arguments[0]);return false;">click here</a>

References:

• https://stackoverflow.com/questions/22001674/inline-javascript-onclick-function#66064971

  Schedule Linux server authomatic reboot once per week ¶

$ cat /etc/cron.d/reboot

# Once per week, on saturday morning
0 6 * * SAT     root    /sbin/shutdown --reboot +5