Architectures et systèmes : processeur, réseau et permissions

def executer(programme, memoire, limite=50):
    if type(limite) is not int or limite < 1:
        raise ValueError('limite entière positive attendue')
    if not isinstance(programme, (list, tuple)) or not isinstance(memoire, (list, tuple)):
        raise ValueError('séquences attendues')
    if any(type(x) is not int for x in memoire):
        raise ValueError('données entières attendues')
    pc, acc, trace = 0, 0, []
    memoire = list(memoire)
    for _ in range(limite):
        if not 0 <= pc < len(programme):
            raise IndexError('compteur hors programme')
        instruction = programme[pc]
        if not isinstance(instruction, (list, tuple)) or not instruction:
            raise ValueError('instruction mal formée')
        operation, *arguments = instruction
        if operation not in ('LOAD', 'ADD', 'STORE', 'JZ', 'HALT'):
            raise ValueError('instruction inconnue')
        if operation == 'HALT':
            if arguments:
                raise ValueError('HALT sans opérande attendu')
        else:
            if len(arguments) != 1 or type(arguments[0]) is not int:
                raise ValueError('une adresse entière attendue')
            borne = len(programme) if operation == 'JZ' else len(memoire)
            if not 0 <= arguments[0] < borne:
                raise IndexError('adresse hors domaine')
        trace.append({'pc': pc, 'instruction': tuple(instruction),
                      'acc_avant': acc, 'memoire': tuple(memoire)})
        pc += 1
        if operation == 'LOAD':
            acc = memoire[arguments[0]]
        elif operation == 'ADD':
            acc += memoire[arguments[0]]
        elif operation == 'STORE':
            memoire[arguments[0]] = acc
        elif operation == 'JZ' and acc == 0:
            pc = arguments[0]
        elif operation == 'HALT':
            return acc, memoire, trace
    raise RuntimeError('limite de pas atteinte')

def bit(x):
    if type(x) is not int or x not in (0, 1):
        raise ValueError('bit attendu')
    return x

def demi_additionneur(a, b):
    a, b = bit(a), bit(b)
    return a ^ b, a & b

def additionneur_complet(a, b, retenue_entree):
    somme1, retenue1 = demi_additionneur(a, b)
    somme2, retenue2 = demi_additionneur(somme1, retenue_entree)
    return somme2, retenue1 | retenue2

def table_complete():
    return [(a,b,r,*additionneur_complet(a,b,r)) for a in (0,1) for b in (0,1) for r in (0,1)]

def fragmenter(message, taille):
    if type(message) is not str or type(taille) is not int or taille < 1:
        raise ValueError('texte et taille entière positive attendus')
    fragments = [message[i:i+taille] for i in range(0, len(message), taille)]
    total = len(fragments)
    return [{'numero': i, 'total': total, 'charge': f} for i, f in enumerate(fragments)]

def reassembler(paquets):
    if type(paquets) is not list:
        raise ValueError('liste de paquets attendue')
    if not paquets:
        return ''
    total, index = None, {}
    for p in paquets:
        if type(p) is not dict or set(p) != {'numero', 'total', 'charge'}:
            raise ValueError('champs de paquet invalides')
        numero, annonce, charge = p['numero'], p['total'], p['charge']
        if type(annonce) is not int or annonce < 1 or type(numero) is not int:
            raise ValueError('entiers de séquence attendus')
        if not 0 <= numero < annonce or type(charge) is not str or not charge:
            raise ValueError('numéro ou charge invalide')
        if total is None:
            total = annonce
        if annonce != total or numero in index:
            raise ValueError('total incohérent ou doublon')
        index[numero] = charge
    if len(index) != total:
        raise ValueError('fragment manquant')
    return ''.join(index[i] for i in range(total))

def recevoir(etat, bit, message):
    if type(bit) is not int or bit not in (0, 1) or type(message) is not str:
        raise ValueError('bit entier et message texte attendus')
    if type(etat) is not dict or type(etat.get('attendu')) is not int or etat['attendu'] not in (0, 1):
        raise ValueError('état de réception invalide')
    if type(etat.get('livres')) is not list or any(type(x) is not str for x in etat['livres']):
        raise ValueError('livraisons invalides')
    livres = list(etat['livres'])
    attendu = etat['attendu']
    if bit == attendu:
        livres.append(message)
        attendu = 1 - attendu
    return {'attendu': attendu, 'livres': livres}, bit

def transmettre(messages, pertes_paquet=frozenset(), pertes_ack=frozenset(), limite=100):
    if type(messages) is not list or any(type(x) is not str for x in messages):
        raise ValueError('liste de textes attendue')
    if type(limite) is not int or limite < 1:
        raise ValueError('limite entière positive attendue')
    for pertes in (pertes_paquet, pertes_ack):
        if not isinstance(pertes, (set, frozenset)) or any(type(x) is not int or x < 0 for x in pertes):
            raise ValueError('ensemble de tentatives attendu')
    etat = {'attendu': 0, 'livres': []}
    trace, bit, tentative = [], 0, 0
    for message in messages:
        acquitte = False
        while not acquitte:
            if tentative >= limite:
                raise RuntimeError('trop de tentatives')
            if tentative in pertes_paquet:
                trace.append((tentative, bit, 'paquet_perdu'))
            else:
                nouveau = bit == etat['attendu']
                etat, ack = recevoir(etat, bit, message)
                trace.append((tentative, bit, 'livre' if nouveau else 'doublon_non_livre'))
                if tentative in pertes_ack:
                    trace.append((tentative, bit, 'ack_perdu'))
                else:
                    acquitte = ack == bit
                    trace.append((tentative, bit, 'ack_recu'))
            tentative += 1
        bit = 1 - bit
    return etat['livres'], trace

def normaliser(chemin, courant='/'):
    if type(chemin) is not str or not chemin or '\0' in chemin:
        raise ValueError('chemin non vide attendu')
    if type(courant) is not str or not courant.startswith('/') or '\0' in courant:
        raise ValueError('répertoire courant absolu attendu')
    complet = chemin if chemin.startswith('/') else courant + '/' + chemin
    morceaux = []
    for morceau in complet.split('/'):
        if morceau in ('', '.'):
            continue
        if morceau == '..':
            if morceaux:
                morceaux.pop()
        else:
            morceaux.append(morceau)
    return '/' + '/'.join(morceaux)

def autorise(fichier, utilisateur, action, groupes=()):
    if type(fichier) is not dict:
        raise ValueError('fiche de permissions attendue')
    if type(action) is not str or action not in ('r', 'w', 'x'):
        raise ValueError('action r, w ou x attendue')
    if type(utilisateur) is not str or not utilisateur:
        raise ValueError('identité fictive attendue')
    if not isinstance(groupes, (list, tuple, set, frozenset)) or any(type(g) is not str for g in groupes):
        raise ValueError('collection de groupes attendue')
    for cle in ('owner', 'groupe'):
        if type(fichier.get(cle)) is not str or not fichier[cle]:
            raise ValueError('propriétaire et groupe attendus')
    for cle in ('proprietaire', 'droits_groupe', 'autres'):
        droits = fichier.get(cle)
        if type(droits) is not str or any(c not in 'rwx' for c in droits) or len(set(droits)) != len(droits):
            raise ValueError('droits invalides')
    if utilisateur == fichier['owner']:
        droits = fichier['proprietaire']
    elif fichier['groupe'] in groupes:
        droits = fichier['droits_groupe']
    else:
        droits = fichier['autres']
    return action in droits

def simuler_cd(courant, argument, repertoires):
    destination = normaliser(argument, courant)
    if destination not in repertoires:
        raise ValueError('répertoire absent de cet arbre fictif')
    return destination

def mode_ordinaire(mode):
    if type(mode) is not str or len(mode) != 3 or any(c not in '01234567' for c in mode):
        raise ValueError('trois chiffres octaux attendus')
    return [''.join(droit for poids, droit in ((4, 'r'), (2, 'w'), (1, 'x')) if int(c) & poids)
            for c in mode]

import math

def commander_eclairage(lux, etat, seuil_bas=200, seuil_haut=300, temps_mesure=0, temps_courant=0):
    def nombre(x):
        return type(x) is int or (type(x) is float and math.isfinite(x))
    for seuil in (seuil_bas, seuil_haut):
        if not nombre(seuil) or not 0 <= seuil <= 200000:
            raise ValueError('seuil numérique dans le domaine attendu')
    if not seuil_bas < seuil_haut:
        raise ValueError('seuils incohérents')
    erreur = None
    if etat not in ('allume', 'eteint'):
        erreur = 'état précédent invalide'
    elif not nombre(lux) or not 0 <= lux <= 200000:
        erreur = 'mesure invalide ou hors domaine'
    elif type(temps_mesure) is not int or type(temps_courant) is not int or temps_mesure < 0 or temps_courant < 0:
        erreur = 'temps logique invalide'
    elif not 0 <= temps_courant - temps_mesure <= 5:
        erreur = 'mesure future ou périmée'
    if erreur:
        return {'commande': 'arreter', 'erreur': erreur}
    if lux < seuil_bas:
        nouvel_etat = 'allume'
    elif lux > seuil_haut:
        nouvel_etat = 'eteint'
    else:
        nouvel_etat = etat
    return {'commande': nouvel_etat, 'erreur': None, 'mesure_lux': lux,
            'age': temps_courant - temps_mesure}

def modele_ihm(resultat):
    if resultat['erreur']:
        return f"Simulation arrêtée : {resultat['erreur']}"
    return (f"Éclairage {resultat['commande']}, mesure {resultat['mesure_lux']} lux, "
            f"âge logique {resultat['age']}")