Deutsche IBAN prüfen und BIC auslesen: Python und JavaScript

import json
import os
import re
from urllib.error import HTTPError
from urllib.request import Request, urlopen
 
API = "https://api.ibanforge.com"
KEY = os.environ.get("IBANFORGE_API_KEY", "").strip()
 
 
def normalise(value: str) -> str:
    if not isinstance(value, str):
        raise ValueError("IBAN must be a string")
    return re.sub(r"[\s\ufeff-]", "", value).upper()
 
 
def post(path: str, payload: dict) -> dict:
    headers = {"Content-Type": "application/json"}
    if KEY:
        headers["Authorization"] = "Bearer " + KEY
    request = Request(API + path, data=json.dumps(payload).encode(),
                      headers=headers, method="POST")
    try:
        with urlopen(request, timeout=30) as response:
            return json.load(response)
    except HTTPError as error:
        if error.code == 429:
            raise RuntimeError("HTTP 429; Retry-After=" +
                               error.headers.get("Retry-After", "unknown")) from None
        if error.code == 402:
            raise RuntimeError("HTTP 402; inspect access and remaining allowance") from None
        raise RuntimeError(f"HTTP {error.code}") from None
 
 
def interpret(original: str, answer: dict, index: int) -> dict:
    if (not isinstance(answer, dict) or type(answer.get("valid")) is not bool
            or not isinstance(answer.get("iban"), str)
            or (answer["valid"] and answer["iban"] != normalise(original))):
        raise ValueError("Unexpected or misaligned API response")
    check = {} if answer.get("bank_code_check") is None else answer["bank_code_check"]
    bic = {} if answer.get("bic") is None else answer["bic"]
    if not isinstance(check, dict) or not isinstance(bic, dict):
        raise ValueError("Unexpected bank reference")
    for flag in ("authoritative", "retired"):
        if flag in check and type(check[flag]) is not bool:
            raise ValueError("Unexpected bank reference flag")
    observation = "review"
    if answer["valid"] is False:
        observation = "invalid_iban"
    elif not answer["iban"].startswith("DE"):
        observation = "outside_german_scope"
    elif check.get("retired") is True:
        observation = "bank_code_retired"
    elif (check.get("status") == "not_in_register"
          and check.get("reason") == "not_allocated"
          and check.get("authoritative") is True):
        observation = "bank_code_not_allocated"
    elif (check.get("status") == "verified" and check.get("authoritative") is True
          and check.get("register") and check.get("as_of")):
        observation = "bank_reference_found"
    return {"index": index, "input": original, "observation": observation,
            "review_required": True, "source_response": answer}
 
 
def review_one(iban: str) -> dict:
    normalise(iban)
    return interpret(iban, post("/v1/iban/validate", {"iban": iban}), 0)
 
 
def review_many(ibans: list[str]) -> list[dict]:
    if not isinstance(ibans, list):
        raise ValueError("Expected a list of IBAN strings")
    for iban in ibans:
        normalise(iban)
    if not ibans:
        return []
    if not KEY:
        raise ValueError("IBANFORGE_API_KEY is required for a batch")
    output = []
    for start in range(0, len(ibans), 100):
        batch = ibans[start:start + 100]
        body = post("/v1/iban/batch", {"ibans": batch})
        results = body.get("results") if isinstance(body, dict) else None
        if not isinstance(results, list) or len(results) != len(batch):
            raise ValueError("Unexpected batch length")
        output.extend(interpret(raw, result, start + offset)
                      for offset, (raw, result) in enumerate(zip(batch, results)))
    return output

const API = "https://api.ibanforge.com";
const KEY = (process.env.IBANFORGE_API_KEY ?? "").trim();
 
function normalise(value) {
  if (typeof value !== "string") throw new Error("IBAN must be a string");
  return value.replace(/[\s-]/g, "").toUpperCase();
}
 
function isObject(value) {
  return value !== null && typeof value === "object" && !Array.isArray(value);
}
 
async function post(path, payload) {
  const headers = { "Content-Type": "application/json" };
  if (KEY) headers.Authorization = `Bearer ${KEY}`;
  const response = await fetch(API + path, {
    method: "POST", headers, body: JSON.stringify(payload),
    signal: AbortSignal.timeout(30_000),
  });
  if (response.status === 429) {
    throw new Error(`HTTP 429; Retry-After=${response.headers.get("Retry-After") ?? "unknown"}`);
  }
  if (response.status === 402) throw new Error("HTTP 402; inspect access and remaining allowance");
  if (!response.ok) throw new Error(`HTTP ${response.status}`);
  return response.json();
}
 
export function interpret(original, answer, index) {
  if (!isObject(answer) || typeof answer.valid !== "boolean" || typeof answer.iban !== "string"
      || (answer.valid && answer.iban !== normalise(original))) {
    throw new Error("Unexpected or misaligned API response");
  }
  const check = answer.bank_code_check ?? {};
  const bic = answer.bic ?? {};
  if (!isObject(check) || !isObject(bic)) throw new Error("Unexpected bank reference");
  for (const flag of ["authoritative", "retired"]) {
    if (flag in check && typeof check[flag] !== "boolean") throw new Error("Unexpected bank reference flag");
  }
  let observation = "review";
  if (answer.valid === false) observation = "invalid_iban";
  else if (!answer.iban.startsWith("DE")) observation = "outside_german_scope";
  else if (check.retired === true) observation = "bank_code_retired";
  else if (check.status === "not_in_register" && check.reason === "not_allocated" && check.authoritative === true) {
    observation = "bank_code_not_allocated";
  } else if (check.status === "verified" && check.authoritative === true && check.register && check.as_of) {
    observation = "bank_reference_found";
  }
  return { index, input: original, observation, review_required: true, source_response: answer };
}
 
export async function reviewOne(iban) {
  normalise(iban);
  return interpret(iban, await post("/v1/iban/validate", { iban }), 0);
}
 
export async function reviewMany(ibans) {
  if (!Array.isArray(ibans)) throw new Error("Expected a list of IBAN strings");
  ibans.forEach(normalise);
  if (!ibans.length) return [];
  if (!KEY) throw new Error("IBANFORGE_API_KEY is required for a batch");
  const output = [];
  for (let start = 0; start < ibans.length; start += 100) {
    const batch = ibans.slice(start, start + 100);
    const body = await post("/v1/iban/batch", { ibans: batch });
    if (!isObject(body) || !Array.isArray(body.results) || body.results.length !== batch.length) {
      throw new Error("Unexpected batch length");
    }
    output.push(...body.results.map((result, offset) => interpret(batch[offset], result, start + offset)));
  }
  return output;
}

python3 -c 'from review_iban import review_one; import json; print(json.dumps(review_one("DE89370400440532013000")))'
node --input-type=module -e 'import { reviewOne } from "./review-iban.mjs"; console.log(JSON.stringify(await reviewOne("DE89370400440532013000")))'