DEV Community: Timo Reusch

Federated avatars in authentik

Timo Reusch — Sat, 15 Nov 2025 01:38:01 +0000

By default, authentik shows the users initials as an avatar or pulls the profile picture from Gravatar (if one is available).
However, unfortunately it does not offer users to set avatars directly in the interface. In this article (based on this GitHub discussion), we will add this functionality.

Tested with authentik 2025.10.0

1. Create a folder to store your avatars

Avatar image files will be stored in a sub-directory /media/user-avatars/ Let's create this:

mkdir -p /authentik/media/user-avatars/

Make sure the directory is writable by authentik, e.g.:

chown -R 1000:1000 /authentik/media/user-avatars/
chmod -R 644 /authentik/media/user-avatars/

2. Create the prompts

This is where we define the fields for uploading an image and deleting it.

Head to Administration Settings → Flows and Stages → Prompts
Create a new file-prompt:
- Name: e.g. default-user-settings-field-avatar
- Field Key: attributes.avatar
- Label (how its shown to the user in the UI): e.g. User Avatar
- Type: File
- Order: e.g. 205
Create a new checkbox-prompt
- Name: e.g. default-user-settings-field-avatar-reset
- Field Key: attributes.avatar_reset
- Label: e.g. Delete Avatar
- Type: Checkbox
- Order: e.g. 206

3. Create a custom expression policy

This is where the uploaded file is saved, any previous file is removed, and the new URL is prepared to be stored in the user profile.

Head to Administration Settings → Customization → Policies
Click on Create
Select Expression Policy
Name it e.g.
Paste the following expression. Make sure to set your AK_DOMAIN (and optionally FILE_PATH in case you changed it). You can also adjust MAX_UPLOAD_SIZE and ACCEPTED_FILE_TYPES:

AK_DOMAIN = "authentik.company"
FILE_PATH = "/media/user-avatars/"
URL_PATH = f"https://{AK_DOMAIN}{FILE_PATH}"
MAX_UPLOAD_SIZE = 5 * 1024 * 1024
ACCEPTED_FILE_TYPES = {
  "image/png": "png",
  "image/jpeg": "jpeg",
  "image/webp": "webp",
  # "image/svg+xml": "svg", # if you trust your users not to upload malicious svg files
  "image/gif": "gif",
  "image/bmp": "bmp",
  "image/vnd.microsoft.icon": "ico"
}

EMPTY_FILE = "data:application/octet-stream;base64,"

# from humanize import naturalsize
from uuid import uuid4
from base64 import b64decode
from os import remove
from os.path import isfile

def naturalsize(value, binary=False, format="%.1f"):
    """
    Convert a size in bytes into a human-readable format.

    :param value: size in bytes
    :param binary: if True, use 1024-based units (KiB, MiB), otherwise 1000-based (KB, MB)
    :param format: number format string (default "%.1f")
    :return: string like "10.5 MB"
    """
    units = ["B", "KB", "MB", "GB", "TB", "PB", "EB"]
    if binary:
        step = 1024.0
        units = ["B", "KiB", "MiB", "GiB", "TiB", "PiB", "EiB"]
    else:
        step = 1000.0

    size = float(value)
    for unit in units:
        if abs(size) < step:
            return (format % size).rstrip("0").rstrip(".") + " " + unit
        size /= step
    return (format % size).rstrip("0").rstrip(".") + " " + units[-1]

def remove_old_avatar_file():
  if not request.user.is_authenticated:
    return
  avatar = request.user.attributes.get("avatar", None)
  if avatar:
    components = avatar.split(URL_PATH, 1)
    if len(components) == 2 and components[0] == "" and components[1]:
      old_filename = FILE_PATH + components[1]
      if isfile(old_filename):
        remove(old_filename)

prompt_data = request.context.get("prompt_data")
avatar_overwritten = False

if "avatar" in prompt_data.get("attributes", {}):
  avatar = prompt_data["attributes"]["avatar"]
  if avatar == EMPTY_FILE:
    # No upload file specified, ignore
    del prompt_data["attributes"]["avatar"]
  else:
    avatar_mimetype = avatar.split("data:", 1)[1].split(";", 1)[0]
    if avatar_mimetype not in ACCEPTED_FILE_TYPES:
      ak_message("User avatar must be an image (" + ", ".join(ACCEPTED_FILE_TYPES.values()) + ") file.")
      return False
    # Now we know it is one of the accepted image file types
    avatar_base64 = avatar.split(",", 1)[1]
    avatar_binary = b64decode(avatar_base64)
    avatar_size = len(avatar_binary)
    if avatar_size > MAX_UPLOAD_SIZE:
      ak_message("User avatar file size must not exceed " + naturalsize(MAX_UPLOAD_SIZE, binary = True, format = "%.0f") + ".")
      return False
    # Set a random file name with extension reflecting mime type
    avatar_filename = str(uuid4()) + "." + ACCEPTED_FILE_TYPES[avatar_mimetype]
    try:
      with (open(FILE_PATH + avatar_filename, "wb") as f):
        f.write(avatar_binary)
    except:
      ak_message("Could not write avatar file.")
      return False
    avatar_overwritten = True
    remove_old_avatar_file()
    prompt_data["attributes"]["avatar"] = URL_PATH + avatar_filename

if "avatar_reset" in prompt_data.get("attributes", {}):
  del prompt_data["attributes"]["avatar_reset"]
  # If a new avatar was uploaded, previous avatar is deleted anyway, so ignore
  if not avatar_overwritten:
    prompt_data["attributes"]["avatar"] = None
    remove_old_avatar_file()
    ak_message("Deleted user avatar.")

return True

4. Modify the user prompt stage

Head to Administration Settings → Flows and Stages → Stages
Select the default-user-settings PromptStage (or create a new, custom prompt stage, if you prefer)
Add default-user-settings-field-avatar and default-user-settings-field-avatar-reset to the Fields section (alongside the default values).
Add default-user-settings-avatar-authorization to the Validation Policies (alongside the default values).

5. Enable `attributes.avatar`

Head to Administration Settings → System → Settings
For Avatars, set the value to attributes.avatar,gravatar,initials. You can change order if you like (in this example gravatar is the fallback, if attributes.avatar=None and initials if gravatar is also none.

6. Test it out!

Go to your user profile settings if/user/#/settings. You should now see the fields we just created and be able to upload and delete your profile picture! When refreshing the site, it will be displayed in the top right where your initials used to be.

You can double-check the media/user-avatars/ folder on your server.

Get the lines of code in your JetBrains IDE (quick)

Timo Reusch — Tue, 06 May 2025 13:10:10 +0000

Some stats about a project are always interesting. There used to be an IntelliJ plugin offering exactly that, but unfortunately, it seems like it is not actively maintained any longer.

A quick and elegant solution on Macs and Linux devices is running the following command from your project root:

find . -name '*.<fileType>' | xargs wc -l

Create a Python virtual environment (quick)

Timo Reusch — Fri, 31 Jan 2025 14:31:58 +0000

When working with Python, it’s best practice to use a separate virtual environment for each project to avoid dependency conflicts. Tools like PyCharm create virtual environments automatically, but you can just as easily do it via the command line:

cd to your project root and create a new virtual environment

Running this command will create a .venv folder (a common name, but you can customize it if needed):
```
python3 -m venv .venv
```
Activate the virtual environment
```
source .venv/bin/activate
```
Once activated, your console should look like this:
```
(.venv) <user>@<computer> <FolderName>
```

You can leave the virtual environment by executing deactivate.

Set up MariaDB on macOS (quick)

Timo Reusch — Sun, 25 Feb 2024 18:46:10 +0000

1. Install MariaDB

MariaDB Server can be easily installed using Homebrew:

brew install mariadb

2. Start the server

mysql.server start

You can also configure auto-start using Homebrew's services functionality:
brew services start mariadb

3. Log in to the server

After starting the server, you can log in as the mysql user or as root (using sudo mysql -u root)

4. Configure a database

Create a database

After logging into the server with the command above, execute

mysql> CREATE DATABASE your_database_name;

Note that the semicolon (;) is mandatory!

Create a user

First, create the user for localhost:

mysql> CREATE USER 'app_user'@'localhost' IDENTIFIED BY 'Password123!';

mysql> GRANT ALL PRIVILEGES ON *.* TO 'app_user'@'localhost'
-> WITH GRANT OPTION;

Next, create the user for an arbitrary server:

mysql> CREATE USER 'app_user'@'%' IDENTIFIED BY 'Password123!';

mysql> GRANT ALL PRIVILEGES ON *.* TO 'app_user'@'%'
-> WITH GRANT OPTION;

Good to know
If any of the specified accounts, or any permissions for the specified accounts, already exist, then the server returns ERROR 1396 (HY000). If an error occurs, CREATE USER will still create the accounts that do not result in an error. Only one error is produced for all users which have not been created:
ERROR 1396 (HY000): Operation CREATE USER failed for 'u1'@'%','u2'@'%'

After completing those steps, the database is ready and should also be manageable using tools like DataGrip.

How to structure big FastAPI projects

Timo Reusch — Sun, 07 Jan 2024 01:40:23 +0000

The whole setup is available as a template on GitHub

When I first started using FastAPI, I found it very challenging to structure my project properly. Writing everything in one or two files is not exactly ideal when it comes to bigger projects.

So the basic requirement was to create an easy-to-follow project structure that integrates SQLAlchemy and Unit Tests nicely. Furthermore, I wanted to achieve a clear separation of concerns by using different modules.

Basic folder structure

We structure our project into two modules: src and test:

.
└── backend/
    ├── src/
    │   ├── config/
    │   ├── routes/
    │   ├── util/
    │   └── __init__.py
    ├── test/
    │   ├── routes/
    │   ├── test_util/
    │   ├── __init.py__
    │   ├── app_test.py
    │   └── conftest.py
    ├── main.py
    └── requirements.txt

Basic FastAPI

The application start is the main.py. In this file, we can define our FastAPI server as expected:

from fastapi import FastAPI
from fastapi.middleware.cors import CORSMiddleware
from starlette.responses import RedirectResponse

app = FastAPI(
    title=APP_NAME,
    version=VERSION
)

app.add_middleware(
    CORSMiddleware,
    allow_origins=["*"],
    allow_methods=["*"],
    allow_headers=["*"],
    allow_credentials=True
)

# Redirect / -> Swagger-UI documentation
@app.get("/")
def main_function():
    """
    # Redirect
    to documentation (`/docs/`).
    """
    return RedirectResponse(url="/docs/")

Some general app parameters are defined in the config.py located in /config. Those values could also be environment variables later in deployment.

APP_NAME = "My fancy app"
VERSION = "v1.0.0"

Routes

When it comes to the individual routes, I took inspiration from SvelteKit. They use file-based routing, which makes searching for a certain piece of code pretty straightforward — you just have to traverse the file structure the same way the URL is structured. This seems like a good idea for APIs, too, so I went with this approach, despite having the downside of creating files with the same names over and over again.

Let's say we build a very basic API for booking meeting rooms. We would probably face the following endpoints:

/rooms          GET
                POST
                DELETE
                PUT

/bookings       GET
                POST
                DELETE
                PUT

/users          GET
                POST
                DELETE
                PUT

As well as the following database tables:

rooms           bookings                users
=========       =============           =====
id              id                      id
name            booker_id               name
capacity        starting_time           mail
building        ending_time
                room_id

In this example, we would create three folders inside the routes-directory:

.
└── backend/
    └── src/
        └── routes/
            ├── users
            ├── bookings
            ├── rooms
            └── __init.py__

Additionally, I like to keep the authentication-logic on its own route.

Inside each of these folders, we would have three files:

main.py: Place for the actual API-Endpoint-Function, could look like this:

@router.get("/")
async def get_all_users(user: User = 
Depends(get_current_active_user),
                        db: Session = Depends(get_db)):
    """
    # Get a list of all users

    **Access:**
    - Admins get a list of all users.
    - Users with lower rights get a list with only the enabled users.
    """
    if user.super_admin:
        return get_users_admin(db=db)
    else:
        return get_users(db=db)

controller.py: Handles your logic

def get_user_by_id(user_id: int, db: Session):
    user = db.query(User).filter(User.id == user_id).first()

    if not user:
        raise HTTPException(
            status_code=404,
            detail="There is no user with this id."
        )

    return user

schemas.py: Home to Pydantic schemas relevant for this route

To use those routes, we have to create a router for each route in the corresponding {route}/main.py:

router = APIRouter(
    prefix="/users",
    tags=["Users"],
    responses={404: {"description": "Not found"}},
)

We then import those routers into the applications main.py:

from src.routes import bookings, users

# ---- Do this for all of your routes ----
app.include_router(users.main.router)
app.include_router(bookings.main.router)
# ----------------------------------------

Database integration

With the above steps done, we have successfully organized our FastAPI server into several folders. However, access to a database is still not possible. We will use SQLAlchemy as an ORM.

Following the FastAPI-docs, we first need to specify our connection parameters inside src/config/database.py:

from sqlalchemy import create_engine
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import sessionmaker

db_username = "user"
db_password = "password123"
db_url = "127.0.0.1:3306"
db_name = "example"

connectionString = f'mariadb+pymysql://{db_username}:{db_password}@{db_url}/{db_name}'

# use echo=True for debugging
engine = create_engine(connectionString, echo=False)
SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)

Base = declarative_base()

Depending on which database you use, you may need to modify the connection string and install a different pip-package. For MariaDB, the relevant ones are mariadb, pymysql and SQLAlchemy==1.4.36.

Keep in mind, that SQLAlchemy >= v2.0 introduced serious changes, so you will need to modify the template, if you wish to use the new version!

For interacting with the database from an endpoint called, we will use dependency injection. We define our dependency in src/util/db_dependency.py:

from src.config.database import SessionLocal


def get_db():
    db = SessionLocal()
    try:
        yield db
    finally:
        db.close()

We can now create db-model-files for every route, e.g. src/routes/users/models.py:

from src.config.database import Base
from sqlalchemy import Column, String, Integer


class User(Base):
    __tablename__ = 'users'

    id = Column(Integer, primary_key=True, autoincrement=True)
    name = Column(String(length=50))
    mail = Column(String(length=100))

Lastly, we import every model into our global main.py and create the specified tables from there:

from src.config.database import engine

from src.routes.users import main, models
from src.routes.auth import main, models

users.models.Base.metadata.create_all(bind=engine)
auth.models.Base.metadata.create_all(bind=engine)

Unit tests

For Unit Tests, /test mirrors the folder structure of /src. The tests are organized in the same routing-structure as before.

This article explained the basic idea behind the project structure. You can find a complete template on GitHub. It also includes authentication, an email template (e.g. notifying the user about security issues or sending password reset links) and the full test configuration.

Even though this structure has worked well for me in some projects, there may be even better organized approaches out there. So, please let me know in the comments: what are your opinions on this project structure & how do you approach FastAPI projects?

Setting up Sass, Bootstrap, Icons, and Notifications in SvelteKit

Timo Reusch — Mon, 05 Dec 2022 01:20:46 +0000

Just as many other developers out there I love Svelte. But setting up a new project with all your preferred libraries and functions, can be quite a hustle. In this article I want to show you how you can set up Bootstrap & Sass, Material Icons and Notifications the easy way.

Bootstrap

Bootstrap is my favorite CSS-library by far: I really like the look they now have with v5 and most of the time I prefer to just modify an existing component then building it out from scratch. To use pure Bootstrap (not a modified version for Svelte) in your project, there is a great adder called Svelte Add, that does all the work for you. In your project directory, make sure you committed all changes and then run

npx svelte-add@latest

The CLI will guide you through the installation:

┌  Welcome to Svelte Add!
│
◇  What would you like to add to your project?
│  Bootstrap
│
◇  Do you want to use sass? (css = faster, sass = better customization)
│  Yes
│
◇  Do you want to add JavaScript (required for some components like dropdowns)?
│  Yes
│
◇  Which package manager to want to install dependencies with?
│  npm
│
◇  Successfully installed dependencies
│
◇  Next steps ─╮
│              │
│              │
│              │
├──────────────╯
│
└  You're all set!

By installing Bootstrap this way, Sass is also enabled.

You can find more information about the project on GitHub. Generally speaking, svelte-add can safe you a lot of time, since its also capable of setting up Jest, Storybook and other libraries for you.

Material Icons

Svelte Material Icons is an NPM package that gives you access to a large set of material icons as a Svelte-component, what makes integration much easier. In fact, the library offers even more icons than Googles official icon set, since they rely on materialdesignicons.com. Just run:

npm i svelte-material-icons

After that, you can integrate your icons just like you would do with any Svelte component:

<script>
  import Check from "svelte-material-icons/Check.svelte";
</script>

<Check {color} {size} {width} {height} {viewBox} />

Notifications

Notifications in the style of macOS or Windows have also become a thing in modern web applications. The library Svelte notifications makes this super easy:

npm install --save svelte-notifications

After that, you have to pass your Main-View to the <Notification> component — the perfect place for this is a layout-file. You can now trigger your notifications from any component that uses this layout:

import { getNotificationsContext } from 'svelte-notifications';

const { addNotification } = getNotificationsContext();

const handleButtonClick = () => {
  addNotification({
    position: 'bottom-right',
    heading: 'hi i am custom notification',
    type: 'error',
    description: 'lorem ipsum',
  });
}

Do you know other libraries, that make working with SvelteKit easier? Feel free to share them in the comments!

Using Sass in your JavaFX project

Timo Reusch — Mon, 05 Dec 2022 01:08:32 +0000

Sass is a beautiful tool — it makes your life so much easier when building for the web. That’s why I also wanted to use it in a JavaFX project I was working on.

In case you’re not familiar with it: Sass is a CSS-Preprocessor that can be seen as a superset of CSS. It provides functionality like functions (called “mixings”), variables and other useful features. Sass files can end on .sass (old, deprecated way) or .scss (modern go-to approach). However, before being able to use the files in a project, they need to be compiled to normal CSS. This video provides a quick and easy introduction.

Ways to compile to CSS

The Sass compiler was originally written in ruby, however, there exists a modern version written in Dart. How you compile to CSS doesn’t really matter — the only important thing is, that the CSS file is included in your application build.

Using a Maven Build-Plugin

The first way would be to configure Maven (or whatever build-tool you are using), so that it compiles the files to CSS while compiling the whole Java-Program. There are multiple librarys for that, the best one (at least from my point of view) being this one . There are other projects, that try to do the same, like described in this blog post.
However, there is a problem with this approach: to make the Scene-Builder work properly, the CSS actually needs to be compiled before runtime. That means, it has to happen on the fly, as soon as we make a change in our files.

Compiling with the help of IntelliJ

Instead of compiling to CSS through Maven or manually, we can let our IDE do this job for us: First of all, we need to install the Sass compiler on our local machine, using Choco, Homebrew, or NPM:

# Homebrew
brew install sass/sass/sass

# NPM
sudo npm install -g sass

# Chocolatey
choco install sass

Next, lets fire up IntelliJ and install these two plugins from the settings-pane:

Sass (comes bundled with the IDE normally)
File Watchers

After that, go to Preferences → Tools → File Watchers, click on the “+”-Icon and select “SCSS”. The dialog you’re facing should look like this:

Click on “OK” — congratulations: now every time we make a change in our .scss-files, they are automatically compiled to standard CSS.

Now all there is left to do, is configuring our project, so that the right file is selected. Your structure should look like this:

src/
├─ main/
│ ├─ java/
│ │ ├─ com.company.example/
│ │ │ ├─ HelloApplication.java
│ │ │ ├─ HelloController.java
│ ├─ resources/
│ │ ├─ com.company.example/
│ │ │ ├─ META-INF/
│ │ │ │ ├─ MANIFEST.MF
│ │ │ ├─ sass/
│ │ │ │ ├─ _colors.scss
│ │ │ │ ├─ style.scss
│ │ │ ├─ hello-view.fxml

The style.css will be automatically generated inside of the style.scss (meaning style.scss will become a kind-of folder):

style.scss/
├─ style.css
├─ style.css.map

Last thing to do, is referencing the CSS-File from the .fxml. For that, go to the Top-Level Element (e.g. a Border Pane) and attach stylesheets="@sass/style.css" to it.

Thats it! You can now use Sass to make JavaFXs CSS a bit less painful.

Python from A-Z in 10 minutes

Timo Reusch — Mon, 05 Dec 2022 00:39:56 +0000

Introduction

We all know this: just the moment you begin to like your newly learned programming language, your boss comes around and wants you to work on something completely different. Sure, concepts are similar or even identical - but as we all know: each language has their own peculiarities and for getting started, you are mostly just interested in those and the syntax.

This post wants to achieve exactly that: giving you a brief overview of the most important syntax and concepts in Python as compact as possible.

General

Python is an interpreted language.
Python uses indentation instead of brackets, so format your code properly!
Whitespaces matter
No strong typing

Comments

# This is a comment

There is no intended way for a multiline comment like for example /* ... */ in Java. However, we can use docstrings in that case. Note, that here the indentation also matters!

def addNumbers(num1, num2, num3):
    """
    A function that returns the sum of
    3 numbers
    """
    return num1 + num2 + num3

Variables

General

Creation
```
x = 5
y = "Hello
k = 5.2
```
In case you have a long integer value (e.g. 1.000.000), you can also write it like this 1_000_000.
Casting

If you want to specify the data type, this can be done using casting:
```
y = str(3)
x = float(7)
z = int(5)
```
Type
The type function returns the data type of the variable
```
print(type(y))
```
Illegal names

Variables can not start with a number, contain a letter or empty space:
```
2myvar = "John"
my-var = "John"
my var = "John"
```

Naming convention

The right way to name them is to use snake_case:

myvar = "John"
my_var = "John"
_my_var = "John"
myVar = "John"
MYVAR = "John"
myvar2 = "John"

Data types

Data type	Example
str	`x = "Hello World"`
int	`x = 20`
float	`x = 20.5`
complex	`x = 2j` (`j`is the imaginary part)
bool	`x = True` (`true` does not work!)
bytes	`x = b"Hello"`

Strings

Multiline

a = """Lorem ipsum dolor sit amet, 
consectetur adipiscing elit,
sed do eiusmod tempor incididunt
ut labore et dolore magna aliqua."""

Strings are arrays

Strings in Python are arrays of bytes representing unicode characters. Square brackets can be used to access elements of the string:
```
a = "Hello, World!"
print(a[1])
```
Looping over Strings

Since strings are arrays, we can loop over the single characters using a for loop.
```
for x in "foo":
print(x)
```
Getting the length: len(a)

Check for a word

To check for a certain phrase or character in a string, we can use in:

txt = "The best things in life are free!"
print("free" in txt)

# Used in a if-case
if "free" in txt:
    print("Yes, 'free' is present.")

Slicing

a = "Hello, World!"

# Get the characters from position x to position y (not included)
print(a[x:y])

# Get the characters from the start to position x (not included)
print(a[:x])

# Get the characters from position x, and all the way to the end
print(a[x:])

Splitting

# returns ['Hello', ' World!']
print(a.split(","))

Upper/Lower case
```
a.upper()
a.lower()
```

Remove whitespace

a = " Hello, World! "

# returns "Hello, World!"
print(a.strip())

Replace

print(a.replace("H", "J")) # returns "Jalllo, World!"

Concatenation

c = a + " bla " + c0

But be careful with numbers!

# You can't do:
age = 36
txt = "My name is John, I am " + age
print(txt)

# Instead:
age = 36
print("My name is John, and I am" + format(age))

Operators

The standard ones and also

x ** y → Exponentiation
x // y → Floor division (cuts after the comma, e.g. 3 // 2 = 1)

Conditional statements and loops

break and continue are supported.

# if
if b > a:
  print("b is greater than a")
else:
  print("Nix.")

# while
i = 1
while i < 6:
  print(i)
  i += 1

# for
fruits = ["apple", "banana", "cherry"]
for x in fruits:
  print(x)

Data collections

There are no classical arrays (Array = List).

Data Type	Example	Particularities
list	`x = ["apple","banana","cherry"]`	List items are ordered, changeable, and allow duplicate values. List items are indexed, the first item has index `[0]`, the second item has index `[1]` etc.
dict	`x = {"name" : "John", "age" : 36}`	Key-Value-Pairs, ordered (from v3.7 on)
set	`x = {"apple", "banana", "cherry"}` `x = frozenset({"apple","banana","cherry"})`	A set is a collection which is both unordered and unindexed. Set items are unordered, unchangeable, and do not allow duplicate values. But: Once a set is created, you cannot change its items, but you can add new items. To prevent this, you can use a `frozenset`
tuple	`("apple", "banana", "cherry")`	Tuple items are ordered, unchangeable, and allow duplicate values. Tuples are unchangeable. Can only be accessed with `foreach`.

Lists

Access items: thislist[5]
Change item: thislist[1] = "blackcurrant"
Inserting
- Append items: thislist.append("orange")
- Insert at certain position: thislist.insert(1, "orange")
- Append elements from another list to the current list: thislist.extend(anotherList)
  
  The extend() method does not have to append lists, you can add any iterable object (tuples, sets, dictionaries etc.).

Removing

# remove specified item
thislist.remove("banana")

# remove specified index
thislist.pop(1) # you can also leave away the index to remove the last element
# or:
del thislist[1]

# empty the list
thislist.clear()

# delete entire list
del thislist

Loop through a list

foreach
```
for x in thislist:
    print(x)
```

for

for i in range(len(thislist)):
    print(thislist[i])

Sorting
```
thislist.sort()
```
You can pass reverse = True as an argument.
count() → Number of Elements in the List

Dicts

thisdict = {
    "brand": "Ford",
    "model": "Mustang",
    "year": 1964
}

x = thisdict["model"]
# or:
x = thisdict.get("model")

# return a list of all the keys in the dictionary:
x = thisdict.keys()

# add entry
thisdict["color"] = "white"

# remove entry
thisdict.pop("model")

# remove last item
thisdict.popitem()

Functions

def my_function(fname):
    print(fname + " Doe")
    return fname

my_function("John")

Function definitions cannot be empty, but if you for some reason have a definition with no content, put in the pass statement:

def myfunction():
    pass

Object orientation

Create a class
```
class MyClass:
    x = 5
```
Create an object
```
p1 = MyClass()
print(p1.x)
```

__init__()-Function (= Constructor)

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

p1 = Person("John", 36)
print(p1.name)

Inheritance

# Superclass
class Person:
    def __init__(self, fname, lname):
        self.firstname = fname
        self.lastname = lname

    def printname(self):
        print(self.firstname, self.lastname)

# Subclass
class Employee(Person):
    pass

DEV Community: Timo Reusch

Federated avatars in authentik

1. Create a folder to store your avatars

2. Create the prompts

3. Create a custom expression policy

4. Modify the user prompt stage

5. Enable attributes.avatar

6. Test it out!

Get the lines of code in your JetBrains IDE (quick)

Create a Python virtual environment (quick)

Set up MariaDB on macOS (quick)

1. Install MariaDB

2. Start the server

3. Log in to the server

4. Configure a database

Create a database

Create a user

How to structure big FastAPI projects

Basic folder structure

Basic FastAPI

Routes

Database integration

Unit tests

Setting up Sass, Bootstrap, Icons, and Notifications in SvelteKit

Bootstrap

Material Icons

Notifications

Using Sass in your JavaFX project

Ways to compile to CSS

Using a Maven Build-Plugin

Compiling with the help of IntelliJ

Python from A-Z in 10 minutes

Introduction

General

Comments

Variables

General

Data types

Strings

Operators

Conditional statements and loops

Data collections

Functions

Object orientation

5. Enable `attributes.avatar`