pip install python-decouple

   DEBUG=True
   SECRET_KEY=mysecretkey
   DATABASE_URL=postgres://user:password@localhost:5432/mydatabase
   

   from decouple import config

   DEBUG = config('DEBUG', default=False, cast=bool)
   SECRET_KEY = config('SECRET_KEY')
   DATABASE_URL = config('DATABASE_URL')
   

   DEBUG=True
   SECRET_KEY=mysecretkey
   DATABASE_URL=sqlite:///mydatabase.db
   

   from flask import Flask
   from decouple import config

   app = Flask(__name__)

   app.config['DEBUG'] = config('DEBUG', default=False, cast=bool)
   app.config['SECRET_KEY'] = config('SECRET_KEY')
   app.config['SQLALCHEMY_DATABASE_URI'] = config('DATABASE_URL')

   @app.route('/')
   def home():
       return "Hello, World!"

   if __name__ == '__main__':
       app.run()
   

docker-compose up -d

pip install redis

import json

from redis import StrictRedis


server = StrictRedis(host="localhost", port=6399, password="redis_password", db=0)

# redis ping
print(server.ping())

topic = "example_topic"

data = {
    "name": "alireza",
    "age": 22,
}

server.publish(channel=topic, message=json.dumps(data))

import json

from redis import StrictRedis


client = StrictRedis(host="localhost", port=6399, password="redis_password", db=0)

topic = "example_topic"

pubsub = client.pubsub()

pubsub.subscribe(topic)

print("waiting for message...")

while True:
    for message in pubsub.listen():
        if message["data"] == 1:
            continue
        match message["type"]:
            case topic:
                # TODO - change serialization. json is not good
                data = json.loads(message["data"])
                print("received message", data["name"], data["age"])

FROM python:3.11-slim as builder

# avoid stuck build due to user prompt
ARG DEBIAN_FRONTEND=noninteractive

RUN apt-get update && \
    apt-get install -y --no-install-recommends ...

# create and activate virtual environment
RUN python -m venv /home/myuser/venv
ENV PATH="/home/myuser/venv/bin:$PATH"

# install requirements
COPY ./requirements .
RUN pip3 install --upgrade --no-cache-dir pip
RUN pip3 install --no-cache-dir wheel
RUN pip3 install --no-cache-dir -r production.txt

FROM python:3.11-slim

RUN useradd --create-home myuser
COPY --from=builder /home/myuser/venv /home/myuser/venv

USER myuser
RUN mkdir /home/myuser/code
WORKDIR /home/myuser/code
COPY . /home/myuser/code

EXPOSE $DJANGO_PORT

# make sure all messages always reach console
ENV PYTHONUNBUFFERED=1

# activate virtual environment
ENV VIRTUAL_ENV=/home/myuser/venv
ENV PATH="/home/myuser/venv/bin:$PATH"

# /dev/shm is mapped to shared memory and should be used for gunicorn heartbeat
# this will improve performance and avoid random freezes
# CMD ["gunicorn","-b", "0.0.0.0:8000", "-w", "4", "-k", "gevent", "--worker-tmp-dir", "/dev/shm", "--chdir", "config config.wsgi:application"]

class UserNotFoundErr(Exception):
    pass


class IpBlockedErr(Exception):
    pass


class TooManyRequestErr(Exception):
    pass


class UserConflictErr(Exception):
    pass

from examples.without_rich_error.service import get_user_service
from examples.without_rich_error.exception import UserNotFoundErr, UserConflictErr, TooManyRequestErr, IpBlockedErr


def get_user_handler(user_id: int):
    try:
        print(service.get_user_by_id(user_id=user_id))
    except UserNotFoundErr as err:
        print("user not found code is 404", err)
    except UserConflictErr as err:
        print("user conflict code is 409", err)
    except TooManyRequestErr as err:
        print("too many request code is 429", err)
    except IpBlockedErr as err:
        print("ip blocked code is 403", err)

from examples.with_rich_error.api import base_response_with_error, base_response


def get_user_handler(user_id: int):
    try:
        ...
    except Exception as err:
        return base_response_with_error(error=err)

gunicorn --chdir config config.wsgi:application -b 0.0.0.0:8000

gunicorn --workers 5 --chdir config config.wsgi:application -b 0.0.0.0:8000

gunicorn --workers 1 -k gevent --chdir config config.wsgi:application -b 0.0.0.0:8000

pip install pylint

pylint .

pylint --generate-rcfile > .pylintrc

@dataclass
class UserCanceledSubscription:
    username: str

@dataclass
class UserSubscribed:
    username: str

def process(event):
    if isinstance(event, UserSubscribed):
        print(f"Enable access to user {event.username}")
    elif isinstance(event, UserCanceledSubscription):
        print(f"Disable access to user {event.username}")

@singledispatch
def process(event):
    pass

@process.register(UserCanceledSubscription)
def _(event):
    print(f"Disable access to user {event.username}")

@process.register(UserSubscribed)
def _(event):
    print(f"Enable access to user {event.username}")

events = [
    UserSubscribed(username="johndoe"),
    UserCanceledSubscription(username="johndoe"),
]

for event in events:
    process(event)

import magic
from django.core.files.uploadedfile import InMemoryUploadedFile

def get_mime_type_from_content(file: InMemoryUploadedFile) -> str:
    """Reads the initial bytes of a file to determine its actual MIME type."""
    try:
        initial_bytes = file.read(2048)
        file.seek(0)
        return magic.from_buffer(initial_bytes, mime=True)
    except Exception as err:
        raise Exception(f"Failed to detect MIME type: {err}")

def check_file_is_image(file: InMemoryUploadedFile) -> bool:
    """Check if the uploaded file is an image based on its MIME type."""
    try:
        mime_type = get_mime_type_from_content(file)
        return mime_type.startswith("image/")
    except Exception as err:
        print(f"[ERROR] check_file_is_image: {err}")
        return False