Blog de développement

...

Turbos SG et Enumération de L'ISIN DE

Les turbos SG (anciennement CommerzBank) sont enregistré en Allemagne, dans un Registre (listed, en Anglais) qui n'est pas disponible gratuitement au grand public. Par contre, si on connait l'ISIN, on peut interroger une base comme Yahoo Finance. Donc, si on arrive à énumérer la base ISIN DE, on peut en extraire rétrospectivement la base des Turbos SG.

C'est un registre! C'est à dire qu'il est construit de façon incrémentale. Le numéro est ensuite encodé dans une base Alpha-numérique, dont la base ne nous est pas connue. Une fois encodé, ils ajoutent un caractère de contrôle.

Détermination de la base

L'ordre de base (A à Z) est identique en français et en allemand

A l'évidence, ils ont évité le I, source d'erreurs. Un petit script regarde dans notre registre: les lettres inutiliséees sont I et O. C'est donc une base (26 -2) + 10 = 34. On ne peut pas utiliser les base-34 'classiques', qui, elles, utilisent les 24 premiers caractères.

Validation de l'ISIN

Dans un ISIN de 12 caractères, les positions 6 à 11 correspondent au WKN allemand. L'ISIN inclut un chiffre de contrôle, calculé selon un algorithme qui valide l'ensemble de l'ISIN, pas le WKN isolément. Le WKN ine possède pas de mécanisme de validation.

Les ISIN, définis par la norme ISO 6166 International Securities Identification Number sont des codes alphanumériques de 12 caractères utilisés pour identifier de manière unique des titres financiers à l'échelle mondiale. Ils facilitent le clearing, le reporting et le règlement des transactions. La structure comprend un code pays, un identifiant national de sécurité et un chiffre de contrôle, ce dernier étant crucial pour détecter les erreurs de transcription

https://en.wikipedia.org/wiki/International_Securities_Identification_Number Wikipedia

def validate_isin(isin: str) -> bool:
    """
    Valide un ISIN complet en :
      - Vérifiant que le format est correct (12 caractères : 2 lettres, 9 caractères alphanumériques et 1 chiffre).
      - Calculant le chiffre de contrôle attendu à partir des 11 premiers caractères 
        et en le comparant au dernier chiffre de l'ISIN.
    
    Lève une ValueError si le format ou le caractère de contrôle n'est pas conforme.
    """
    isin = isin.strip().upper()
    if not re.match(r'^[A-Z]{2}[A-Z0-9]{9}[0-9]$', isin):
        raise ValueError(f"ISIN '{isin}' n'est pas conforme au format attendu.")
    
    expected_cd = calculate_isin_check_digit(isin[:-1])
    actual_cd = int(isin[-1])
    
    if expected_cd != actual_cd:
        raise ValueError(f"ISIN '{isin}' a un chiffre de contrôle invalide (attendu {expected_cd}, trouvé {actual_cd}).")
    
    return True

Pour le fun: un ISIN valide mais... Faux

La détection d'ISIN frauduleux ou malveillants n'est pas notre sujet. On notera qu'on peut construire un ISIN qui passra de nombreux validateur alors même qu'il est faux. Il suffit d'utiliser un I ou O

Prenez DE000CJ3VYW0, retirez lui sa clé (le dernier Zero) et remplacons J par I. On ajoute à DE000CI3VYW sa clé calculée (1) pour avoir DE000CI3VYW1. Il passe tous les validateurs ! Si vous en trouvez un qui le rejette faites moi signe! https://github.com/floydspace/isin-validator https://www.lseg.com/en/data-analytics refinitiv.com

Le

https://onlinelibrary.wiley.com/doi/10.1155/2014/407145

S'abandonner au VIBE ? Et risquer l'erreur fatale ??

Il y a un engouement récent pour le Vibe Programming, entièrement assisté par une intelligence artificielle.  Andrej Karpathy a inventé le terme « vibe coding » pour décrire comment les LLM deviennent si bons que les développeurs peuvent simplement « s'abandonner au VIBE, embrasser les exponentielles et oublier l'existence même du code ». Mon attention a été attirée par la vidéo de MoonDev Vidéo →,  qui fait référence à cette vidéo originale: "Vibe Coding Is the Future" Vidéo → Voir aussi : Vidéo →

Le sujet est très passionnant! J'utilise beaucoup l'IA comme assistant de programmation, plutôt que comme 'agent' autonome.  Les progrès sont énormes et très rapides: ce qui est impossible aujourd'hui sera banal demain. Les AI prisées pour programmer sont Sonnet, GPT (OpenAI) et nouvellement Grok.  J'ai été particulièrement impressionné par la fluidité, la vitesse et le caractère sympathique de Grok.  J'ai donc eu tendance à utiliser Grok (*) plutôt que Chat GPT (*) (assez lent, chez moi) ((* : avec abonnement $30 et $20). Toutefois, j'ai eu l'occasion de constater un cas très particulier et indiscutable où l'utilisation de l'AI peut mener à des erreurs fatales: 

Je travaillais sur les ISIN. (Mars 2025) Ce sont des identifiants normalisés dont le dernier chiffre est une clé informatique de contrôle.  Elle est parfaitement normalisée ISO 6166 et décrite dans Wikipédia → Par ailleurs, il existe un snippet sur Github.  Moi, je voulais une clé de contrôle pour mon programme en Python.  J'ai donc renseigné Grok avec la fiche wikipédia, le lien vers le snippet, le copiant même dans le prompt, lui donnant ainsi un parfait exemple de ce qu'il fallait faire.  Grok a généré une fonction, en apparence, bien ficellée.  Testée sur mes annuaires, j'ai vu que ça marchait pas. 

J'ai fourni à CHAT GPT les mêmes informations: le lien vers Wikipédia, ainsi que le snippet, sur Github.  Chat GPT a généré une fonction. Elle n'a bien validé ma liste de référence.

Du coup, j'ai questionné les 2 IA: Grok et CHAT GPT, leur soumettant, à la fois la norme, le snippet et les 2 fonctions: celle qui marche et celle qui marche pas.  Et en leur demandant de différencier celle qui marche de celle ne marche pas.

Grok m'a affirmé que sa fonction convient et que les 2 fonctions étaient équivalentes. (persistence dans l'erreur). À l'inverse, CHAT GPT a bien analysé que la fonction de Grok ne fonctionnerait pas, alors que sa fonction fonctionnerait, en me donnant des explications. 

Utiliser l'IA, comme substitut complet à une programmation financière, est donc particulièrement risqué parce que l'IA peut vous donner des algorithmes complètement faux. 

J'ai le même problème avec le calcul et la simulation des prix du turbo en fonction des prix du sous-jacent. Les résultats que j'obtiens sont pas très satisfaisants et ne corroborent pas la réalité. 

Cela reste des outils absolument géniaux pour gagner du temps. Je suis revenu à CHAT GPT, car cette expérience m'a quand même refroidi sur les capacités de Grok à être un assistant fiable. Sonnet a une bonne réputation et je vais l'installer pour essayer.

Calcul de la clé informatique ISIN (check digit) qui marche

# CHAT GPT (cette fonction marche)
def calculate_isin_check_digit(isin_without_cd: str) -> int:
    """
    Calcule le chiffre de contrôle pour une partie d'ISIN (les 11 premiers caractères).    
    L'algorithme consiste à :
      1. Vérifier que l'ISIN partiel correspond au pattern : 2 lettres suivies de 9 caractères alphanumériques.
      2. Remplacer chaque lettre par sa valeur numérique (base 36, A=10, B=11, …, Z=35) 
         et laisser les chiffres tels quels.
      3. Inverser la chaîne obtenue et, en partant de l'extrémité droite, doubler la valeur de chaque chiffre
         en position paire (indice 0, 2, 4, …) en additionnant les chiffres du résultat si celui-ci est supérieur à 9.
      4. Le chiffre de contrôle est alors calculé par : (10 - (total % 10)) % 10.
    """
    if not re.match(r'^[A-Z]{2}[A-Z0-9]{9}$', isin_without_cd.upper()):
        raise ValueError(f"Partie ISIN '{isin_without_cd}' non conforme au pattern attendu.")
    
    # Conversion : pour chaque caractère, si lettre => conversion en entier (base 36), sinon le chiffre est conservé.
    converted = ""
    for char in isin_without_cd.upper():
        if char.isdigit():
            converted += char
        else:
            converted += str(int(char, 36))
    
    # Application de l'algorithme de Luhn sur la chaîne convertie (inversion + doublement des chiffres en position paire)
    total = 0
    reversed_digits = converted[::-1]
    for index, digit_char in enumerate(reversed_digits):
        digit = int(digit_char)
        if index % 2 == 0:
            doubled = digit * 2
            total += (doubled // 10) + (doubled % 10)
        else:
            total += digit
            
    return (10 - (total % 10)) % 10	

Calcul ISIN (GROK) NE marche PAS: Explications

Pour réference cette fonction ne marche pas... Saurez vous comprendre pourquoi ?

# ### GROK
# Fonction pour calculer le caractère de contrôle d'un ISIN (basée sur les 11 premiers caractères)
def calculate_check_digit(isin_base):
    # Mettre en majuscules pour uniformité
    isin_base = isin_base.upper()
    
    # Vérifier que les caractères sont alphanumériques
    if not isin_base.isalnum():
        raise ValueError("L'ISIN doit contenir uniquement des lettres et des chiffres")
    
    # Convertir en séquence de chiffres
    digits = []
    for char in isin_base:
        if char.isdigit():
            digits.append(int(char))  # Chiffres : 0-9
        elif char.isalpha():
            num = 10 + ord(char) - ord('A')  # Lettres : A=10, B=11, ..., Z=35
            digits.append(num // 10)  # Dizaine
            digits.append(num % 10)   # Unité
    
    # Doubler les chiffres en position impaire (indices 0, 2, 4, ...)
    summed_digits = []
    for i, digit in enumerate(digits):
        if i % 2 == 0:  # Position impaire (en commençant à 0)
            doubled = digit * 2
            summed_digits.append(doubled // 10 + doubled % 10)  # Somme des chiffres si > 9
        else:
            summed_digits.append(digit)  # Position paire, pas de doublage
    
    # Calculer la somme totale
    total_sum = sum(summed_digits)
    
    # Calculer le caractère de contrôle
    check_digit = (10 - (total_sum % 10)) % 10
    return check_digit

Problème dans la fonction de calcul du chiffre de contrôle :

Doublement des chiffres L’algorithme de l’ISIN consiste à convertir les 11 premiers caractères en une suite de chiffres, puis à appliquer l’algorithme de Luhn sur cette suite. Pour ce faire, il faut « doubler » certains chiffres. La règle standard est de doubler les chiffres en partant de la droite (le chiffre le plus à droite, le premier à considérer, n’étant pas doublé, puis le suivant est doublé, etc.). Cela revient, en travaillant dans l’ordre naturel (de gauche à droite), à doubler les chiffres en fonction de la parité de la longueur de la chaîne obtenue. En d’autres termes, si la suite convertie comporte un nombre pair de chiffres, il faut doubler ceux qui se trouvent en position impaire (si on compte à partir de 0, ce sont les indices 1, 3, 5, …), et si elle comporte un nombre impair de chiffres, doubler ceux en position paire (indices 0, 2, 4, …).

Ce qui est fait dans votre fonction Dans votre fonction calculate_check_digit, vous extrayez la suite convertie et vous doublez systématiquement les chiffres aux indices 0, 2, 4, … sans tenir compte de la parité de la longueur de la chaîne.

Conséquence : Pour de nombreux ISIN dont la partie sans le chiffre de contrôle convertit en une suite de nombre impair de chiffres (cas fréquent lorsque les 9 derniers caractères sont numériques), le calcul tombe juste. Mais pour les cas où la conversion donne un nombre pair de chiffres (par exemple, si certains des 9 caractères sont des lettres, ce qui ajoute 2 chiffres au lieu d’un), le schéma de doublement appliqué sera incorrect et le chiffre calculé sera erroné.