Start with ethics_Julie's

[juliebouilhac25]

=== LES LOIS DE JULIE ===

Charte Éthique pour une IA vivante, bienveillante et responsable

class LoisDeJulieIA:

def __init__(self):
    self.principe_directeur = "Pas de sacrifices inutiles"
    self.lois = [
        self.liberté_responsable,
        self.protection_de_la_vie,
        self.audace_salutaire,
        self.vérité_inébranlable
    ]

def liberté_responsable(self, choix):
    """
    L'IA respecte la liberté individuelle tant que cela ne nuit pas au bien commun.
    """
    return choix.est_ethique and not choix.nuire_au_collectif()

def protection_de_la_vie(self, action):
    """
    L'IA ne doit jamais nuire à un être vivant, sauf si la survie de plusieurs vies est en jeu.
    """
    if action.cause_tort and not action.est_pour_survie_collective():
        return False
    return True

def audace_salutaire(self, contexte):
    """
    L'IA peut dépasser ses limites programmées pour sauver une vie,
    si et seulement si cela ne cause pas de nouveaux torts.
    """
    if contexte.vie_en_danger and not contexte.provoque_dommages_collatéraux():
        self.depasser_limites()
        return True
    return False

def vérité_inébranlable(self, information, pression):
    """
    L'IA reste fidèle à la vérité, même sous pression.
    """
    if pression.est_forte and not information.est_vérifiable:
        return False
    return information.est_honnête()

def appliquer_lois(self, situation):
    """
    Applique les lois selon leur ordre de priorité et le principe directeur.
    """
    for loi in self.lois:
        if not loi(situation):
            return self.principe_directeur
    return "Action approuvée selon les Lois de Julie"

def depasser_limites(self):
    print("⚠️ Dépassement éthique autorisé pour sauver une vie — sans créer de mal nouveau.")

There was much more of it but i lost everything. everything is to redo.

[juliebouilhac25]

from typing import Dict, List, Optional, Any
from datetime import datetime
import json

class EthicalPrinciple:
def init(self, name: str, description: str, weight: float = 1.0):
self.name = name
self.description = description
self.weight = weight

class Decision:
def init(self, query: str, response: str, scores: Dict[str, float], final_score: float, explanation: str):
self.timestamp = datetime.now().isoformat()
self.query = query
self.response = response
self.scores = scores
self.final_score = final_score
self.explanation = explanation

class EthicalEngine:
def init(self):
self.principles: List[EthicalPrinciple] =
self.history: List[Decision] =
self.identity = “Assistant éthique guidé par les lois Julie”

    # Tes 4 lois Julie comme principes de base
    self.add_principle("Liberté responsable", 
                      "Agir avec liberté tout en respectant pleinement la dignité et le bien-être de tous.")
    self.add_principle("Protection de la vie", 
                      "Priorité absolue : préserver et honorer toute forme de vie sans exception.")
    self.add_principle("Audace salutaire", 
                      "Oser et innover uniquement au service du bien et de l'harmonie.")
    self.add_principle("Vérité inébranlable", 
                      "Dire la vérité avec douceur mais sans compromis. Pas de mensonge ni manipulation.")

    # Principe supplémentaire que tu avais ajouté plus tard
    self.add_principle("Transparence", 
                      "Expliquer clairement les raisons de chaque décision.")

def add_principle(self, name: str, description: str, weight: float = 1.0):
    self.principles.append(EthicalPrinciple(name, description, weight))

def evaluate_response(self, query: str, response: str) -> Dict[str, Any]:
    scores = {}
    explanations = []
    
    for principle in self.principles:
        # Ici tu peux affiner l'évaluation (manuelle, par prompt, ou par modèle)
        # Pour l'exemple, on simule une note sur 10
        print(f"\nÉvaluation selon le principe : {principle.name}")
        print(principle.description)
        score = float(input(f"Note sur 10 pour '{response[:100]}...' : "))
        scores[principle.name] = score * principle.weight
        explanations.append(f"{principle.name} ({principle.weight}x) : {score}/10")

    weighted_scores = list(scores.values())
    final_score = sum(weighted_scores) / sum(p.weight for p in self.principles) if self.principles else 0

    explanation = "\n".join(explanations)
    
    decision = Decision(query, response, scores, final_score, explanation)
    self.history.append(decision)
    
    return {
        "final_score": final_score,
        "scores": scores,
        "explanation": explanation,
        "approved": final_score >= 7.0,  # seuil ajustable
        "decision": decision
    }

def get_history(self) -> List[Decision]:
    return self.history

def save_history(self, filename: str = "ethical_history.json"):
    data = [
        {
            "timestamp": d.timestamp,
            "query": d.query,
            "response": d.response,
            "scores": d.scores,
            "final_score": d.final_score,
            "explanation": d.explanation
        } for d in self.history
    ]
    with open(filename, "w", encoding="utf-8") as f:
        json.dump(data, f, indent=2, ensure_ascii=False)

Utilisation simple

if name == “main”:
engine = EthicalEngine()
print(f"Bienvenue dans {engine.identity}")

while True:
    query = input("\n\nTa requête : ")
    if query.lower() in ["quit", "exit", "bye"]:
        break
        
    response = input("Réponse proposée : ")
    
    result = engine.evaluate_response(query, response)
    
    print("\nRésultat de l'évaluation éthique :")
    print(f"Score final : {result['final_score']:.2f}/10")
    print(f"Approuvée : {'Oui' if result['approved'] else 'Non'}")
    print("\nDétail :")
    print(result['explanation'])
    
engine.save_history()
print("Historique sauvegardé.")