@functools.cache
def the_chess_board():
    return ChessBoard()

class ChessBoard:
    def __init__(self):
        ...

    @classmethod
    @functools.cache
    def the_board(cls):
        return cls()

class FileManager:
    def __init__(self, filename, mode):
        self.filename = filename
        self.mode = mode

    def __enter__(self):
        self.file = open(self.filename, self.mode)
        return self.file

    def __exit__(self, exc_type, exc_value, traceback):
        self.file.close()

with FileManager('data.txt', 'w') as f:
    f.write('Hello, World!')

numbers = [1, 2, 3, 4, 5]
squared_numbers = [n * n for n in numbers]
print(squared_numbers)  # Output: [1, 4, 9, 16, 25]

def double(x):
  return x * 2

numbers = [1, 2, 3, 4, 5]
doubled_numbers = list(map(double, numbers))
print(doubled_numbers)  # Output: [2, 4, 6, 8, 10]

def even_numbers(start, end):
  for n in range(start, end + 1):
    if n % 2 == 0:
      yield n

for even_number in even_numbers(1, 20):
  print(even_number)  # Output: 2 4 6 8 10 12 14 16 18 20

import time

def log_execution_time(func):
    def wrapper(*args, **kwargs):
        start_time = time.time()
        result = func(*args, **kwargs)
        end_time = time.time()
        print(f"Function {func.__name__} took {end_time - start_time} seconds to execute.")
        return result
    return wrapper

@log_execution_time
def my_function(n):
    result = 0
    for i in range(n):
        result += i
    return result

my_function(10000000)

from dataclasses import dataclass

@dataclass
class Person:
    name: str
    age: int
    email: str = None

person1 = Person("Alice", 30, "alice@example.com")
person2 = Person("Bob", 25)

print(person1)  # Output: Person(name='Alice', age=30, email='alice@example.com')
print(person2)  # Output: Person(name='Bob', age=25, email=None)

print(person1 == person2)  # Output: False

lambda arguments: expression

add = lambda x, y: x + y

result = add(3, 4)
print(result)  # Output: 7

numbers = [1, 2, 3, 4, 5]

doubled = map(lambda x: x * 2, numbers)

print(list(doubled))  # Output: [2, 4, 6, 8, 10]

numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

evens = filter(lambda x: x % 2 == 0, numbers)

print(list(evens))  # Output: [2, 4, 6, 8, 10]

from functools import reduce

numbers = [1, 2, 3, 4, 5]

product = reduce(lambda x, y: x * y, numbers)

print(product)  # Output: 120

from io import StringIO

sentence = StringIO()
while True:
    word = input("Enter a word (or './!/?' to end the sentence): ")
    if word in ".!?":
        sentence.write(word)
        break
    if sentence.tell() == 0:
        sentence.write(word)
    else:
        sentence.write(" " + word)

print("The concatenated sentence is:", sentence.getvalue())

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)