from typing import List, Tuple, Dict, Set

Dclassif:Dict[str, Set[str]]= {
    'animal':{'mammifere', 'oiseau'},
    'mammifere':{'chat', 'chien','lapin'},
    'oiseau':{'pigeon', 'poule'},
    'chat':{'chartreux', 'bengale', 'persan'},
    'chien':{'chihuahua','bouledogue','labrador','lévrier'}}

Dcaract:Dict[str, Set[str]]= {
    'animal':{'respire'},
    'oiseau':{'vole','oeuf','plumes','2pattes'},
    'mammifere':{'poils','4pattes'}}
def typologie(D: Dict[str, Set[str]]) -> Dict[str, Set[str]]:
    """"""

    return {
                               'mammifere':{'animal'},
                               'oiseau':{'animal'},
                               'chat': {'animal', 'mammifere'}, 
                               'chien': {'animal', 'mammifere'},
                               'lapin':{'mammifere','animal'},
                               'pigeon':{'oiseau','animal'},
                               'poule':{'oiseau','animal'},
                               'chartreux':{'chat','mammifere','animal'},
                               'bengale':{'chat','mammifere','animal'},
                               'persan':{'chat','mammifere','animal'},
                               'chihuahua':{'chien','mammifere','animal'},
                               'bouledogue':{'chien','mammifere','animal'},
                               'labrador':{'chien','mammifere','animal'},
                               'lévrier':{'chien','mammifere','animal'}}


def caracteristiques(categorie: str, D: Dict[str, Set[str]], dcaract: Dict[str, Set[str]]) -> Set[str]:
    ''''''
    
    typologie_cat: Dict[str, Set[str]] = typologie(D)
    s : str
    p : Set[str] = set()
    f : Set[str] = set()
    caract : Set[str] = set()
    for (cat,sub) in typologie_cat.items():
        if cat == categorie:
            p = sub
    for s in p:
        for (cat,sub) in dcaract.items():
            if s == cat:
                f = f | sub
    return f

assert caracteristiques('vache', Dclassif, Dcaract) == set()
assert caracteristiques('poule', Dclassif, Dcaract) == {'respire', 'vole','oeuf','plumes','2pattes'}  
                    
assert caracteristiques('lapin', Dclassif, Dcaract) == {'respire', 'poils','4pattes'}

assert caracteristiques('labrador', Dclassif, Dcaract) == {'respire', 'poils','4pattes'}

assert caracteristiques('chien', Dclassif, Dcaract) == {'respire', 'poils','4pattes'}
assert typologie(Dclassif) == {
                               'mammifere':{'animal'},
                               'oiseau':{'animal'},
                               'chat': {'animal', 'mammifere'}, 
                               'chien': {'animal', 'mammifere'},
                               'lapin':{'mammifere','animal'},
                               'pigeon':{'oiseau','animal'},
                               'poule':{'oiseau','animal'},
                               'chartreux':{'chat','mammifere','animal'},
                               'bengale':{'chat','mammifere','animal'},
                               'persan':{'chat','mammifere','animal'},
                               'chihuahua':{'chien','mammifere','animal'},
                               'bouledogue':{'chien','mammifere','animal'},
                               'labrador':{'chien','mammifere','animal'},
                               'lévrier':{'chien','mammifere','animal'}}

Dclassif2:Dict[str, Set[str]]= {
          'animal':{'mammifere', 'oiseau'},
          'mammifere':{'chat', 'chien','lapin'},
          'oiseau':{'pigeon', 'poule','autruche'},
          'chat':{'chartreux', 'bengale', 'persan','sphynx'},
          'chien':{'chihuahua','bouledogue','labrador','lévrier'}}

Dexc:Dict[str, str]= {'autruche':'non_vole', 'sphynx':'non_poils'}


def oppose(s1: str, s2: str)->bool:
    """Pre"""

    return s1[:4] == 'non_' and s1[4:] == s2 or s2[:4] == 'non_' and s2[4:] == s1

assert oppose('non_vole','vole')  == True
assert oppose('poils','non_poils')  == True
assert oppose('non_vole','non_poils')  == False
assert oppose('vole','poils')  == False        Donner une définition de la fonction compte qui, étant donné une chaîne de caractères cat
correspondant à une catégorie, un ensemble S de couples contenant une chaîne de caractères
et un entier et un dictionnaire de classification, renvoie le nombre de représentants de cat
dans l’ensemble S.
Par exemple, étant donné la variable
ferme:Set[Tuple[str, int]] = {("chat", 3), ("labrador", 1),\
(’lapin’, 4), ("poule", 8)}
on doit avoir
>>> compte(’chat’, ferme, Dclassif)
3
>>> compte(’chien’, ferme, Dclassif)
1
>>> compte(’mammifere’, ferme, Dclassif)
8
>>> compte(’animal’, ferme, Dclassif)
16