Alpha-Eye-BE makes use of an extendable async API using FastAPI, Pydantic V2, SQLAlchemy 2.0 and PostgreSQL:

• FastAPI: modern Python web framework for building APIs
• Pydantic V2: the most widely used data Python validation library, rewritten in Rust (5x-50x faster)
• SQLAlchemy 2.0: Python SQL toolkit and Object Relational Mapper
• PostgreSQL: The World's Most Advanced Open Source Relational Database
• Redis: Open source, in-memory data store used by millions as a cache, message broker and more.
• Docker Compose With a single command, create and start all the services from your configuration.

• ⚡️ Fully async
• 🚀 Pydantic V2 and SQLAlchemy 2.0
• 🔐 User authentication with JWT
• 🍪 Cookie based refresh token
• 🏬 Easy redis caching
• 👜 Easy client-side caching
• 👮 FastAPI docs behind authentication and hidden based on the environment
• 🦾 Easily extendable
• 🤸‍♂️ Flexible
• 🚚 Easy running with docker compose

0. About
1. Features
   1. To Do
2. Contents
3. Prerequisites
   1. Environment Variables (.env)
   2. Docker Compose
   3. From Scratch
4. Usage
   1. Docker Compose
   2. From Scratch
      1. Packages
      2. Running PostgreSQL With Docker
      3. Running Redis with Docker
      4. Running the API
   3. Creating the first superuser
   4. Database Migrations
5. Extending
   1. Project Structure
   2. Database Model
   3. SQLAlchemy Models
   4. Pydantic Schemas
   5. Alembic Migrations
   6. CRUD
   7. Routes
      1. Paginated Responses
      2. HTTP Exceptions
   8. Caching
   9. More Advanced Caching
   10. ARQ Job Queues
   11. Rate Limiting
   12. JWT Authentication
   13. Running
   14. Create Application
6. Running in Production
   1. Uvicorn Workers with Gunicorn
   2. Running With NGINX
      1. One Server
      2. Multiple Servers
7. Testing
8. Contributing
9. References
10. License
11. Contact

Start by using the template, and naming the repository to what you want.

To access all backend codes

cd Backend

Then clone the repository to your local machine:

• Get env file to run

ENVIRONMENT can be one of local, staging and production, defaults to local, and changes the behavior of api docs endpoints:

• local: /docs, /redoc and /openapi.json available
• staging: /docs, /redoc and /openapi.json available for superusers
• production: /docs, /redoc and /openapi.json not available

To do it using docker compose, ensure you have docker and docker compose installed, then: While in the base project directory (FastAPI-boilerplate here), run:

docker compose up

You should have a web container, postgres container, a worker container and a redis container running. Then head to http://127.0.0.1:8000/docs.

Test using poetry Install poetry:

pip install poetry

Install dependencies:

poetry-add-requirements. txt

Test using venv

python -m venv venv

source venv/bin/activate
```sh
```sh
pip install -r requirements.txt

To run

uvicorn app.main:app --reload

If you used docker compose, your setup is done. You just need to ensure that when you run (while in the base folder):

docker compose up

So you may skip to 5. Extending.

While in the root folder, run to start the application with uvicorn server:

poetry run uvicorn src.app.main:app --reload

Create the new entities and relationships and add them to the model

Note that this table is used to blacklist the JWT tokens (it's how you log a user out)

If you are using docker compose, just running the following command should ensure everything is working:

docker compose up

If you are doing it from scratch, ensure your postgres and your redis are running, then while in the root folder, run to start the application with uvicorn server:

poetry run uvicorn src.app.main:app --reload

This project is a web application built with React.js, Vite, and Tailwind CSS. It provides a fast and efficient development environment for building modern web applications with a focus on performance and developer experience.

• React.js: A JavaScript library for building user interfaces.
• Vite: A build tool that focuses on speed and development experience for web projects.
• Tailwind CSS: A utility-first CSS framework for rapidly building custom designs.

Before running the project, make sure you have Node.js and npm installed on your machine.

1. Clone the repository:

 git clone 

2. Navigate into the project directory:

cd Frontend

3. Install dependencies:

 npm install

To start the development server, run:

bash npm run dev

This will start the Vite development server and open your default web browser to display the web application. The development server supports hot module replacement for fast development iteration.

To build the project for production, run:

bash npm run build

This command will build the project optimized for production deployment. The output will be generated in the dist directory.

Contributions are welcome! If you find any issues or have suggestions for improvement, feel free to open an issue or submit a pull request.

This project is licensed under the MIT License - see the LICENSE file for details.

• React.js: https://reactjs.org/
• Vite: https://vitejs.dev/
• Tailwind CSS: https://tailwindcss.com/

Currently, two official plugins are available:

• @vitejs/plugin-react uses Babel for Fast Refresh
• @vitejs/plugin-react-swc uses SWC for Fast Refresh

Mobile The mobile application is developed with Flutter and is located in the mobile directory. To run the mobile app, navigate to the mobile directory and fetch the dependencies:

To run the mobile app

cd Mobile

to get all dependencies

flutter pub get

to run the application

flutter run