user.sync
=========

.. py:module:: user.sync


Attributes
----------

.. autoapisummary::

   user.sync._T


Classes
-------

.. autoapisummary::

   user.sync.UserSourceArgsWithoutName
   user.sync.UserSource
   user.sync.ZugUserSource


Module Contents
---------------

.. py:class:: UserSourceArgsWithoutName

   Bases: :py:obj:`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)


   .. py:attribute:: bases
      :type:  collections.abc.Sequence[str]


   .. py:attribute:: org
      :type:  NotRequired[Any]


   .. py:attribute:: filters
      :type:  NotRequired[collections.abc.Sequence[str]]


   .. py:attribute:: user_type
      :type:  NotRequired[str]


   .. py:attribute:: default_filter
      :type:  NotRequired[str]


.. py:data:: _T

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

   Generalized UserSource to facilitate ldap sync 


   .. py:attribute:: name


   .. py:attribute:: _bases


   .. py:attribute:: default_filter
      :value: '(objectClass=*)'



   .. py:attribute:: filters


   .. py:attribute:: _org
      :value: None



   .. py:attribute:: _user_type
      :value: None



   .. py:attribute:: verbose
      :value: False



   .. py:method:: scalar(value: list[str] | str | None, default: str = '') -> str
                  scalar(value: list[_T] | _T | None, default: _T) -> _T
      :staticmethod:



   .. py:property:: ldap_attributes
      :type: collections.abc.Sequence[str]

      :abstractmethod:



   .. py:property:: ldap_mapping
      :type: collections.abc.Mapping[str, str]

      :abstractmethod:



   .. py:property:: organisation
      :type: Any



   .. py:property:: bases
      :type: collections.abc.Sequence[str]



   .. py:method:: user_type_default(entry: ldap3.Entry) -> str | None


   .. py:method:: user_type(entry: ldap3.Entry) -> str | None


   .. py:method:: excluded_default(entry: ldap3.Entry) -> bool

      Default when no function specific to the source name exists. 



   .. py:method:: excluded(entry: ldap3.Entry) -> bool

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



   .. py:property:: default_filters
      :type: list[str]



   .. py:property:: bases_filters_attributes
      :type: collections.abc.Sequence[tuple[str, str, collections.abc.Sequence[str]]]



   .. py:method:: map_entry(entry: ldap3.Entry) -> dict[str, Any]


   .. py:method:: complete_entry(user: dict[str, Any], **kwargs: Any) -> dict[str, Any]

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



   .. py:method:: map_entries(entries: collections.abc.Iterable[ldap3.Entry], **kwargs: Any) -> collections.abc.Iterator[dict[str, Any]]


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

   Bases: :py:obj:`UserSource`


   Generalized UserSource to facilitate ldap sync 


   .. py:attribute:: default_filter
      :value: '(objectClass=*)'



   .. py:attribute:: ldap_mapping


   .. py:attribute:: schools
      :type:  dict[str, UserSourceArgsWithoutName]


   .. py:attribute:: ldap_users
      :type:  dict[str, UserSourceArgsWithoutName]


   .. py:property:: ldap_attributes
      :type: list[str]



   .. py:method:: user_type_ktzg(entry: ldap3.Entry) -> str | None

      KTZG specific user type 



   .. py:method:: 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. 



   .. py:method:: excluded(entry: ldap3.Entry) -> bool

      General exclusion pattern for all synced users. 



   .. py:method:: map_entry(entry: ldap3.Entry) -> dict[str, Any]


   .. py:method:: complete_entry(user: dict[str, Any], **kwargs: Any) -> dict[str, Any]

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



   .. py:method:: map_entries(entries: collections.abc.Iterable[ldap3.Entry], **kwargs: Any) -> collections.abc.Iterator[dict[str, Any]]


   .. py:method:: factory(verbose: bool = False) -> list[ZugUserSource]
      :classmethod: