Question technique sur l'utilisation du mot clé super pour héritage.

from abc import ABC, abstractmethod

import ldap

from mce_sync.config import ConfigLoader
from mce_sync.core.ldap import LDAP
from mce_sync.core.treatments import Treatments


class TreatmentStrategy(ABC):
    def __init__(
        self,
        configuration: ConfigLoader,
        annuaire: LDAP,
        treatments: Treatments,
    ):
        self._configuration = configuration
        self._annuaire = annuaire
        self._treatments = treatments
        self._frequency = None
        self._enabled = None
        self._NAME = None

    @abstractmethod
    def frequency(self):
        """Fréquence du traitement."""
        pass

    @abstractmethod
    def enabled(self):
        """Activation du traitemnt"""
        pass

    @abstractmethod
    def name(self):
        """Nom du traitement"""
        pass

    @abstractmethod
    def execute(self):
        pass

    def _build_generic_ldap_filter(self) -> str:
        ldap_object_class_attr_name: str = (
            self._configuration.config.ldap_attributes.object_class
        )
        ldap_mailhost_filter: str = (
            self._configuration.config.ldap_syncprov.filter
        )
        ldap_account_type: str = (
            self._configuration.config.ldap_values.mce_account
        )

        ldap_filter: str = (
            "(&"
            f"{ldap_mailhost_filter}"
            f"({ldap_object_class_attr_name}={ldap_account_type})"
        )
        return ldap_filter

    def _search(self, ldap_filter: str):
        ldap_base_dn = self._configuration.config.ldap_syncprov.base
        return self._annuaire.search(
            ldap_base_dn, ldap.SCOPE_SUBTREE, ldap_filter
        )

    def _extract_user_from_entry(self, entry):
        """Extrait l'utilisateur à partir de l'entrée LDAP."""
        ldap_user_id_attr_name = (
            self._configuration.config.ldap_attributes.user_id_mce
        )
        return entry[0][1][ldap_user_id_attr_name][0].decode("utf-8")

import logging

import ldap
from mce_sync.logger.log_msgs import MessagePurgeLogMsg


class MessagePurgeTreatment(TreatmentStrategy):
    """Pour tous les comptes où mcePurge est valué à une valeur différente
    de -1 : T9 Purge messages"""

    def __init__(self):
        super().__init__()
        self._NAME: str = "message_purge"
        self._frequency = (
            self._configuration.config.scheduled_treatment.message_purge.frequency
        )
        self._enabled = (
            self._configuration.config.scheduled_treatment.message_purge.enabled
        )

        self.log_msg = MessagePurgeLogMsg()
        self.logger = logging.getLogger(
            "mce_sync.ScheduledTreatment.Message_Purge"
        )

    @property
    def frequency(self):
        """Propriété pour accéder à la fréquence."""
        return self._frequency

    @property
    def enabled(self):
        """Propriété pour accéder à l'activation ou non du traitement"""
        return self._enabled

    @property
    def name(self):
        """Propriété pour accéder au nom du traitement"""
        return self._NAME

    def _search_for_accounts_to_purge(self, ldap_filter: str):
        return self._search(ldap_filter)

    def _build_ldap_message_purge_filter(self) -> str:
        """Construit le filtre LDAP pour rechercher les comptes à purger."""
        generic_ldap_filter = self._build_generic_ldap_filter()
        return self._do_build_ldap_message_purge_filter(generic_ldap_filter)

    def _do_build_ldap_message_purge_filter(self, ldap_filter: str) -> str:
        ldap_purge_attr_name: str = (
            self._configuration.config.ldap_attributes.imap_purge
        )

        ldap_filter += (
            f"({ldap_purge_attr_name}=*)" f"(!({ldap_purge_attr_name}=-1))" f")"
        )
        return ldap_filter

    def _extract_user_and_purge_days(self, entry):
        """Extrait l'utilisateur et le nombre de jours à purger à partir de l'entrée LDAP."""
        ldap_user_id_attr_name = (
            self._configuration.config.ldap_attributes.user_id_mce
        )
        ldap_purge_attr_name = (
            self._configuration.config.ldap_attributes.imap_purge
        )
        user = entry[1][ldap_user_id_attr_name][0].decode("utf-8")
        days = entry[1][ldap_purge_attr_name][0].decode("utf-8")
        return user, days

    def execute(self):
        """Exécute la purge des messages pour un utilisateur."""
        _, msg = self.log_msg.run_purge_message
        self.logger.info(msg, self.name)

        ldap_filter: str = self._build_ldap_message_purge_filter()
        search_result = self._search_for_accounts_to_purge(ldap_filter)
        if search_result:
            for entry in self._search_result:
                dn = entry[0][0]
                user, days = self._extract_user_and_purge_days(entry)
                self._treatments.messages_purge(user, days, dn)
        else:
            _, msg = self.log_msg.no_purge
            self.logger.info(msg)

class User:
    def foo(self):
        print("Foo de base")


class Admin(User):
    def foo(self):
        print("Foo d'admin")


admin = Admin()
admin.foo()  # Affiche uniquement "Foo d'admin"

class User:
    def foo(self):
        print("Foo de base")


class Admin(User):
    def foo(self):
        super().foo()
        print("Foo d'admin")


admin = Admin()
admin.foo()  # Affiche "Foo de base et Foo d'admin"