app1/models.py
class ModelOne(models.Model):
    ...

app2/models.py
class ModelTwo(models.Model):
   model_one = models.ForeignKey("app1.ModelOne")

#### blog_app/models/__init__.py
from .comment import Comment 
from .post import Post
#### blog_app/models/comment.py 
class Comment(models.Model):
    # comment fields 
#### blog_app/models/post.py

from django.db import connection
from django.db import reset_queries 
def database_debug(func):
    def inner_func(*args, **kwargs): 
        reset_queries()
        results = func(*args, **kwargs) 
        query_info = connection.queries
        print(f'function_name: {func.__name__}') 
        print(f'query_count: {len(query_info)}')
        queries = [f'{ query["sql"]}\n' for query in query_info] 
        print(f'queries: \n{"".join(queries)}')
        return results 
    return inner_func

@database_debug
def regular_query(): 
    blogs = models.Blog.objects.all()
    return [blog.author.name for blog in blogs] 

## OUTPUT
function_name: regular_query
query_count: 4
queries:
SELECT "blog_blog"."id", "blog_blog"."noscript",
"blog_blog"."content", "blog_blog"."author_id", 
"blog_blog"."created_at", "blog_blog"."updated_at" FROM
"blog_blog"
SELECT "author_author"."id", "author_author"."name",
"author_author"."email", "author_author"."bio" FROM 
"author_author" WHERE "author_author"."id" = 1 LIMIT 21
SELECT "author_author"."id", "author_author"."name", 
"author_author"."email", "author_author"."bio" FROM
"author_author" WHERE "author_author"."id" = 2 LIMIT 21
SELECT "author_author"."id", "author_author"."name",
"author_author"."email", "author_author"."bio" FROM 
"author_author" WHERE "author_author"."id" = 2 LIMIT 21

CREATE TABLE order (
    id INT PRIMARY KEY AUTO_INCREMENT,
    ...
    plan_id INT NULL,
    product_id INT NULL,
)

import time
import random

def unreliable_function():
    if random.random() < 0.7:
        raise Exception("an error occurred")
    return "OK"

def retry(func, retries=3, delay=2):
    for attempt in range(retries):
        try:
            result = func()
            return result
        except Exception as e:
            print(f"try again. retry time: %d" % retries)
            time.sleep(delay)
    raise Exception("unexpected error")

# Retry Pattern
result = retry(unreliable_function)
print(result)

func HandleRequest(ctx context.Context, db *sql.DB) {
    query := "SELECT * FROM users"
    rows, err := db.QueryContext(ctx, query)
    if err != nil {
        log.Fatal(err)
    }
    defer rows.Close()

    for rows.Next() {
        // پردازش داده‌ها
    }
}

syntax = "proto3";

package user;

message User {
    string name = 1;
    int32 age = 2;
}

go get google.golang.org/protobuf/cmd/protoc-gen-go

protoc --go_out=. user.proto

package main

import (
    "log"
    "github.com/confluentinc/confluent-kafka-go/kafka"
    "google.golang.org/protobuf/proto"
    "your_project/user"
)

func main() {
    producer, err := kafka.NewProducer(&kafka.ConfigMap{"bootstrap.servers": "localhost:9092"})
    if err != nil {
        log.Fatal(err)
    }
    defer producer.Close()

    // create user
    user := &user.User{
        Name: "Alice",
        Age:  30,
    }

    // serialize data
    data, err := proto.Marshal(user)
    if err != nil {
        log.Fatal("Failed to serialize user:", err)
    }

    // publish a message
    topic := "users"
    err = producer.Produce(&kafka.Message{
        TopicPartition: kafka.TopicPartition{Topic: &topic, Partition: kafka.PartitionAny},
        Value:          data,
    }, nil)

    if err != nil {
        log.Fatal("Failed to send message:", err)
    }

    producer.Flush(15 * 1000)
    log.Println("User sent to Kafka:", user.Name)
}

package main

import (
    "log"
    "github.com/confluentinc/confluent-kafka-go/kafka"
    "google.golang.org/protobuf/proto"
    "your_project/user"
)

func main() {
    consumer, err := kafka.NewConsumer(&kafka.ConfigMap{
        "bootstrap.servers": "localhost:9092",
        "group.id":          "user_group",
        "auto.offset.reset": "earliest",
    })
    if err != nil {
        log.Fatal(err)
    }
    defer consumer.Close()

    consumer.SubscribeTopics([]string{"users"}, nil)

    for {
        msg, err := consumer.ReadMessage(-1)
        if err != nil {
            log.Println("Error reading message:", err)
            continue
        }

        // deserialization
        receivedUser := &user.User{}
        if err := proto.Unmarshal(msg.Value, receivedUser); err != nil {
            log.Println("Failed to unmarshal user:", err)
            continue
        }

        // use info
        log.Printf("Received User: Name: %s, Age: %d\n", receivedUser.Name, receivedUser.Age)
    }
}

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"])