app.py

import json
import os
from pathlib import Path

from flasgger import Swagger
from flask import Flask, current_app, jsonify, request

BASE_DIR = Path(__file__).resolve().parent
DEFAULT_DATA_FILE = BASE_DIR / 'data' / 'books.json'


def default_books():
    return [
        {
            'name': 'The Pragmatic Programmer',
            'price': 299,
            'isbn': 100,
            'author': 'Andrew Hunt'
        },
        {
            'name': 'Clean Code',
            'price': 399,
            'isbn': 101,
            'author': 'Robert C. Martin'
        }
    ]


def load_books(data_file):
    path = Path(data_file)
    path.parent.mkdir(parents=True, exist_ok=True)

    if not path.exists():
        initial_data = default_books()
        path.write_text(json.dumps(initial_data, indent=2), encoding='utf-8')
        return initial_data

    with path.open('r', encoding='utf-8') as file_handle:
        books = json.load(file_handle)

    if not isinstance(books, list):
        return default_books()

    return books


def persist_books(books):
    data_file = Path(current_app.config['BOOKS_DATA_FILE'])
    data_file.parent.mkdir(parents=True, exist_ok=True)
    with data_file.open('w', encoding='utf-8') as file_handle:
        json.dump(books, file_handle, indent=2)


def valid_book_object(book_object):
    return isinstance(book_object, dict) and all(
        field in book_object for field in ('name', 'price', 'isbn', 'author')
    )


def find_book_index(books, isbn):
    for index, book in enumerate(books):
        if book.get('isbn') == isbn:
            return index
    return -1


def create_app(test_config=None):
    app = Flask(__name__)
    app.config.from_mapping(
        BOOKS_DATA_FILE=os.getenv('BOOKS_DATA_FILE', str(DEFAULT_DATA_FILE)),
        HOST=os.getenv('HOST', '0.0.0.0'),
        PORT=int(os.getenv('PORT', '5000')),
        JSON_SORT_KEYS=False,
    )

    if test_config:
        app.config.update(test_config)

    books = load_books(app.config['BOOKS_DATA_FILE'])

    Swagger(app, template={
        'swagger': '2.0',
        'info': {
            'title': 'Books API',
            'description': 'A small Flask API for managing books.',
            'version': '1.0.0'
        },
        'schemes': ['http', 'https'],
    })

    @app.route('/books', methods=['GET'])
    def get_books():
        """
        Get all books
        ---
        tags:
          - Books
        responses:
          200:
            description: A list of books
        """
        return jsonify({'books': books})

    @app.route('/books', methods=['POST'])
    def add_book():
        """
        Add a new book
        ---
        tags:
          - Books
        parameters:
          - in: body
            name: body
            required: true
            schema:
              type: object
              required:
                - name
                - price
                - isbn
                - author
              properties:
                name:
                  type: string
                price:
                  type: integer
                isbn:
                  type: integer
                author:
                  type: string
        responses:
          201:
            description: Book created successfully
          400:
            description: Invalid book payload
        """
        request_data = request.get_json(silent=True)
        if not valid_book_object(request_data):
            return jsonify({'error': 'Invalid book payload'}), 400

        books.insert(0, request_data)
        persist_books(books)
        return jsonify(request_data), 201

    @app.route('/books/<int:isbn>', methods=['GET'])
    def get_book_by_isbn(isbn):
        """
        Get a book by ISBN
        ---
        tags:
          - Books
        parameters:
          - in: path
            name: isbn
            type: integer
            required: true
        responses:
          200:
            description: Book item found
          404:
            description: Book not found
        """
        index = find_book_index(books, isbn)
        if index == -1:
            return jsonify({'error': 'Book not found'}), 404

        book = books[index]
        return jsonify({
            'name': book['name'],
            'price': book['price'],
            'isbn': book['isbn'],
            'author': book['author']
        })

    @app.route('/books/<int:isbn>', methods=['PUT'])
    def replace_book(isbn):
        """
        Replace a book by ISBN
        ---
        tags:
          - Books
        parameters:
          - in: path
            name: isbn
            type: integer
            required: true
          - in: body
            name: body
            required: true
            schema:
              type: object
              required:
                - name
                - price
                - isbn
                - author
              properties:
                name:
                  type: string
                price:
                  type: integer
                isbn:
                  type: integer
                author:
                  type: string
        responses:
          200:
            description: Book updated successfully
          400:
            description: Invalid book payload
          404:
            description: Book not found
        """
        request_data = request.get_json(silent=True)
        if not valid_book_object(request_data):
            return jsonify({'error': 'Invalid book payload'}), 400

        index = find_book_index(books, isbn)
        if index == -1:
            return jsonify({'error': 'Book not found'}), 404

        updated_book = {
            'name': request_data['name'],
            'price': request_data['price'],
            'author': request_data['author'],
            'isbn': isbn
        }
        books[index] = updated_book
        persist_books(books)
        return jsonify(updated_book)

    @app.route('/books/<int:isbn>', methods=['DELETE'])
    def delete_book(isbn):
        """
        Delete a book by ISBN
        ---
        tags:
          - Books
        parameters:
          - in: path
            name: isbn
            type: integer
            required: true
        responses:
          204:
            description: Book deleted successfully
          404:
            description: Book not found
        """
        index = find_book_index(books, isbn)
        if index == -1:
            return jsonify({'error': 'Book not found'}), 404

        books.pop(index)
        persist_books(books)
        return '', 204

    return app


app = create_app()


if __name__ == '__main__':
    app.run(host=app.config['HOST'], port=app.config['PORT'])