Configs

poetry

official docs

poetry env use python3.11
poetry init
poetry add --group
poetry update
poetry remove
poetry install --only

.flake8, integration with black

official docs

[flake8]
max-line-length=120
ignore=E203,W503,E402,B008
per-file-ignores=__init__.py:F401
exclude=venv,static

streamlit config.toml

official docs

[browser]
    gatherUsageStats = false

[theme]
    font="arial"


[logger]
    level = "error"

[server]
    address = "0.0.0.0"

pre-commit

official docs

repos:
  - repo: https://github.com/pre-commit/pre-commit-hooks
    rev: v4.4.0
    hooks:
      - id: check-yaml
        args: [ --unsafe ]
      - id: end-of-file-fixer
        files: '\.pyi?$'
      - id: trailing-whitespace
        files: '\.pyi?$'
      - id: check-ast
        files: '\.pyi?$'
      - id: check-builtin-literals
        files: '\.pyi?$'
      - id: detect-private-key
        files: '\.pyi?$'
      - id: check-case-conflict
        files: '\.pyi?$'
      - id: pretty-format-json
        files: '\.pyi?$'
  - repo: https://github.com/psf/black
    rev: 22.12.0
    hooks:
      - id: black
        language_version: python3.11
        args: ["--line-length=120"]
  - repo: https://github.com/PyCQA/flake8
    rev: 6.0.0
    hooks:
      - id: flake8
        args: [--config, ./.flake8]
  - repo: https://github.com/commitizen-tools/commitizen
    rev: v2.39.1
    hooks:
      - id: commitizen
      - id: commitizen-branch
        stages: [ push, post-commit ]

bash profile

add git and other aliases

eval "$(/opt/homebrew/bin/brew shellenv)"
export PYENV_ROOT="$HOME/.pyenv"
export PATH="$PYENV_ROOT/bin:$PATH"
export PATH="$HOME/.local/bin:$PATH"
if command -v pyenv 1>/dev/null 2>&1; then
  eval "$(pyenv init -)"
fi
alias aws_exp_env='eval "$(aws2-wrap --profile XXX --export)"'
alias aws_sso_dev="aws sso login --profile XXX"

function parse_git_branch() {
    git branch 2> /dev/null | sed -n -e 's/^\* \(.*\)/[\1]/p'
}

COLOR_DEF=$'\e[0m'
COLOR_USR=$'\e[38;5;243m'
COLOR_DIR=$'\e[38;5;197m'
COLOR_GIT=$'\e[38;5;39m'
setopt PROMPT_SUBST
export PROMPT='${COLOR_USR}%n ${COLOR_DIR}%~ ${COLOR_GIT}$(parse_git_branch)${COLOR_DEF} $ '

autoload -Uz compinit
compinit

autoload -U +X bashcompinit && bashcompinit
complete -o nospace -C /usr/local/bin/terraform terraform

Docker

docker-compose

execute multiple commands at start

version: '3.2'
services:
  service_name:
    container_name: container_name
    restart: on-failure
    build:
      context: .
      dockerfile: Dockerfile
    environment:
      - PYTHONPATH=/app
    ports:
      - "external:internal"
    command:
      - bash
      - -c
      - |
        command1
        command2

keep the container running continuously

version: '3.2'
services:
  service_name:
    container_name: container_name
    restart: on-failure
    build:
      context: .
      dockerfile: Dockerfile
    environment:
      - PYTHONPATH=/app
    ports:
      - "external:internal"
    command:
      - bash
      - -c
      - tail -f /dev/null

docker

execute bash from

image

docker run -it image bash

container

docker exec -it container bash

SQLAlchemy

AuditBaseModelMixin

Base model mixin for applications which implement auditing (postgres)

from sqlalchemy import Boolean
from sqlalchemy import Column
from sqlalchemy import DateTime
from sqlalchemy import text
from sqlalchemy.dialects.postgresql import UUID
from sqlalchemy.sql import expression


class AuditBaseModelMixin:
    id = Column(
        UUID(as_uuid=True),
        primary_key=True,
        index=True,
        server_default=text(
            "gen_random_uuid()",
        ),
    )
    created_timestamp = Column(DateTime(timezone=True), server_default=text("current_timestamp"))
    updated_timestamp = Column(DateTime(timezone=True), server_default=text("current_timestamp"))
    is_active = Column(Boolean, server_default=expression.true(), nullable=False)

Testing

patch order in unittest

official docs

from unittest.mock import patch


@patch('where.foo.is.used')
@patch('where.bar.is.used')
def test_foo_bar(mock_bar, mock_foo):
    # call the method to test
    assert mock_bar.called
    assert mock_foo.called

pytest parametrize

official docs

import pytest


@pytest.mark.parametrize(
    "param1", "param2", "expected_result"
    [
        ("param1_value1", "param2_value1", 1), 
        ("param1_value2", "param2_value2", 2), 
    ]
)
def test_params(param1, param2, expected_result):
    return_value = what_am_i_testing(param1, param2)
    assert return_value == expected_result

Postgres

calendar table

create table calendar as
SELECT CAST('2020-12-15' AS DATE) + (n || ' day')::INTERVAL AS calendar_date 
FROM generate_series(0, 900) n;