# Django loyihasi yaratish
django-admin startproject myproject
cd myproject

# Django app yaratish
python manage.py startapp myapp

# settings.py da SQLite sozlash
DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.sqlite3',
        'NAME': BASE_DIR / 'db.sqlite3',
    }
}

# models.py
from django.db import models
from django.contrib.auth.models import User

class Author(models.Model):
    name = models.CharField(max_length=100)
    birth_year = models.IntegerField(null=True, blank=True)
    nationality = models.CharField(max_length=50)
    created_at = models.DateTimeField(auto_now_add=True)
    
    def __str__(self):
        return self.name
    
    class Meta:
        ordering = ['name']

class Book(models.Model):
    title = models.CharField(max_length=200)
    author = models.ForeignKey(Author, on_delete=models.CASCADE)
    isbn = models.CharField(max_length=20, unique=True)
    publication_year = models.IntegerField()
    pages = models.IntegerField()
    price = models.DecimalField(max_digits=10, decimal_places=2)
    created_at = models.DateTimeField(auto_now_add=True)
    
    def __str__(self):
        return self.title
    
    class Meta:
        ordering = ['title']

class BookLoan(models.Model):
    book = models.ForeignKey(Book, on_delete=models.CASCADE)
    borrower_name = models.CharField(max_length=100)
    loan_date = models.DateField(auto_now_add=True)
    return_date = models.DateField(null=True, blank=True)
    is_returned = models.BooleanField(default=False)
    
    def __str__(self):
        return f"{self.book.title} - {self.borrower_name}"
    
    class Meta:
        ordering = ['-loan_date']

# Migration yaratish
python manage.py makemigrations

# Migration bajarish
python manage.py migrate

# Ma'lumotlar bazasini yaratish
python manage.py migrate

# Superuser yaratish
python manage.py createsuperuser

# admin.py
from django.contrib import admin
from .models import Author, Book, BookLoan

@admin.register(Author)
class AuthorAdmin(admin.ModelAdmin):
    list_display = ['name', 'birth_year', 'nationality', 'created_at']
    list_filter = ['nationality', 'birth_year']
    search_fields = ['name']
    ordering = ['name']

@admin.register(Book)
class BookAdmin(admin.ModelAdmin):
    list_display = ['title', 'author', 'publication_year', 'price']
    list_filter = ['author', 'publication_year']
    search_fields = ['title', 'author__name']
    ordering = ['title']

@admin.register(BookLoan)
class BookLoanAdmin(admin.ModelAdmin):
    list_display = ['book', 'borrower_name', 'loan_date', 'is_returned']
    list_filter = ['is_returned', 'loan_date']
    search_fields = ['book__title', 'borrower_name']
    ordering = ['-loan_date']

# views.py
from django.shortcuts import render, get_object_or_404
from django.http import JsonResponse
from django.db.models import Q, Count, Avg
from .models import Author, Book, BookLoan

def author_list(request):
    """Mualliflar ro'yxati"""
    authors = Author.objects.all()
    return render(request, 'authors.html', {'authors': authors})

def book_list(request):
    """Kitoblar ro'yxati"""
    books = Book.objects.select_related('author').all()
    return render(request, 'books.html', {'books': books})

def book_detail(request, book_id):
    """Kitob tafsilotlari"""
    book = get_object_or_404(Book, id=book_id)
    return render(request, 'book_detail.html', {'book': book})

def search_books(request):
    """Kitob qidirish"""
    query = request.GET.get('q', '')
    if query:
        books = Book.objects.filter(
            Q(title__icontains=query) | 
            Q(author__name__icontains=query)
        ).select_related('author')
    else:
        books = Book.objects.none()
    
    return render(request, 'search_results.html', {
        'books': books,
        'query': query
    })

def statistics(request):
    """Statistika"""
    stats = {
        'total_authors': Author.objects.count(),
        'total_books': Book.objects.count(),
        'total_loans': BookLoan.objects.count(),
        'active_loans': BookLoan.objects.filter(is_returned=False).count(),
        'avg_price': Book.objects.aggregate(avg_price=Avg('price'))['avg_price'],
        'authors_with_books': Author.objects.annotate(
            book_count=Count('book')
        ).filter(book_count__gt=0).count()
    }
    
    return render(request, 'statistics.html', {'stats': stats})

def api_books(request):
    """API - Kitoblar"""
    books = Book.objects.select_related('author').all()
    data = []
    for book in books:
        data.append({
            'id': book.id,
            'title': book.title,
            'author': book.author.name,
            'publication_year': book.publication_year,
            'price': float(book.price)
        })
    
    return JsonResponse({'books': data})

    
    


    
Kitoblar ro'yxati
    
    

        
        Qidirish
    
    
    
            {% for book in books %}
            
            {% endfor %}
        

        

            

                
Nomi
                
Muallif
                
Nashr yili
                
Narx
                
Harakatlar
            
        
        

                
{{ book.title }}
                
{{ book.author.name }}
                
{{ book.publication_year }}
                
{{ book.price }} so'm
                

                    Tafsilotlar
                
            
    
    
    Statistika







    
    


    
{{ book.title }}
    
    
Muallif: {{ book.author.name }}
    
ISBN: {{ book.isbn }}
    
Nashr yili: {{ book.publication_year }}
    
Sahifalar: {{ book.pages }}
    
Narx: {{ book.price }} so'm
    
    
Ijara tarixi
    

        {% for loan in book.bookloan_set.all %}
        

            {{ loan.borrower_name }} - 
            {{ loan.loan_date }} 
            {% if loan.is_returned %}
                (Qaytarilgan: {{ loan.return_date }})
            {% else %}
                (Faol)
            {% endif %}
        
        {% endfor %}
    
    
    Orqaga

# Flask loyihasi
from flask import Flask, render_template, request, jsonify, redirect, url_for
import sqlite3
from datetime import datetime

app = Flask(__name__)

def get_db_connection():
    """Ma'lumotlar bazasiga ulanish"""
    conn = sqlite3.connect('library.db')
    conn.row_factory = sqlite3.Row
    return conn

def init_database():
    """Ma'lumotlar bazasini ishga tushirish"""
    conn = get_db_connection()
    
    # Jadvallar yaratish
    conn.execute('''
    CREATE TABLE IF NOT EXISTS authors (
        id INTEGER PRIMARY KEY AUTOINCREMENT,
        name TEXT NOT NULL,
        birth_year INTEGER,
        nationality TEXT,
        created_at DATETIME DEFAULT CURRENT_TIMESTAMP
    )
    ''')
    
    conn.execute('''
    CREATE TABLE IF NOT EXISTS books (
        id INTEGER PRIMARY KEY AUTOINCREMENT,
        title TEXT NOT NULL,
        author_id INTEGER,
        isbn TEXT UNIQUE,
        publication_year INTEGER,
        pages INTEGER,
        price REAL,
        created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
        FOREIGN KEY (author_id) REFERENCES authors(id)
    )
    ''')
    
    conn.execute('''
    CREATE TABLE IF NOT EXISTS book_loans (
        id INTEGER PRIMARY KEY AUTOINCREMENT,
        book_id INTEGER,
        borrower_name TEXT,
        loan_date DATE DEFAULT CURRENT_DATE,
        return_date DATE,
        is_returned BOOLEAN DEFAULT 0,
        FOREIGN KEY (book_id) REFERENCES books(id)
    )
    ''')
    
    conn.commit()
    conn.close()

@app.route('/')
def index():
    """Asosiy sahifa"""
    return render_template('index.html')

@app.route('/authors')
def authors():
    """Mualliflar ro'yxati"""
    conn = get_db_connection()
    authors = conn.execute('SELECT * FROM authors ORDER BY name').fetchall()
    conn.close()
    return render_template('authors.html', authors=authors)

@app.route('/books')
def books():
    """Kitoblar ro'yxati"""
    conn = get_db_connection()
    books = conn.execute('''
        SELECT b.*, a.name as author_name 
        FROM books b 
        INNER JOIN authors a ON b.author_id = a.id 
        ORDER BY b.title
    ''').fetchall()
    conn.close()
    return render_template('books.html', books=books)

@app.route('/book/')
def book_detail(book_id):
    """Kitob tafsilotlari"""
    conn = get_db_connection()
    book = conn.execute('''
        SELECT b.*, a.name as author_name 
        FROM books b 
        INNER JOIN authors a ON b.author_id = a.id 
        WHERE b.id = ?
    ''', (book_id,)).fetchone()
    
    loans = conn.execute('''
        SELECT * FROM book_loans 
        WHERE book_id = ? 
        ORDER BY loan_date DESC
    ''', (book_id,)).fetchall()
    
    conn.close()
    return render_template('book_detail.html', book=book, loans=loans)

@app.route('/search')
def search():
    """Kitob qidirish"""
    query = request.args.get('q', '')
    if query:
        conn = get_db_connection()
        books = conn.execute('''
            SELECT b.*, a.name as author_name 
            FROM books b 
            INNER JOIN authors a ON b.author_id = a.id 
            WHERE b.title LIKE ? OR a.name LIKE ?
            ORDER BY b.title
        ''', (f'%{query}%', f'%{query}%')).fetchall()
        conn.close()
    else:
        books = []
    
    return render_template('search_results.html', books=books, query=query)

@app.route('/statistics')
def statistics():
    """Statistika"""
    conn = get_db_connection()
    
    # Statistika ma'lumotlari
    stats = conn.execute('''
        SELECT 
            (SELECT COUNT(*) FROM authors) as total_authors,
            (SELECT COUNT(*) FROM books) as total_books,
            (SELECT COUNT(*) FROM book_loans) as total_loans,
            (SELECT COUNT(*) FROM book_loans WHERE is_returned = 0) as active_loans,
            (SELECT AVG(price) FROM books) as avg_price
    ''').fetchone()
    
    conn.close()
    return render_template('statistics.html', stats=stats)

@app.route('/api/books')
def api_books():
    """API - Kitoblar"""
    conn = get_db_connection()
    books = conn.execute('''
        SELECT b.id, b.title, a.name as author, b.publication_year, b.price
        FROM books b 
        INNER JOIN authors a ON b.author_id = a.id 
        ORDER BY b.title
    ''').fetchall()
    conn.close()
    
    return jsonify([dict(book) for book in books])

if __name__ == '__main__':
    init_database()
    app.run(debug=True)

    
    


    
Kitoblar ro'yxati
    
    

        
        Qidirish
    
    
    
            {% for book in books %}
            
            {% endfor %}
        

        

            

                
Nomi
                
Muallif
                
Nashr yili
                
Narx
                
Harakatlar
            
        
        

                
{{ book.title }}
                
{{ book.author_name }}
                
{{ book.publication_year }}
                
{{ book.price }} so'm
                

                    Tafsilotlar
                
            
    
    
    Statistika







    
    


    
Kutubxona statistikasi
    
    

        
Umumiy ma'lumotlar
        
Mualliflar soni: {{ stats.total_authors }}
        
Kitoblar soni: {{ stats.total_books }}
        
Jami ijaralar: {{ stats.total_loans }}
        
Faol ijaralar: {{ stats.active_loans }}
        
O'rtacha narx: {{ "%.2f"|format(stats.avg_price) }} so'm
    
    
    Kitoblar ro'yxati

# requirements.txt
Flask==2.3.3
Django==4.2.7

# Django loyihasi yaratish
django-admin startproject library_project
cd library_project
python manage.py startapp library

# Flask loyihasi yaratish
mkdir flask_library
cd flask_library
touch app.py
mkdir templates
mkdir static

# Django deployment
# settings.py da production sozlamalari
DEBUG = False
ALLOWED_HOSTS = ['yourdomain.com']

# Static fayllar
STATIC_URL = '/static/'
STATIC_ROOT = os.path.join(BASE_DIR, 'staticfiles')

# Media fayllar
MEDIA_URL = '/media/'
MEDIA_ROOT = os.path.join(BASE_DIR, 'media')

# Flask deployment
# app.py da production sozlamalari
if __name__ == '__main__':
    app.run(host='0.0.0.0', port=5000, debug=False)