Django Project Dockerization


version: "2"

    build: "."
      - "8000:80"
      - ".:/app:rw"
    command: python runserver


FROM aldryn/base-project:py3-3.23

# System upgrade
RUN apt-get update && apt-get upgrade -yq

# Setup for ssh onto github
RUN mkdir -p /root/.ssh
ADD credentials/divio-deploy-key.pem /root/.ssh/id_rsa
RUN chmod 700 /root/.ssh/id_rsa
RUN echo "Host\n\tStrictHostKeyChecking no\n" >> /root/.ssh/config

# Python
# we want to keep project-specific sources in the "wee" folder
COPY requirements.txt /app/
RUN pip install -r requirements.txt

# nvm environment variables
RUN . $NVM_DIR/ && nvm install $NODE_VERSION

# add node and npm to path so the commands are available
ENV PATH $NVM_DIR/versions/node/v$NODE_VERSION/bin:$PATH
COPY package.json /app/
RUN npm install

COPY . /app

RUN npm run build

RUN DJANGO_MODE=build python collectstatic --noinput

Das isch Züri

Das muss man über Züri einfach wissen, no excuse
– So werden in der Schweiz Freunde gemacht, gilt auch für Züri: musst Du einfach gelesen haben, sonst weisst Du nicht was hier läuft, sorry.

Das muss man in Züri (mindestens) einmal gemacht haben (vielleicht):

Ab in die Berge…
– Wanderungen ab Zürich:

create ethereum keystore from private key

I havent yet found a python way of doing this but here is an npm solution:

npm install ethereumjs-wallet


var Wallet = require('ethereumjs-wallet');
var key = Buffer.from('<private key>', 'hex');
var wallet = Wallet.fromPrivateKey(key);
wallet.toV3String('<empty string or password');

Derive bitcoin addresses from HD xpub keys


we want to

  • generate Bitcoin receiving addresses from an xpub key (so that no secret information needs to be shared)
  • do this independently from a service / API, in python
  • be compatible with
  • be compatible with wallet software such as Electrum or so that the received funds can be easily managed

A note in regards to

  • allows to export the mnemonic and also the xpub key for each wallet account created
  • the xprv key for each account can be derived via by setting the account to {n}, where 0 corresponds to the first account, 1 to the second, and so on.
  • this xprv can then be imported into Electrum

Solution appears to be the continuation of Vitalik Buterin’s abandoned


from cryptos import *

words = 'word1 word2 word3 word4 word5 word6 word7 word8 word9 word10 word11 word12'
coin = Bitcoin()
private_wallet = coin.wallet(words)

xpub = private_wallet.keystore.xpub

# this is where you would start with an address calculation feature in an insecure environment like a web server
pub_keystore = keystore.from_xpub(xpub, coin, "p2pkh")
pub_wallet = wallet.HDWallet(pub_keystore)

Divio/DjangoCMS – import a DB dump

This is based on

First, get rid of the old db:

docker ps
docker stop projectname_db_1
docker rm projectname_db_1
docker-compose up db

then import

cat db-dump.sql | docker exec -i projectname_db_1 psql -U postgres db

Simple Django Admin Bulk Editing

Django Admin is awesome but it lacks an important feature: Editing multiple items in batch. There are two django add-ons this functionality but both seem a bit out of date.

Here I would like to show an example of how simple batch editing can be added to django admin with minimal amount of code, taking advantage of django admin’s own get_form().

def batch_update_view(model_admin, request, queryset, field_name):

        # removes all other fields from the django admin form for a model
    def remove_fields(form):
        for field in list(form.base_fields.keys()):
            if not field == field_name:
                del form.base_fields[field]
        return form

        # the return value is the form class, not the form class instance
    form_class = remove_fields(model_admin.get_form(request))

    if request.method == 'POST':
        form = form_class()

        # the view is already called via POST from the django admin changelist
        # here we have to distinguish between just showing the intermediary view via post
        # and actually confirming the bulk edits
        # for this there is a hidden field 'form-post' in the html template
        if 'form-post' in request.POST:
            form = form_class(request.POST)
            if form.is_valid():
                for item in queryset.all():
                    setattr(item, field_name, form.cleaned_data[field_name])
                model_admin.message_user(request, "Changed offer on {} items".format(queryset.count()))
                return HttpResponseRedirect(request.get_full_path())

        return render(
                'form': form,
                'items': queryset,

The template for the intermediary view could be made model agnostic by passing a list of (id, string) tuples to the template instead of item objects:


{% extends "admin/base_site.html" %}

{% block extrahead %}{{ block.super }}
    <script type="text/javascript" src="{% url 'admin:jsi18n' %}"></script>
    {{ media }}
{% endblock %}

{% block content %}
    <form action="" method="post">
        {% csrf_token %}
            {{ form }}
            {% for item in items %}
                    {{ }} - {{ }} - {{ item.who }} - {{ item.offer }} - {{ item.offer_work_type }}
                {# this is required by Django Admin custom action framework #}
                <input type="hidden" name="_selected_action" value="{{ }}"/>
            {% endfor %}
                {# this is required by Django Admin custom action framework #}
        <input type="hidden" name="action" value="{{ request.POST.action }}"/>
        <input type="hidden" name="form-post" value="True"/>
        <input type="submit" name="apply" value="Save"/>
{% endblock %}
class YourModelAdmin(admin.ModelAdmin):
    actions = [

    def custom_batch_editing_field1_admin_action(self, request, queryset):
        return batch_update_view(
            # this is the name of the field on the YourModel model
    batch_update_offer.short_description = "batch update field1"

Website Launch und Relaunch – Diese Skills müssen Sie an Bord holen

  • Branding: Der Branding Experte stellt sicher, dass die Alleinstellungsmerkmale und die Marke visuell und inhaltlich klar und prägnant sind.
  • Creative Design: Der Designer stellt sicher, dass die Webseite optisch ansprechend daherkommt.
  • UX (User Experience): Der UX Experte stellt sicher, dass sich der User intuitiv zurecht findet auf der Webseite.
  • Kommunikation / PR / Text: Der Texter stellt sicher, dass die Texte einfach lesbar und interessant sind.
  • Fotografie: Stellt sicher, dass die verwendeten Fotos authentisch und ansprechend sind. Produziert eigene Fotos, falls nötig.
  • Frontend Development: Setzt die Anleitungen von UX und Creative Design um und optimiert das User Interface für geläufige Browser und Geräte (responsive web design).
  • Online Marketing: Stellt sicher, dass für Marketing und Business verwertbare User Interaktionen (z.B. Warenkorb oder Kontaktformular) vorhanden sind und der Weg des Users da hin klar und einfach gestaltet ist.
  • Backend / CMS Engineering: Stellt sicher, dass Inhalte erstellt, editiert und verknüpft werden können.