user.sync

Module Contents

Classes

UserSourceArgsWithoutName	dict() -> new empty dictionary
UserSource	Generalized UserSource to facilitate ldap sync
ZugUserSource	Generalized UserSource to facilitate ldap sync

Attributes

_T

class user.sync.UserSourceArgsWithoutName

Bases: typing_extensions.TypedDict

dict() -> new empty dictionary dict(mapping) -> new dictionary initialized from a mapping object’s

(key, value) pairs

dict(iterable) -> new dictionary initialized as if via:

d = {} for k, v in iterable:

d[k] = v

dict(**kwargs) -> new dictionary initialized with the name=value pairs

in the keyword argument list. For example: dict(one=1, two=2)

bases: collections.abc.Sequence[str]

org: typing_extensions.NotRequired[Any]

filters: typing_extensions.NotRequired[collections.abc.Sequence[str]]

user_type: typing_extensions.NotRequired[str]

default_filter: typing_extensions.NotRequired[str]

user.sync._T

class user.sync.UserSource(name: str, bases: Sequence[str], org: Any | None = None, filters: Sequence[str] | None = None, user_type: str | None = None, default_filter: str = '(objectClass=*)', verbose: bool = False)

Generalized UserSource to facilitate ldap sync

abstract property ldap_attributes: Sequence[str]

abstract property ldap_mapping: Mapping[str, str]

property organisation: Any

property bases: Sequence[str]

property default_filters: list[str]

property bases_filters_attributes: Sequence[tuple[str, str, Sequence[str]]]

static scalar(value: list[str] | str | None, default: str = '') → str

static scalar(value: list[_T] | _T | None, default: _T) → _T

user_type_default(entry: ldap3.Entry) → str | None

user_type(entry: ldap3.Entry) → str | None

excluded_default(entry: ldap3.Entry) → bool

Default when no function specific to the source name exists.

excluded(entry: ldap3.Entry) → bool

Finds a specific exclusion function specific to the name or use the fallback

map_entry(entry: ldap3.Entry) → dict[str, Any]

complete_entry(user: dict[str, Any], **kwargs: Any) → dict[str, Any]

Add additional logic after the user is mapped before writing to the db.

map_entries(entries: Iterable[Entry], **kwargs: Any) → Iterator[dict[str, Any]]

class user.sync.ZugUserSource(name: str, bases: Sequence[str], org: Any | None = None, filters: Sequence[str] | None = None, user_type: str | None = None, default_filter: str = '(objectClass=*)', verbose: bool = False)

Bases: UserSource

Generalized UserSource to facilitate ldap sync

property ldap_attributes: list[str]

default_filter = '(objectClass=*)'

ldap_mapping

schools: dict[str, UserSourceArgsWithoutName]

ldap_users: dict[str, UserSourceArgsWithoutName]

user_type_ktzg(entry: ldap3.Entry) → str | None

KTZG specific user type

user_type_default(entry: ldap3.Entry) → str | None

For all the schools, we filter by Mail already, but we exclude the students. Name specific user_type functions will run first, this is

a fallback.

excluded(entry: ldap3.Entry) → bool

General exclusion pattern for all synced users.

map_entry(entry: ldap3.Entry) → dict[str, Any]

complete_entry(user: dict[str, Any], **kwargs: Any) → dict[str, Any]

Add additional logic after the user is mapped before writing to the db.

map_entries(entries: Iterable[Entry], **kwargs: Any) → Iterator[dict[str, Any]]

classmethod factory(verbose: bool = False) → list[ZugUserSource]