Skip to content

README.md

Latest commit

History

History
85 lines (68 loc) · 8.14 KB

README.md

File metadata and controls

85 lines (68 loc) · 8.14 KB
Raw

FastAPI Template

A FastAPI template with Redis, Docker and PostgreSQL

Introduction

This FastAPI template was created out of a need for consistent structure for projects with a setup that's easy to understand and use with as minimal additional setup as possible.

What is hoped to be achieved

  • Simplicity; no need for bloated classes and huge utils that you'll likely never use. Everything here should be very much needed in most projects
  • Low barrier for entry; a template that is easy to start with and does not seem too advanced for beginners to use
  • Production-ready; the above does not remove the important fact that this should be always production-ready without obvious faults
  • Consistency; a smell for codebases is you not having a 'knowing' of where certain code is located. A wanted structure is one that's easy to navigate

What is not hoped to be achieved

  • Batteries-included; this template, whilst influenced by Django, does not aim to provide Django-like capabilities or to have a 'Django, but for FastAPI' setup
  • Utility dump; this template will not be where all sorts of utilities are dumped because, 'why not?'.

How to use

  • Copy .example.env into a file, .env
  • Run docker-compose up --build to build and run container. Yes, I expect you to use Docker in this day and age.

The above is enough to run your project except you need more than that if you are working on a real application. So, this:

Personalizing the template

First, head to app/settings and edit Settings.APP_NAME to reflect the name of your application.

Next, you'll want to run pipenv install to ensure you get a Python environment you can attach to your IDE to allow for autocomplete and auto-imports so you don't have yellow and red lines everywhere

After this, we head to the .env to edit some of the values to your taste. Each value is explained in the Config section.

Databases

Databases can be quite dicey and I'm happy to say Alembic is used to handle migrations and whatnots. This coupled with SQLAlchemy makes the world a better place. Whilst PostgreSQL is assumed to be the default database. You can of course edit things to your liking.

  • Create migrations with docker-compose run web alembic revision -m "Migration message here".
  • Run migrations within Docker with docker-compose run web alembic upgrade head.

Config

This section documents configuration options and the meaning of settings values and how to use them.

Environmental Variables

The environmental variables in the .example.env file have specific purposes:

KeyDescriptionDefault
ALLOWED_HOSTThe domain you intend to run this application on0.0.0.0
SECRET_KEYA secret value used to hash and sign tokens and other security-related stuffs.meandyouaretogether
DEBUGA value that evaluates to a boolean to determine whether the app is run in debug mode or production.True
PORTPort the application will run on. If you change this from default, you will have to change the value in the docker-compose.yml file.11000
POSTGRES_USERThis is the default user for the PostgreSQL database. On first run, Docker will use this value to initialize a postgres user so you'll want to set it before your first execution.sasori
POSTGRES_PASSWORDThis is the default password for the PostgreSQL database. On first run, Docker will use this value to initialize a postgres database so you'll want to set it before your first execution.sasori
POSTGRES_DBThis is the default PostgreSQL database created. On first run, Docker will use this value to initialize a postgres database so you'll want to set it before your first executionakatsuki
POSTGRES_TEST_DBThis is the database created for test cases. It is flushed after every test case is run.hebi
POSTGRES_PORTThe port Postgres will run on. Don't change it except you know what you're doing, and if you do, change the value in the docker-compose.yml file.5432
POSTGRES_HOSTThe host set in the docker container where the PostgreSQL instance will be running. Don't change it except you know what you're doing, and if you do, change the value in the docker-compose.yml file.postgres
REDIS_HOSTThe host set in the docker container where the Redis instance will be running. Don't change it except you know what you're doing, and if you do, change the value in the docker-compose.yml file.redis
REDIS_PORTThe port the application will use to connect to Redis. Don't change it except you know what you're doing, and if you do, change the value in the docker-compose.yml file.6379

Application Settings

Application settings are set in the app.settings.Settings class and are used to store app wide configurations. Values are so:

keyDescriptionDefault
APP_TITLEName of the application, will show in the documentationApp Name
ALLOWED_HOSTThe domain you intend to run this application onDerived from .env with key ALLOWED_HOST
SECRET_KEYA secret value used to hash and sign tokens and other security-related stuffs.Derived from .env with key SECRET_KEY
DEBUGA value that evaluates to a boolean to determine whether the app is run in debug mode or production.Derived from .env with key DEBUG
ALLOWED_PORTPort the application will run on. If you change this from default, you will have to change the value in the docker-compose.yml file.Derived from .env with key PORT
DB_USERThis is the default user for the PostgreSQL database. On first run, Docker will use this value to initialize a postgres user so you'll want to set it before your first execution.Derived from .env with key POSTGRES_USER
DB_PASSWORDThis is the default password for the PostgreSQL database. On first run, Docker will use this value to initialize a postgres database so you'll want to set it before your first execution.Derived from .env with key POSTGRES_PASSWORD
DB_DBThis is the default PostgreSQL database created. On first run, Docker will use this value to initialize a postgres database so you'll want to set it before your first executionDerived from .env with key POSTGRES_DB
DB_PORTThe port Postgres will run on. Don't change it except you know what you're doing, and if you do, change the value in the docker-compose.yml file.Derived from .env with key POSTGRES_PORT
DB_HOSTThe host set in the docker container where the PostgreSQL instance will be running. Don't change it except you know what you're doing, and if you do, change the value in the docker-compose.yml file.Derived from .env with key POSTGRES_HOST
DB_URLURL leading to the application databasepostgresql+psycopg2://{DB_USER}:{DB_PASSWORD}@{DB_HOST}:{DB_PORT}/{DB_DB}
TEST_DBThis is the database created for test cases. It is flushed after every test case is run.Derived from .env with key POSTGRES_TEST_DB
TEST_DB_URLURL leading to test databasepostgresql+psycopg2://{DB_USER}:{DB_PASSWORD}@{DB_HOST}:{DB_PORT}/{TEST_DB}
ACCESS_TOKEN_EXPIRY_TIMEDuration in seconds before access token expires60 * 30 (seconds)
REFRESH_TOKEN_EXPIRY_TIMEDuration in seconds before refresh token expires60 * 30 (seconds)
PASSWORD_HASHERHashing algorithm for passwordsCryptContext(schemes=["bcrypt"], deprecated="auto")
JWT_ALGORITHMAlgorithm used to generate JWT tokenHS256
REDIS_HOSTThe host set in the docker container where the Redis instance will be running. Don't change it except you know what you're doing, and if you do, change the value in the docker-compose.yml file.Derived from .env with key REDIS_HOST
REDIS_PORTThe port the application will use to connect to Redis. Don't change it except you know what you're doing, and if you do, change the value in the docker-compose.yml file.Derived from .env with key REDIS_HOST
PAGE_SIZE[Not Implemented] default size of page for paginated items50

I don't want some things

There is the possibility that you may not want some features such as Redis. You can easily remove what you don't need and proceed as planned.

, 'i'); if (__m === '*' || __re.test(location.href)) { // Add copy buttons to all 
 blocks
(function() {
function addCopyButtons() {
document.querySelectorAll('pre code').forEach(function(codeBlock) {
if (codeBlock.parentElement.hasAttribute('data-copy-added')) return;
codeBlock.parentElement.setAttribute('data-copy-added', 'true');
var btn = document.createElement('button');
btn.textContent = 'Copy';
btn.style.cssText = 'position:absolute;top:4px;right:4px;padding:2px 8px;font-size:11px;background:#4ecdc4;border:none;border-radius:4px;color:#1a1a2e;cursor:pointer;opacity:0.7;transition:opacity 0.2s;';
btn.onmouseover = function() { this.style.opacity = '1'; };
btn.onmouseout = function() { this.style.opacity = '0.7'; };
btn.onclick = function() {
navigator.clipboard.writeText(codeBlock.textContent).then(function() {
btn.textContent = 'Copied!';
setTimeout(function() { btn.textContent = 'Copy'; }, 1500);
});
};
codeBlock.parentElement.style.position = 'relative';
codeBlock.parentElement.appendChild(btn);
});
}
addCopyButtons();
// Re-run on dynamic content
var observer = new MutationObserver(addCopyButtons);
observer.observe(document.body, { childList: true, subtree: true });
})();
}
} catch(__e) { console.warn('[Userscript:Add Copy Buttons to Code Blocks]', __e); }
})();
(function(){
try {
var __m = "github.com";
var __re = new RegExp('^' + "github\\.com" + '
fastapi-template/README.md at main · FastAPI-MEA/fastapi-template · GitHub
Skip to content
README.md
Latest commit
History
History
85 lines (68 loc) · 8.14 KB
README.md
File metadata and controls
85 lines (68 loc) · 8.14 KB
Raw
FastAPI Template
A FastAPI template with Redis, Docker and PostgreSQL
Introduction
This FastAPI template was created out of a need for consistent structure for projects with a setup that's easy to understand and use with as minimal additional setup as possible.
What is hoped to be achieved
  • Simplicity; no need for bloated classes and huge utils that you'll likely never use. Everything here should be very much needed in most projects
  • Low barrier for entry; a template that is easy to start with and does not seem too advanced for beginners to use
  • Production-ready; the above does not remove the important fact that this should be always production-ready without obvious faults
  • Consistency; a smell for codebases is you not having a 'knowing' of where certain code is located. A wanted structure is one that's easy to navigate
What is not hoped to be achieved
  • Batteries-included; this template, whilst influenced by Django, does not aim to provide Django-like capabilities or to have a 'Django, but for FastAPI' setup
  • Utility dump; this template will not be where all sorts of utilities are dumped because, 'why not?'.
How to use
  • Copy .example.env into a file, .env
  • Run docker-compose up --build to build and run container. Yes, I expect you to use Docker in this day and age.
The above is enough to run your project except you need more than that if you are working on a real application. So, this:
Personalizing the template
First, head to app/settings and edit Settings.APP_NAME to reflect the name of your application.
Next, you'll want to run pipenv install to ensure you get a Python environment you can attach to your IDE to allow for autocomplete and auto-imports so you don't have yellow and red lines everywhere
After this, we head to the .env to edit some of the values to your taste. Each value is explained in the Config section.
Databases
Databases can be quite dicey and I'm happy to say Alembic is used to handle migrations and whatnots. This coupled with SQLAlchemy makes the world a better place. Whilst PostgreSQL is assumed to be the default database. You can of course edit things to your liking.
  • Create migrations with docker-compose run web alembic revision -m "Migration message here".
  • Run migrations within Docker with docker-compose run web alembic upgrade head.
Config
This section documents configuration options and the meaning of settings values and how to use them.
Environmental Variables
The environmental variables in the .example.env file have specific purposes:
KeyDescriptionDefault
ALLOWED_HOSTThe domain you intend to run this application on0.0.0.0
SECRET_KEYA secret value used to hash and sign tokens and other security-related stuffs.meandyouaretogether
DEBUGA value that evaluates to a boolean to determine whether the app is run in debug mode or production.True
PORTPort the application will run on. If you change this from default, you will have to change the value in the docker-compose.yml file.11000
POSTGRES_USERThis is the default user for the PostgreSQL database. On first run, Docker will use this value to initialize a postgres user so you'll want to set it before your first execution.sasori
POSTGRES_PASSWORDThis is the default password for the PostgreSQL database. On first run, Docker will use this value to initialize a postgres database so you'll want to set it before your first execution.sasori
POSTGRES_DBThis is the default PostgreSQL database created. On first run, Docker will use this value to initialize a postgres database so you'll want to set it before your first executionakatsuki
POSTGRES_TEST_DBThis is the database created for test cases. It is flushed after every test case is run.hebi
POSTGRES_PORTThe port Postgres will run on. Don't change it except you know what you're doing, and if you do, change the value in the docker-compose.yml file.5432
POSTGRES_HOSTThe host set in the docker container where the PostgreSQL instance will be running. Don't change it except you know what you're doing, and if you do, change the value in the docker-compose.yml file.postgres
REDIS_HOSTThe host set in the docker container where the Redis instance will be running. Don't change it except you know what you're doing, and if you do, change the value in the docker-compose.yml file.redis
REDIS_PORTThe port the application will use to connect to Redis. Don't change it except you know what you're doing, and if you do, change the value in the docker-compose.yml file.6379
Application Settings
Application settings are set in the app.settings.Settings class and are used to store app wide configurations. Values are so:
keyDescriptionDefault
APP_TITLEName of the application, will show in the documentationApp Name
ALLOWED_HOSTThe domain you intend to run this application onDerived from .env with key ALLOWED_HOST
SECRET_KEYA secret value used to hash and sign tokens and other security-related stuffs.Derived from .env with key SECRET_KEY
DEBUGA value that evaluates to a boolean to determine whether the app is run in debug mode or production.Derived from .env with key DEBUG
ALLOWED_PORTPort the application will run on. If you change this from default, you will have to change the value in the docker-compose.yml file.Derived from .env with key PORT
DB_USERThis is the default user for the PostgreSQL database. On first run, Docker will use this value to initialize a postgres user so you'll want to set it before your first execution.Derived from .env with key POSTGRES_USER
DB_PASSWORDThis is the default password for the PostgreSQL database. On first run, Docker will use this value to initialize a postgres database so you'll want to set it before your first execution.Derived from .env with key POSTGRES_PASSWORD
DB_DBThis is the default PostgreSQL database created. On first run, Docker will use this value to initialize a postgres database so you'll want to set it before your first executionDerived from .env with key POSTGRES_DB
DB_PORTThe port Postgres will run on. Don't change it except you know what you're doing, and if you do, change the value in the docker-compose.yml file.Derived from .env with key POSTGRES_PORT
DB_HOSTThe host set in the docker container where the PostgreSQL instance will be running. Don't change it except you know what you're doing, and if you do, change the value in the docker-compose.yml file.Derived from .env with key POSTGRES_HOST
DB_URLURL leading to the application databasepostgresql+psycopg2://{DB_USER}:{DB_PASSWORD}@{DB_HOST}:{DB_PORT}/{DB_DB}
TEST_DBThis is the database created for test cases. It is flushed after every test case is run.Derived from .env with key POSTGRES_TEST_DB
TEST_DB_URLURL leading to test databasepostgresql+psycopg2://{DB_USER}:{DB_PASSWORD}@{DB_HOST}:{DB_PORT}/{TEST_DB}
ACCESS_TOKEN_EXPIRY_TIMEDuration in seconds before access token expires60 * 30 (seconds)
REFRESH_TOKEN_EXPIRY_TIMEDuration in seconds before refresh token expires60 * 30 (seconds)
PASSWORD_HASHERHashing algorithm for passwordsCryptContext(schemes=["bcrypt"], deprecated="auto")
JWT_ALGORITHMAlgorithm used to generate JWT tokenHS256
REDIS_HOSTThe host set in the docker container where the Redis instance will be running. Don't change it except you know what you're doing, and if you do, change the value in the docker-compose.yml file.Derived from .env with key REDIS_HOST
REDIS_PORTThe port the application will use to connect to Redis. Don't change it except you know what you're doing, and if you do, change the value in the docker-compose.yml file.Derived from .env with key REDIS_HOST
PAGE_SIZE[Not Implemented] default size of page for paginated items50
I don't want some things
There is the possibility that you may not want some features such as Redis. You can easily remove what you don't need and proceed as planned.

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Force GitHub README to respect dark mode
(function() {
var style = document.createElement('style');
style.textContent = '
.markdown-body {
color-scheme: dark light;
}
.markdown-body pre { background: #161b22 !important; }
.markdown-body code { background: rgba(110, 118, 129, 0.4) !important; }
.markdown-body table th, .markdown-body table td { border-color: #30363d !important; }
.markdown-body img { background: #0d1117; }
.markdown-body blockquote { border-left-color: #8b949e; }
.markdown-body hr { border-color: #30363d; }
';
document.head.appendChild(style);
})();
}
} catch(__e) { console.warn('[Userscript:GitHub Dark Mode README Fix]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '
fastapi-template/README.md at main · FastAPI-MEA/fastapi-template · GitHub
Skip to content
README.md
Latest commit
History
History
85 lines (68 loc) · 8.14 KB
README.md
File metadata and controls
85 lines (68 loc) · 8.14 KB
Raw
FastAPI Template
A FastAPI template with Redis, Docker and PostgreSQL
Introduction
This FastAPI template was created out of a need for consistent structure for projects with a setup that's easy to understand and use with as minimal additional setup as possible.
What is hoped to be achieved
  • Simplicity; no need for bloated classes and huge utils that you'll likely never use. Everything here should be very much needed in most projects
  • Low barrier for entry; a template that is easy to start with and does not seem too advanced for beginners to use
  • Production-ready; the above does not remove the important fact that this should be always production-ready without obvious faults
  • Consistency; a smell for codebases is you not having a 'knowing' of where certain code is located. A wanted structure is one that's easy to navigate
What is not hoped to be achieved
  • Batteries-included; this template, whilst influenced by Django, does not aim to provide Django-like capabilities or to have a 'Django, but for FastAPI' setup
  • Utility dump; this template will not be where all sorts of utilities are dumped because, 'why not?'.
How to use
  • Copy .example.env into a file, .env
  • Run docker-compose up --build to build and run container. Yes, I expect you to use Docker in this day and age.
The above is enough to run your project except you need more than that if you are working on a real application. So, this:
Personalizing the template
First, head to app/settings and edit Settings.APP_NAME to reflect the name of your application.
Next, you'll want to run pipenv install to ensure you get a Python environment you can attach to your IDE to allow for autocomplete and auto-imports so you don't have yellow and red lines everywhere
After this, we head to the .env to edit some of the values to your taste. Each value is explained in the Config section.
Databases
Databases can be quite dicey and I'm happy to say Alembic is used to handle migrations and whatnots. This coupled with SQLAlchemy makes the world a better place. Whilst PostgreSQL is assumed to be the default database. You can of course edit things to your liking.
  • Create migrations with docker-compose run web alembic revision -m "Migration message here".
  • Run migrations within Docker with docker-compose run web alembic upgrade head.
Config
This section documents configuration options and the meaning of settings values and how to use them.
Environmental Variables
The environmental variables in the .example.env file have specific purposes:
KeyDescriptionDefault
ALLOWED_HOSTThe domain you intend to run this application on0.0.0.0
SECRET_KEYA secret value used to hash and sign tokens and other security-related stuffs.meandyouaretogether
DEBUGA value that evaluates to a boolean to determine whether the app is run in debug mode or production.True
PORTPort the application will run on. If you change this from default, you will have to change the value in the docker-compose.yml file.11000
POSTGRES_USERThis is the default user for the PostgreSQL database. On first run, Docker will use this value to initialize a postgres user so you'll want to set it before your first execution.sasori
POSTGRES_PASSWORDThis is the default password for the PostgreSQL database. On first run, Docker will use this value to initialize a postgres database so you'll want to set it before your first execution.sasori
POSTGRES_DBThis is the default PostgreSQL database created. On first run, Docker will use this value to initialize a postgres database so you'll want to set it before your first executionakatsuki
POSTGRES_TEST_DBThis is the database created for test cases. It is flushed after every test case is run.hebi
POSTGRES_PORTThe port Postgres will run on. Don't change it except you know what you're doing, and if you do, change the value in the docker-compose.yml file.5432
POSTGRES_HOSTThe host set in the docker container where the PostgreSQL instance will be running. Don't change it except you know what you're doing, and if you do, change the value in the docker-compose.yml file.postgres
REDIS_HOSTThe host set in the docker container where the Redis instance will be running. Don't change it except you know what you're doing, and if you do, change the value in the docker-compose.yml file.redis
REDIS_PORTThe port the application will use to connect to Redis. Don't change it except you know what you're doing, and if you do, change the value in the docker-compose.yml file.6379
Application Settings
Application settings are set in the app.settings.Settings class and are used to store app wide configurations. Values are so:
keyDescriptionDefault
APP_TITLEName of the application, will show in the documentationApp Name
ALLOWED_HOSTThe domain you intend to run this application onDerived from .env with key ALLOWED_HOST
SECRET_KEYA secret value used to hash and sign tokens and other security-related stuffs.Derived from .env with key SECRET_KEY
DEBUGA value that evaluates to a boolean to determine whether the app is run in debug mode or production.Derived from .env with key DEBUG
ALLOWED_PORTPort the application will run on. If you change this from default, you will have to change the value in the docker-compose.yml file.Derived from .env with key PORT
DB_USERThis is the default user for the PostgreSQL database. On first run, Docker will use this value to initialize a postgres user so you'll want to set it before your first execution.Derived from .env with key POSTGRES_USER
DB_PASSWORDThis is the default password for the PostgreSQL database. On first run, Docker will use this value to initialize a postgres database so you'll want to set it before your first execution.Derived from .env with key POSTGRES_PASSWORD
DB_DBThis is the default PostgreSQL database created. On first run, Docker will use this value to initialize a postgres database so you'll want to set it before your first executionDerived from .env with key POSTGRES_DB
DB_PORTThe port Postgres will run on. Don't change it except you know what you're doing, and if you do, change the value in the docker-compose.yml file.Derived from .env with key POSTGRES_PORT
DB_HOSTThe host set in the docker container where the PostgreSQL instance will be running. Don't change it except you know what you're doing, and if you do, change the value in the docker-compose.yml file.Derived from .env with key POSTGRES_HOST
DB_URLURL leading to the application databasepostgresql+psycopg2://{DB_USER}:{DB_PASSWORD}@{DB_HOST}:{DB_PORT}/{DB_DB}
TEST_DBThis is the database created for test cases. It is flushed after every test case is run.Derived from .env with key POSTGRES_TEST_DB
TEST_DB_URLURL leading to test databasepostgresql+psycopg2://{DB_USER}:{DB_PASSWORD}@{DB_HOST}:{DB_PORT}/{TEST_DB}
ACCESS_TOKEN_EXPIRY_TIMEDuration in seconds before access token expires60 * 30 (seconds)
REFRESH_TOKEN_EXPIRY_TIMEDuration in seconds before refresh token expires60 * 30 (seconds)
PASSWORD_HASHERHashing algorithm for passwordsCryptContext(schemes=["bcrypt"], deprecated="auto")
JWT_ALGORITHMAlgorithm used to generate JWT tokenHS256
REDIS_HOSTThe host set in the docker container where the Redis instance will be running. Don't change it except you know what you're doing, and if you do, change the value in the docker-compose.yml file.Derived from .env with key REDIS_HOST
REDIS_PORTThe port the application will use to connect to Redis. Don't change it except you know what you're doing, and if you do, change the value in the docker-compose.yml file.Derived from .env with key REDIS_HOST
PAGE_SIZE[Not Implemented] default size of page for paginated items50
I don't want some things
There is the possibility that you may not want some features such as Redis. You can easily remove what you don't need and proceed as planned.

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Highlight search terms from Google/DuckDuckGo/Bing referrer
(function() {
var ref = document.referrer;
var terms = [];
if (ref.includes('google.com') || ref.includes('duckduckgo.com') || ref.includes('bing.com')) {
var url = new URL(ref);
var q = url.searchParams.get('q') || url.searchParams.get('p');
if (q) {
terms = q.split(/\s+/).filter(function(t) { return t.length > 2; });
}
}
if (terms.length === 0) return;
var style = document.createElement('style');
style.textContent = '.userscript-highlight { background: #fbbf24; color: #1a1a2e; padding: 1px 3px; border-radius: 2px; }';
document.head.appendChild(style);
function highlight(node) {
if (node.nodeType === 3) { // text node
var text = node.textContent;
var found = false;
terms.forEach(function(term) {
var regex = new RegExp('(' + term.replace(/[.*+?^${}()|[\]\\]/g, '\\') + ')', 'gi');
if (regex.test(text)) {
found = true;
var frag = document.createDocumentFragment();
var parts = text.split(regex);
parts.forEach(function(part, i) {
if (i % 2 === 0) {
frag.appendChild(document.createTextNode(part));
} else {
var span = document.createElement('span');
span.className = 'userscript-highlight';
span.textContent = part;
frag.appendChild(span);
}
});
node.parentNode.replaceChild(frag, node);
}
});
} else if (node.nodeType === 1 && node.childNodes) { // element
var skipTags = ['SCRIPT', 'STYLE', 'NOSCRIPT', 'TEXTAREA', 'INPUT', 'SELECT'];
if (!skipTags.includes(node.tagName)) {
Array.from(node.childNodes).forEach(highlight);
}
}
}
highlight(document.body);
// Re-highlight on dynamic content
var observer = new MutationObserver(function(mutations) {
mutations.forEach(function(m) {
m.addedNodes.forEach(function(node) {
if (node.nodeType === 1 || node.nodeType === 3) highlight(node);
});
});
});
observer.observe(document.body, { childList: true, subtree: true });
})();
}
} catch(__e) { console.warn('[Userscript:Highlight Search Terms]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '
fastapi-template/README.md at main · FastAPI-MEA/fastapi-template · GitHub
Skip to content
README.md
Latest commit
History
History
85 lines (68 loc) · 8.14 KB
README.md
File metadata and controls
85 lines (68 loc) · 8.14 KB
Raw
FastAPI Template
A FastAPI template with Redis, Docker and PostgreSQL
Introduction
This FastAPI template was created out of a need for consistent structure for projects with a setup that's easy to understand and use with as minimal additional setup as possible.
What is hoped to be achieved
  • Simplicity; no need for bloated classes and huge utils that you'll likely never use. Everything here should be very much needed in most projects
  • Low barrier for entry; a template that is easy to start with and does not seem too advanced for beginners to use
  • Production-ready; the above does not remove the important fact that this should be always production-ready without obvious faults
  • Consistency; a smell for codebases is you not having a 'knowing' of where certain code is located. A wanted structure is one that's easy to navigate
What is not hoped to be achieved
  • Batteries-included; this template, whilst influenced by Django, does not aim to provide Django-like capabilities or to have a 'Django, but for FastAPI' setup
  • Utility dump; this template will not be where all sorts of utilities are dumped because, 'why not?'.
How to use
  • Copy .example.env into a file, .env
  • Run docker-compose up --build to build and run container. Yes, I expect you to use Docker in this day and age.
The above is enough to run your project except you need more than that if you are working on a real application. So, this:
Personalizing the template
First, head to app/settings and edit Settings.APP_NAME to reflect the name of your application.
Next, you'll want to run pipenv install to ensure you get a Python environment you can attach to your IDE to allow for autocomplete and auto-imports so you don't have yellow and red lines everywhere
After this, we head to the .env to edit some of the values to your taste. Each value is explained in the Config section.
Databases
Databases can be quite dicey and I'm happy to say Alembic is used to handle migrations and whatnots. This coupled with SQLAlchemy makes the world a better place. Whilst PostgreSQL is assumed to be the default database. You can of course edit things to your liking.
  • Create migrations with docker-compose run web alembic revision -m "Migration message here".
  • Run migrations within Docker with docker-compose run web alembic upgrade head.
Config
This section documents configuration options and the meaning of settings values and how to use them.
Environmental Variables
The environmental variables in the .example.env file have specific purposes:
KeyDescriptionDefault
ALLOWED_HOSTThe domain you intend to run this application on0.0.0.0
SECRET_KEYA secret value used to hash and sign tokens and other security-related stuffs.meandyouaretogether
DEBUGA value that evaluates to a boolean to determine whether the app is run in debug mode or production.True
PORTPort the application will run on. If you change this from default, you will have to change the value in the docker-compose.yml file.11000
POSTGRES_USERThis is the default user for the PostgreSQL database. On first run, Docker will use this value to initialize a postgres user so you'll want to set it before your first execution.sasori
POSTGRES_PASSWORDThis is the default password for the PostgreSQL database. On first run, Docker will use this value to initialize a postgres database so you'll want to set it before your first execution.sasori
POSTGRES_DBThis is the default PostgreSQL database created. On first run, Docker will use this value to initialize a postgres database so you'll want to set it before your first executionakatsuki
POSTGRES_TEST_DBThis is the database created for test cases. It is flushed after every test case is run.hebi
POSTGRES_PORTThe port Postgres will run on. Don't change it except you know what you're doing, and if you do, change the value in the docker-compose.yml file.5432
POSTGRES_HOSTThe host set in the docker container where the PostgreSQL instance will be running. Don't change it except you know what you're doing, and if you do, change the value in the docker-compose.yml file.postgres
REDIS_HOSTThe host set in the docker container where the Redis instance will be running. Don't change it except you know what you're doing, and if you do, change the value in the docker-compose.yml file.redis
REDIS_PORTThe port the application will use to connect to Redis. Don't change it except you know what you're doing, and if you do, change the value in the docker-compose.yml file.6379
Application Settings
Application settings are set in the app.settings.Settings class and are used to store app wide configurations. Values are so:
keyDescriptionDefault
APP_TITLEName of the application, will show in the documentationApp Name
ALLOWED_HOSTThe domain you intend to run this application onDerived from .env with key ALLOWED_HOST
SECRET_KEYA secret value used to hash and sign tokens and other security-related stuffs.Derived from .env with key SECRET_KEY
DEBUGA value that evaluates to a boolean to determine whether the app is run in debug mode or production.Derived from .env with key DEBUG
ALLOWED_PORTPort the application will run on. If you change this from default, you will have to change the value in the docker-compose.yml file.Derived from .env with key PORT
DB_USERThis is the default user for the PostgreSQL database. On first run, Docker will use this value to initialize a postgres user so you'll want to set it before your first execution.Derived from .env with key POSTGRES_USER
DB_PASSWORDThis is the default password for the PostgreSQL database. On first run, Docker will use this value to initialize a postgres database so you'll want to set it before your first execution.Derived from .env with key POSTGRES_PASSWORD
DB_DBThis is the default PostgreSQL database created. On first run, Docker will use this value to initialize a postgres database so you'll want to set it before your first executionDerived from .env with key POSTGRES_DB
DB_PORTThe port Postgres will run on. Don't change it except you know what you're doing, and if you do, change the value in the docker-compose.yml file.Derived from .env with key POSTGRES_PORT
DB_HOSTThe host set in the docker container where the PostgreSQL instance will be running. Don't change it except you know what you're doing, and if you do, change the value in the docker-compose.yml file.Derived from .env with key POSTGRES_HOST
DB_URLURL leading to the application databasepostgresql+psycopg2://{DB_USER}:{DB_PASSWORD}@{DB_HOST}:{DB_PORT}/{DB_DB}
TEST_DBThis is the database created for test cases. It is flushed after every test case is run.Derived from .env with key POSTGRES_TEST_DB
TEST_DB_URLURL leading to test databasepostgresql+psycopg2://{DB_USER}:{DB_PASSWORD}@{DB_HOST}:{DB_PORT}/{TEST_DB}
ACCESS_TOKEN_EXPIRY_TIMEDuration in seconds before access token expires60 * 30 (seconds)
REFRESH_TOKEN_EXPIRY_TIMEDuration in seconds before refresh token expires60 * 30 (seconds)
PASSWORD_HASHERHashing algorithm for passwordsCryptContext(schemes=["bcrypt"], deprecated="auto")
JWT_ALGORITHMAlgorithm used to generate JWT tokenHS256
REDIS_HOSTThe host set in the docker container where the Redis instance will be running. Don't change it except you know what you're doing, and if you do, change the value in the docker-compose.yml file.Derived from .env with key REDIS_HOST
REDIS_PORTThe port the application will use to connect to Redis. Don't change it except you know what you're doing, and if you do, change the value in the docker-compose.yml file.Derived from .env with key REDIS_HOST
PAGE_SIZE[Not Implemented] default size of page for paginated items50
I don't want some things
There is the possibility that you may not want some features such as Redis. You can easily remove what you don't need and proceed as planned.

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Strip utm_, fbclid, gclid, etc. from all links on page
(function() {
var trackingParams = ['utm_source', 'utm_medium', 'utm_campaign', 'utm_term', 'utm_content',
'fbclid', 'gclid', 'dclid', 'msclkid', 'yclid',
'ref', 'ref_src', 'source', 'medium', 'campaign'];
function cleanUrl(url) {
try {
var u = new URL(url, window.location.origin);
var changed = false;
trackingParams.forEach(function(p) {
if (u.searchParams.has(p)) {
u.searchParams.delete(p);
changed = true;
}
});
return changed ? u.toString() : url;
} catch (e) {
return url;
}
}
function cleanLinks() {
document.querySelectorAll('a[href]').forEach(function(a) {
var clean = cleanUrl(a.href);
if (clean !== a.href) a.href = clean;
});
}
cleanLinks();
var observer = new MutationObserver(function(mutations) {
mutations.forEach(function(m) {
m.addedNodes.forEach(function(node) {
if (node.nodeType === 1) {
if (node.tagName === 'A') cleanLinks();
node.querySelectorAll('a[href]').forEach(function(a) {
var clean = cleanUrl(a.href);
if (clean !== a.href) a.href = clean;
});
}
});
});
});
observer.observe(document.body, { childList: true, subtree: true });
})();
}
} catch(__e) { console.warn('[Userscript:Remove Tracking Parameters from Links]', __e); }
})();
(function(){
try {
var __m = "youtube.com";
var __re = new RegExp('^' + "youtube\\.com" + '
fastapi-template/README.md at main · FastAPI-MEA/fastapi-template · GitHub
Skip to content
README.md
Latest commit
History
History
85 lines (68 loc) · 8.14 KB
README.md
File metadata and controls
85 lines (68 loc) · 8.14 KB
Raw
FastAPI Template
A FastAPI template with Redis, Docker and PostgreSQL
Introduction
This FastAPI template was created out of a need for consistent structure for projects with a setup that's easy to understand and use with as minimal additional setup as possible.
What is hoped to be achieved
  • Simplicity; no need for bloated classes and huge utils that you'll likely never use. Everything here should be very much needed in most projects
  • Low barrier for entry; a template that is easy to start with and does not seem too advanced for beginners to use
  • Production-ready; the above does not remove the important fact that this should be always production-ready without obvious faults
  • Consistency; a smell for codebases is you not having a 'knowing' of where certain code is located. A wanted structure is one that's easy to navigate
What is not hoped to be achieved
  • Batteries-included; this template, whilst influenced by Django, does not aim to provide Django-like capabilities or to have a 'Django, but for FastAPI' setup
  • Utility dump; this template will not be where all sorts of utilities are dumped because, 'why not?'.
How to use
  • Copy .example.env into a file, .env
  • Run docker-compose up --build to build and run container. Yes, I expect you to use Docker in this day and age.
The above is enough to run your project except you need more than that if you are working on a real application. So, this:
Personalizing the template
First, head to app/settings and edit Settings.APP_NAME to reflect the name of your application.
Next, you'll want to run pipenv install to ensure you get a Python environment you can attach to your IDE to allow for autocomplete and auto-imports so you don't have yellow and red lines everywhere
After this, we head to the .env to edit some of the values to your taste. Each value is explained in the Config section.
Databases
Databases can be quite dicey and I'm happy to say Alembic is used to handle migrations and whatnots. This coupled with SQLAlchemy makes the world a better place. Whilst PostgreSQL is assumed to be the default database. You can of course edit things to your liking.
  • Create migrations with docker-compose run web alembic revision -m "Migration message here".
  • Run migrations within Docker with docker-compose run web alembic upgrade head.
Config
This section documents configuration options and the meaning of settings values and how to use them.
Environmental Variables
The environmental variables in the .example.env file have specific purposes:
KeyDescriptionDefault
ALLOWED_HOSTThe domain you intend to run this application on0.0.0.0
SECRET_KEYA secret value used to hash and sign tokens and other security-related stuffs.meandyouaretogether
DEBUGA value that evaluates to a boolean to determine whether the app is run in debug mode or production.True
PORTPort the application will run on. If you change this from default, you will have to change the value in the docker-compose.yml file.11000
POSTGRES_USERThis is the default user for the PostgreSQL database. On first run, Docker will use this value to initialize a postgres user so you'll want to set it before your first execution.sasori
POSTGRES_PASSWORDThis is the default password for the PostgreSQL database. On first run, Docker will use this value to initialize a postgres database so you'll want to set it before your first execution.sasori
POSTGRES_DBThis is the default PostgreSQL database created. On first run, Docker will use this value to initialize a postgres database so you'll want to set it before your first executionakatsuki
POSTGRES_TEST_DBThis is the database created for test cases. It is flushed after every test case is run.hebi
POSTGRES_PORTThe port Postgres will run on. Don't change it except you know what you're doing, and if you do, change the value in the docker-compose.yml file.5432
POSTGRES_HOSTThe host set in the docker container where the PostgreSQL instance will be running. Don't change it except you know what you're doing, and if you do, change the value in the docker-compose.yml file.postgres
REDIS_HOSTThe host set in the docker container where the Redis instance will be running. Don't change it except you know what you're doing, and if you do, change the value in the docker-compose.yml file.redis
REDIS_PORTThe port the application will use to connect to Redis. Don't change it except you know what you're doing, and if you do, change the value in the docker-compose.yml file.6379
Application Settings
Application settings are set in the app.settings.Settings class and are used to store app wide configurations. Values are so:
keyDescriptionDefault
APP_TITLEName of the application, will show in the documentationApp Name
ALLOWED_HOSTThe domain you intend to run this application onDerived from .env with key ALLOWED_HOST
SECRET_KEYA secret value used to hash and sign tokens and other security-related stuffs.Derived from .env with key SECRET_KEY
DEBUGA value that evaluates to a boolean to determine whether the app is run in debug mode or production.Derived from .env with key DEBUG
ALLOWED_PORTPort the application will run on. If you change this from default, you will have to change the value in the docker-compose.yml file.Derived from .env with key PORT
DB_USERThis is the default user for the PostgreSQL database. On first run, Docker will use this value to initialize a postgres user so you'll want to set it before your first execution.Derived from .env with key POSTGRES_USER
DB_PASSWORDThis is the default password for the PostgreSQL database. On first run, Docker will use this value to initialize a postgres database so you'll want to set it before your first execution.Derived from .env with key POSTGRES_PASSWORD
DB_DBThis is the default PostgreSQL database created. On first run, Docker will use this value to initialize a postgres database so you'll want to set it before your first executionDerived from .env with key POSTGRES_DB
DB_PORTThe port Postgres will run on. Don't change it except you know what you're doing, and if you do, change the value in the docker-compose.yml file.Derived from .env with key POSTGRES_PORT
DB_HOSTThe host set in the docker container where the PostgreSQL instance will be running. Don't change it except you know what you're doing, and if you do, change the value in the docker-compose.yml file.Derived from .env with key POSTGRES_HOST
DB_URLURL leading to the application databasepostgresql+psycopg2://{DB_USER}:{DB_PASSWORD}@{DB_HOST}:{DB_PORT}/{DB_DB}
TEST_DBThis is the database created for test cases. It is flushed after every test case is run.Derived from .env with key POSTGRES_TEST_DB
TEST_DB_URLURL leading to test databasepostgresql+psycopg2://{DB_USER}:{DB_PASSWORD}@{DB_HOST}:{DB_PORT}/{TEST_DB}
ACCESS_TOKEN_EXPIRY_TIMEDuration in seconds before access token expires60 * 30 (seconds)
REFRESH_TOKEN_EXPIRY_TIMEDuration in seconds before refresh token expires60 * 30 (seconds)
PASSWORD_HASHERHashing algorithm for passwordsCryptContext(schemes=["bcrypt"], deprecated="auto")
JWT_ALGORITHMAlgorithm used to generate JWT tokenHS256
REDIS_HOSTThe host set in the docker container where the Redis instance will be running. Don't change it except you know what you're doing, and if you do, change the value in the docker-compose.yml file.Derived from .env with key REDIS_HOST
REDIS_PORTThe port the application will use to connect to Redis. Don't change it except you know what you're doing, and if you do, change the value in the docker-compose.yml file.Derived from .env with key REDIS_HOST
PAGE_SIZE[Not Implemented] default size of page for paginated items50
I don't want some things
There is the possibility that you may not want some features such as Redis. You can easily remove what you don't need and proceed as planned.

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Auto-enable theater mode on YouTube
(function() {
function tryTheater() {
var btn = document.querySelector('button[aria-label="Theater mode"], ytd-player #player button[title="Theater mode"]');
if (btn && !btn.classList.contains('activated')) {
btn.click();
}
}
// Try immediately
tryTheater();
// Try after navigation (SPA)
var lastUrl = location.href;
setInterval(function() {
if (location.href !== lastUrl) {
lastUrl = location.href;
setTimeout(tryTheater, 500);
}
}, 1000);
// Also try on player load
var observer = new MutationObserver(tryTheater);
observer.observe(document.body, { childList: true, subtree: true });
})();
}
} catch(__e) { console.warn('[Userscript:YouTube Theater Mode Default]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '
fastapi-template/README.md at main · FastAPI-MEA/fastapi-template · GitHub
Skip to content
README.md
Latest commit
History
History
85 lines (68 loc) · 8.14 KB
README.md
File metadata and controls
85 lines (68 loc) · 8.14 KB
Raw
FastAPI Template
A FastAPI template with Redis, Docker and PostgreSQL
Introduction
This FastAPI template was created out of a need for consistent structure for projects with a setup that's easy to understand and use with as minimal additional setup as possible.
What is hoped to be achieved
  • Simplicity; no need for bloated classes and huge utils that you'll likely never use. Everything here should be very much needed in most projects
  • Low barrier for entry; a template that is easy to start with and does not seem too advanced for beginners to use
  • Production-ready; the above does not remove the important fact that this should be always production-ready without obvious faults
  • Consistency; a smell for codebases is you not having a 'knowing' of where certain code is located. A wanted structure is one that's easy to navigate
What is not hoped to be achieved
  • Batteries-included; this template, whilst influenced by Django, does not aim to provide Django-like capabilities or to have a 'Django, but for FastAPI' setup
  • Utility dump; this template will not be where all sorts of utilities are dumped because, 'why not?'.
How to use
  • Copy .example.env into a file, .env
  • Run docker-compose up --build to build and run container. Yes, I expect you to use Docker in this day and age.
The above is enough to run your project except you need more than that if you are working on a real application. So, this:
Personalizing the template
First, head to app/settings and edit Settings.APP_NAME to reflect the name of your application.
Next, you'll want to run pipenv install to ensure you get a Python environment you can attach to your IDE to allow for autocomplete and auto-imports so you don't have yellow and red lines everywhere
After this, we head to the .env to edit some of the values to your taste. Each value is explained in the Config section.
Databases
Databases can be quite dicey and I'm happy to say Alembic is used to handle migrations and whatnots. This coupled with SQLAlchemy makes the world a better place. Whilst PostgreSQL is assumed to be the default database. You can of course edit things to your liking.
  • Create migrations with docker-compose run web alembic revision -m "Migration message here".
  • Run migrations within Docker with docker-compose run web alembic upgrade head.
Config
This section documents configuration options and the meaning of settings values and how to use them.
Environmental Variables
The environmental variables in the .example.env file have specific purposes:
KeyDescriptionDefault
ALLOWED_HOSTThe domain you intend to run this application on0.0.0.0
SECRET_KEYA secret value used to hash and sign tokens and other security-related stuffs.meandyouaretogether
DEBUGA value that evaluates to a boolean to determine whether the app is run in debug mode or production.True
PORTPort the application will run on. If you change this from default, you will have to change the value in the docker-compose.yml file.11000
POSTGRES_USERThis is the default user for the PostgreSQL database. On first run, Docker will use this value to initialize a postgres user so you'll want to set it before your first execution.sasori
POSTGRES_PASSWORDThis is the default password for the PostgreSQL database. On first run, Docker will use this value to initialize a postgres database so you'll want to set it before your first execution.sasori
POSTGRES_DBThis is the default PostgreSQL database created. On first run, Docker will use this value to initialize a postgres database so you'll want to set it before your first executionakatsuki
POSTGRES_TEST_DBThis is the database created for test cases. It is flushed after every test case is run.hebi
POSTGRES_PORTThe port Postgres will run on. Don't change it except you know what you're doing, and if you do, change the value in the docker-compose.yml file.5432
POSTGRES_HOSTThe host set in the docker container where the PostgreSQL instance will be running. Don't change it except you know what you're doing, and if you do, change the value in the docker-compose.yml file.postgres
REDIS_HOSTThe host set in the docker container where the Redis instance will be running. Don't change it except you know what you're doing, and if you do, change the value in the docker-compose.yml file.redis
REDIS_PORTThe port the application will use to connect to Redis. Don't change it except you know what you're doing, and if you do, change the value in the docker-compose.yml file.6379
Application Settings
Application settings are set in the app.settings.Settings class and are used to store app wide configurations. Values are so:
keyDescriptionDefault
APP_TITLEName of the application, will show in the documentationApp Name
ALLOWED_HOSTThe domain you intend to run this application onDerived from .env with key ALLOWED_HOST
SECRET_KEYA secret value used to hash and sign tokens and other security-related stuffs.Derived from .env with key SECRET_KEY
DEBUGA value that evaluates to a boolean to determine whether the app is run in debug mode or production.Derived from .env with key DEBUG
ALLOWED_PORTPort the application will run on. If you change this from default, you will have to change the value in the docker-compose.yml file.Derived from .env with key PORT
DB_USERThis is the default user for the PostgreSQL database. On first run, Docker will use this value to initialize a postgres user so you'll want to set it before your first execution.Derived from .env with key POSTGRES_USER
DB_PASSWORDThis is the default password for the PostgreSQL database. On first run, Docker will use this value to initialize a postgres database so you'll want to set it before your first execution.Derived from .env with key POSTGRES_PASSWORD
DB_DBThis is the default PostgreSQL database created. On first run, Docker will use this value to initialize a postgres database so you'll want to set it before your first executionDerived from .env with key POSTGRES_DB
DB_PORTThe port Postgres will run on. Don't change it except you know what you're doing, and if you do, change the value in the docker-compose.yml file.Derived from .env with key POSTGRES_PORT
DB_HOSTThe host set in the docker container where the PostgreSQL instance will be running. Don't change it except you know what you're doing, and if you do, change the value in the docker-compose.yml file.Derived from .env with key POSTGRES_HOST
DB_URLURL leading to the application databasepostgresql+psycopg2://{DB_USER}:{DB_PASSWORD}@{DB_HOST}:{DB_PORT}/{DB_DB}
TEST_DBThis is the database created for test cases. It is flushed after every test case is run.Derived from .env with key POSTGRES_TEST_DB
TEST_DB_URLURL leading to test databasepostgresql+psycopg2://{DB_USER}:{DB_PASSWORD}@{DB_HOST}:{DB_PORT}/{TEST_DB}
ACCESS_TOKEN_EXPIRY_TIMEDuration in seconds before access token expires60 * 30 (seconds)
REFRESH_TOKEN_EXPIRY_TIMEDuration in seconds before refresh token expires60 * 30 (seconds)
PASSWORD_HASHERHashing algorithm for passwordsCryptContext(schemes=["bcrypt"], deprecated="auto")
JWT_ALGORITHMAlgorithm used to generate JWT tokenHS256
REDIS_HOSTThe host set in the docker container where the Redis instance will be running. Don't change it except you know what you're doing, and if you do, change the value in the docker-compose.yml file.Derived from .env with key REDIS_HOST
REDIS_PORTThe port the application will use to connect to Redis. Don't change it except you know what you're doing, and if you do, change the value in the docker-compose.yml file.Derived from .env with key REDIS_HOST
PAGE_SIZE[Not Implemented] default size of page for paginated items50
I don't want some things
There is the possibility that you may not want some features such as Redis. You can easily remove what you don't need and proceed as planned.

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Remove or un-stick sticky/fixed headers that block content
(function() {
function unstick() {
document.querySelectorAll('header, nav, [role="banner"], .header, .navbar, .sticky, .fixed-top, [style*="position: fixed"], [style*="position:sticky"]').forEach(function(el) {
if (el.style.position === 'fixed' || el.style.position === 'sticky' || getComputedStyle(el).position === 'fixed' || getComputedStyle(el).position === 'sticky') {
el.style.position = 'static';
el.style.top = 'auto';
el.style.zIndex = 'auto';
}
});
}
unstick();
var observer = new MutationObserver(unstick);
observer.observe(document.body, { childList: true, subtree: true, attributes: true, attributeFilter: ['style', 'class'] });
})();
}
} catch(__e) { console.warn('[Userscript:Kill Sticky Headers]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '
fastapi-template/README.md at main · FastAPI-MEA/fastapi-template · GitHub
Skip to content
README.md
Latest commit
History
History
85 lines (68 loc) · 8.14 KB
README.md
File metadata and controls
85 lines (68 loc) · 8.14 KB
Raw
FastAPI Template
A FastAPI template with Redis, Docker and PostgreSQL
Introduction
This FastAPI template was created out of a need for consistent structure for projects with a setup that's easy to understand and use with as minimal additional setup as possible.
What is hoped to be achieved
  • Simplicity; no need for bloated classes and huge utils that you'll likely never use. Everything here should be very much needed in most projects
  • Low barrier for entry; a template that is easy to start with and does not seem too advanced for beginners to use
  • Production-ready; the above does not remove the important fact that this should be always production-ready without obvious faults
  • Consistency; a smell for codebases is you not having a 'knowing' of where certain code is located. A wanted structure is one that's easy to navigate
What is not hoped to be achieved
  • Batteries-included; this template, whilst influenced by Django, does not aim to provide Django-like capabilities or to have a 'Django, but for FastAPI' setup
  • Utility dump; this template will not be where all sorts of utilities are dumped because, 'why not?'.
How to use
  • Copy .example.env into a file, .env
  • Run docker-compose up --build to build and run container. Yes, I expect you to use Docker in this day and age.
The above is enough to run your project except you need more than that if you are working on a real application. So, this:
Personalizing the template
First, head to app/settings and edit Settings.APP_NAME to reflect the name of your application.
Next, you'll want to run pipenv install to ensure you get a Python environment you can attach to your IDE to allow for autocomplete and auto-imports so you don't have yellow and red lines everywhere
After this, we head to the .env to edit some of the values to your taste. Each value is explained in the Config section.
Databases
Databases can be quite dicey and I'm happy to say Alembic is used to handle migrations and whatnots. This coupled with SQLAlchemy makes the world a better place. Whilst PostgreSQL is assumed to be the default database. You can of course edit things to your liking.
  • Create migrations with docker-compose run web alembic revision -m "Migration message here".
  • Run migrations within Docker with docker-compose run web alembic upgrade head.
Config
This section documents configuration options and the meaning of settings values and how to use them.
Environmental Variables
The environmental variables in the .example.env file have specific purposes:
KeyDescriptionDefault
ALLOWED_HOSTThe domain you intend to run this application on0.0.0.0
SECRET_KEYA secret value used to hash and sign tokens and other security-related stuffs.meandyouaretogether
DEBUGA value that evaluates to a boolean to determine whether the app is run in debug mode or production.True
PORTPort the application will run on. If you change this from default, you will have to change the value in the docker-compose.yml file.11000
POSTGRES_USERThis is the default user for the PostgreSQL database. On first run, Docker will use this value to initialize a postgres user so you'll want to set it before your first execution.sasori
POSTGRES_PASSWORDThis is the default password for the PostgreSQL database. On first run, Docker will use this value to initialize a postgres database so you'll want to set it before your first execution.sasori
POSTGRES_DBThis is the default PostgreSQL database created. On first run, Docker will use this value to initialize a postgres database so you'll want to set it before your first executionakatsuki
POSTGRES_TEST_DBThis is the database created for test cases. It is flushed after every test case is run.hebi
POSTGRES_PORTThe port Postgres will run on. Don't change it except you know what you're doing, and if you do, change the value in the docker-compose.yml file.5432
POSTGRES_HOSTThe host set in the docker container where the PostgreSQL instance will be running. Don't change it except you know what you're doing, and if you do, change the value in the docker-compose.yml file.postgres
REDIS_HOSTThe host set in the docker container where the Redis instance will be running. Don't change it except you know what you're doing, and if you do, change the value in the docker-compose.yml file.redis
REDIS_PORTThe port the application will use to connect to Redis. Don't change it except you know what you're doing, and if you do, change the value in the docker-compose.yml file.6379
Application Settings
Application settings are set in the app.settings.Settings class and are used to store app wide configurations. Values are so:
keyDescriptionDefault
APP_TITLEName of the application, will show in the documentationApp Name
ALLOWED_HOSTThe domain you intend to run this application onDerived from .env with key ALLOWED_HOST
SECRET_KEYA secret value used to hash and sign tokens and other security-related stuffs.Derived from .env with key SECRET_KEY
DEBUGA value that evaluates to a boolean to determine whether the app is run in debug mode or production.Derived from .env with key DEBUG
ALLOWED_PORTPort the application will run on. If you change this from default, you will have to change the value in the docker-compose.yml file.Derived from .env with key PORT
DB_USERThis is the default user for the PostgreSQL database. On first run, Docker will use this value to initialize a postgres user so you'll want to set it before your first execution.Derived from .env with key POSTGRES_USER
DB_PASSWORDThis is the default password for the PostgreSQL database. On first run, Docker will use this value to initialize a postgres database so you'll want to set it before your first execution.Derived from .env with key POSTGRES_PASSWORD
DB_DBThis is the default PostgreSQL database created. On first run, Docker will use this value to initialize a postgres database so you'll want to set it before your first executionDerived from .env with key POSTGRES_DB
DB_PORTThe port Postgres will run on. Don't change it except you know what you're doing, and if you do, change the value in the docker-compose.yml file.Derived from .env with key POSTGRES_PORT
DB_HOSTThe host set in the docker container where the PostgreSQL instance will be running. Don't change it except you know what you're doing, and if you do, change the value in the docker-compose.yml file.Derived from .env with key POSTGRES_HOST
DB_URLURL leading to the application databasepostgresql+psycopg2://{DB_USER}:{DB_PASSWORD}@{DB_HOST}:{DB_PORT}/{DB_DB}
TEST_DBThis is the database created for test cases. It is flushed after every test case is run.Derived from .env with key POSTGRES_TEST_DB
TEST_DB_URLURL leading to test databasepostgresql+psycopg2://{DB_USER}:{DB_PASSWORD}@{DB_HOST}:{DB_PORT}/{TEST_DB}
ACCESS_TOKEN_EXPIRY_TIMEDuration in seconds before access token expires60 * 30 (seconds)
REFRESH_TOKEN_EXPIRY_TIMEDuration in seconds before refresh token expires60 * 30 (seconds)
PASSWORD_HASHERHashing algorithm for passwordsCryptContext(schemes=["bcrypt"], deprecated="auto")
JWT_ALGORITHMAlgorithm used to generate JWT tokenHS256
REDIS_HOSTThe host set in the docker container where the Redis instance will be running. Don't change it except you know what you're doing, and if you do, change the value in the docker-compose.yml file.Derived from .env with key REDIS_HOST
REDIS_PORTThe port the application will use to connect to Redis. Don't change it except you know what you're doing, and if you do, change the value in the docker-compose.yml file.Derived from .env with key REDIS_HOST
PAGE_SIZE[Not Implemented] default size of page for paginated items50
I don't want some things
There is the possibility that you may not want some features such as Redis. You can easily remove what you don't need and proceed as planned.

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Universal Dark Mode - works on any site
(function() {
var enabled = true;
function applyDarkMode() {
if (!enabled) return;
// Create style element if it doesn't exist
var style = document.getElementById('universal-dark-mode-style');
if (!style) {
style = document.createElement('style');
style.id = 'universal-dark-mode-style';
document.head.appendChild(style);
}
// Dark mode CSS - inverts colors but preserves images/video
style.textContent = '
/* Invert everything except media */
html {
filter: invert(1) hue-rotate(180deg) !important;
background: #1a1a2e !important;
}
/* Restore images, videos, iframes, canvas */
img, video, iframe, canvas, svg, picture, [style*="background-image"] {
filter: invert(1) hue-rotate(180deg) !important;
}
/* Preserve specific elements that should not be inverted */
.no-dark-mode, .no-dark-mode *,
[data-theme="light"], [data-theme="light"],
.ace_editor, .ace_editor *,
.CodeMirror, .CodeMirror *,
.monaco-editor, .monaco-editor *,
.markdown-body pre, .markdown-body pre *,
.highlight, .highlight *,
pre code, pre code * {
filter: none !important;
}
/* Fix common UI elements */
.modal, .popup, .dropdown-menu, .tooltip, .popover {
filter: invert(1) hue-rotate(180deg) !important;
background: #2d2d44 !important;
border-color: #444 !important;
}
/* Scrollbars */
::-webkit-scrollbar { background: #1a1a2e !important; }
::-webkit-scrollbar-thumb { background: #444 !important; }
::-webkit-scrollbar-thumb:hover { background: #555 !important; }
/* Selection */
::selection { background: #4ecdc4 !important; color: #1a1a2e !important; }
::-moz-selection { background: #4ecdc4 !important; color: #1a1a2e !important; }
';
}
function removeDarkMode() {
var style = document.getElementById('universal-dark-mode-style');
if (style) style.remove();
}
// Toggle with Alt+Shift+D
document.addEventListener('keydown', function(e) {
if (e.altKey && e.shiftKey && e.key === 'D') {
e.preventDefault();
enabled = !enabled;
if (enabled) {
applyDarkMode();
console.log('[Universal Dark Mode] Enabled');
} else {
removeDarkMode();
console.log('[Universal Dark Mode] Disabled');
}
}
});
// Apply on load
applyDarkMode();
// Re-apply on dynamic content
var observer = new MutationObserver(function(mutations) {
if (enabled && !document.getElementById('universal-dark-mode-style')) {
applyDarkMode();
}
});
observer.observe(document.head, { childList: true });
console.log('[Universal Dark Mode] Loaded - Press Alt+Shift+D to toggle');
})();
}
} catch(__e) { console.warn('[Userscript:Universal Dark Mode]', __e); }
})();
})();
fastapi-template/README.md at main · FastAPI-MEA/fastapi-template · GitHub
Skip to content
README.md
Latest commit
History
History
85 lines (68 loc) · 8.14 KB
README.md
File metadata and controls
85 lines (68 loc) · 8.14 KB
Raw
FastAPI Template
A FastAPI template with Redis, Docker and PostgreSQL
Introduction
This FastAPI template was created out of a need for consistent structure for projects with a setup that's easy to understand and use with as minimal additional setup as possible.
What is hoped to be achieved
  • Simplicity; no need for bloated classes and huge utils that you'll likely never use. Everything here should be very much needed in most projects
  • Low barrier for entry; a template that is easy to start with and does not seem too advanced for beginners to use
  • Production-ready; the above does not remove the important fact that this should be always production-ready without obvious faults
  • Consistency; a smell for codebases is you not having a 'knowing' of where certain code is located. A wanted structure is one that's easy to navigate
What is not hoped to be achieved
  • Batteries-included; this template, whilst influenced by Django, does not aim to provide Django-like capabilities or to have a 'Django, but for FastAPI' setup
  • Utility dump; this template will not be where all sorts of utilities are dumped because, 'why not?'.
How to use
  • Copy .example.env into a file, .env
  • Run docker-compose up --build to build and run container. Yes, I expect you to use Docker in this day and age.
The above is enough to run your project except you need more than that if you are working on a real application. So, this:
Personalizing the template
First, head to app/settings and edit Settings.APP_NAME to reflect the name of your application.
Next, you'll want to run pipenv install to ensure you get a Python environment you can attach to your IDE to allow for autocomplete and auto-imports so you don't have yellow and red lines everywhere
After this, we head to the .env to edit some of the values to your taste. Each value is explained in the Config section.
Databases
Databases can be quite dicey and I'm happy to say Alembic is used to handle migrations and whatnots. This coupled with SQLAlchemy makes the world a better place. Whilst PostgreSQL is assumed to be the default database. You can of course edit things to your liking.
  • Create migrations with docker-compose run web alembic revision -m "Migration message here".
  • Run migrations within Docker with docker-compose run web alembic upgrade head.
Config
This section documents configuration options and the meaning of settings values and how to use them.
Environmental Variables
The environmental variables in the .example.env file have specific purposes:
KeyDescriptionDefault
ALLOWED_HOSTThe domain you intend to run this application on0.0.0.0
SECRET_KEYA secret value used to hash and sign tokens and other security-related stuffs.meandyouaretogether
DEBUGA value that evaluates to a boolean to determine whether the app is run in debug mode or production.True
PORTPort the application will run on. If you change this from default, you will have to change the value in the docker-compose.yml file.11000
POSTGRES_USERThis is the default user for the PostgreSQL database. On first run, Docker will use this value to initialize a postgres user so you'll want to set it before your first execution.sasori
POSTGRES_PASSWORDThis is the default password for the PostgreSQL database. On first run, Docker will use this value to initialize a postgres database so you'll want to set it before your first execution.sasori
POSTGRES_DBThis is the default PostgreSQL database created. On first run, Docker will use this value to initialize a postgres database so you'll want to set it before your first executionakatsuki
POSTGRES_TEST_DBThis is the database created for test cases. It is flushed after every test case is run.hebi
POSTGRES_PORTThe port Postgres will run on. Don't change it except you know what you're doing, and if you do, change the value in the docker-compose.yml file.5432
POSTGRES_HOSTThe host set in the docker container where the PostgreSQL instance will be running. Don't change it except you know what you're doing, and if you do, change the value in the docker-compose.yml file.postgres
REDIS_HOSTThe host set in the docker container where the Redis instance will be running. Don't change it except you know what you're doing, and if you do, change the value in the docker-compose.yml file.redis
REDIS_PORTThe port the application will use to connect to Redis. Don't change it except you know what you're doing, and if you do, change the value in the docker-compose.yml file.6379
Application Settings
Application settings are set in the app.settings.Settings class and are used to store app wide configurations. Values are so:
keyDescriptionDefault
APP_TITLEName of the application, will show in the documentationApp Name
ALLOWED_HOSTThe domain you intend to run this application onDerived from .env with key ALLOWED_HOST
SECRET_KEYA secret value used to hash and sign tokens and other security-related stuffs.Derived from .env with key SECRET_KEY
DEBUGA value that evaluates to a boolean to determine whether the app is run in debug mode or production.Derived from .env with key DEBUG
ALLOWED_PORTPort the application will run on. If you change this from default, you will have to change the value in the docker-compose.yml file.Derived from .env with key PORT
DB_USERThis is the default user for the PostgreSQL database. On first run, Docker will use this value to initialize a postgres user so you'll want to set it before your first execution.Derived from .env with key POSTGRES_USER
DB_PASSWORDThis is the default password for the PostgreSQL database. On first run, Docker will use this value to initialize a postgres database so you'll want to set it before your first execution.Derived from .env with key POSTGRES_PASSWORD
DB_DBThis is the default PostgreSQL database created. On first run, Docker will use this value to initialize a postgres database so you'll want to set it before your first executionDerived from .env with key POSTGRES_DB
DB_PORTThe port Postgres will run on. Don't change it except you know what you're doing, and if you do, change the value in the docker-compose.yml file.Derived from .env with key POSTGRES_PORT
DB_HOSTThe host set in the docker container where the PostgreSQL instance will be running. Don't change it except you know what you're doing, and if you do, change the value in the docker-compose.yml file.Derived from .env with key POSTGRES_HOST
DB_URLURL leading to the application databasepostgresql+psycopg2://{DB_USER}:{DB_PASSWORD}@{DB_HOST}:{DB_PORT}/{DB_DB}
TEST_DBThis is the database created for test cases. It is flushed after every test case is run.Derived from .env with key POSTGRES_TEST_DB
TEST_DB_URLURL leading to test databasepostgresql+psycopg2://{DB_USER}:{DB_PASSWORD}@{DB_HOST}:{DB_PORT}/{TEST_DB}
ACCESS_TOKEN_EXPIRY_TIMEDuration in seconds before access token expires60 * 30 (seconds)
REFRESH_TOKEN_EXPIRY_TIMEDuration in seconds before refresh token expires60 * 30 (seconds)
PASSWORD_HASHERHashing algorithm for passwordsCryptContext(schemes=["bcrypt"], deprecated="auto")
JWT_ALGORITHMAlgorithm used to generate JWT tokenHS256
REDIS_HOSTThe host set in the docker container where the Redis instance will be running. Don't change it except you know what you're doing, and if you do, change the value in the docker-compose.yml file.Derived from .env with key REDIS_HOST
REDIS_PORTThe port the application will use to connect to Redis. Don't change it except you know what you're doing, and if you do, change the value in the docker-compose.yml file.Derived from .env with key REDIS_HOST
PAGE_SIZE[Not Implemented] default size of page for paginated items50
I don't want some things
There is the possibility that you may not want some features such as Redis. You can easily remove what you don't need and proceed as planned.