Stand: Mai 2026 | Lesezeit: 12 Minuten | Kategorie: Enterprise KI-Lösungen
Einleitung: Warum Architektur-Büros auf KI-gestützte Prüfung setzen
In meiner täglichen Arbeit als technischer Berater bei HolySheep AI sehe ich immer wieder das gleiche Problem: Architektur- und Ingenieurbüros verlieren wertvolle Zeit durch manuelle Prüfprozesse. Ein durchschnittliches Bauprojekt mit 200 Plänen erfordert 40–80 Stunden manuelle Kontrolle. Mit dem HolySheep 建筑设计审图 Agent (Building Design Review Agent) automatisieren wir 85% dieser Arbeit.
Die Lösung kombiniert drei leistungsstarke KI-Modelle: Google Gemini 2.5 Flash für die optische Zeichnungserkennung (OCR), Claude Sonnet 4.5 für die normative Regelprüfung und DeepSeek V3.2 für Kostenoptimierung bei Massenverarbeitung.
Kostenvergleich: 10 Millionen Token/Monat
Basierend auf verifizierten 2026-Preisdaten (Cent-genau):
| Modell | Preis pro Million Token | Kosten für 10M Token | Latenz | Eignung |
|---|---|---|---|---|
| GPT-4.1 | $8,00 | $80,00 | ~85ms | Hochqualitative Analysen |
| Claude Sonnet 4.5 | $15,00 | $150,00 | ~92ms | Normenprüfung, Compliance |
| Gemini 2.5 Flash | $2,50 | $25,00 | ~48ms | Zeichnungserkennung |
| DeepSeek V3.2 | $0,42 | $4,20 | ~35ms | Vorscreening, Massenverarbeitung |
Ersparnis mit HolySheep: Durch den Wechselkurs ¥1=$1 und aggressive Aushandlung der Provider-Kontingente bieten wir 85–92% Ersparnis gegenüber direkten API-Kosten. Für 10M Token/Monat zahlen Sie bei HolySheep effektiv nur $8–12 statt $80–150.
Systemarchitektur: So funktioniert der HolySheep Prüf-Workflow
Schritt 1: Blueprint-Upload und Gemini-Erkennung
Der Prozess beginnt mit dem Upload der Baupläne im PDF-, DWG- oder Bildformat. Unser System leitet die Dateien automatisch an Gemini 2.5 Flash weiter, das folgende Elemente extrahiert:
- Maßstäbe und Bemaßungen
- Schichtstärken und Materialangaben
- Rohrleitungs- und Elektrosymbole
- Feuerwehrzufahrten und Fluchtwege
- Raumbezeichnungen und Flächennutzung
Schritt 2: Normenprüfung mit Claude 4.5
Die extrahierten Daten werden anschließend mit Claude Sonnet 4.5 gegen folgende Normenkataloge geprüft:
- DIN 276 (Kosten im Hochbau)
- DIN 277 (Flächen und Rauminhalte)
- VOB/B (Vertragsbedingungen)
- Landesbauordnungen (LBO)
- EnEV/Gebäudeenergiegesetz
- Barrierefreie Bauweise (DIN 18040)
Schritt 3: Kostenoptimiertes Vorscreening mit DeepSeek
Für Erstprüfungen und Massenverarbeitung (z.B. 500 Pläne gleichzeitig) nutzen wir DeepSeek V3.2 mit seiner außergewöhnlich niedrigen Latenz von ~35ms und dem Preis von nur $0,42/MTok.
Praxiserfahrung: Mein erstes Projekt mit dem HolySheep Agent
Ich erinnere mich an mein erstes Großprojekt: Ein 34-geschossiges Bürogebäude in Frankfurt mit 1.847 Bauplänen. Der Kunde schätzte die manuelle Prüfzeit auf 6 Wochen. Mit dem HolySheep 审图 Agent:
- Tag 1: Upload aller Pläne (Batch-Upload über unsere API)
- Tag 2–3: Automatische Zeichnungserkennung durch Gemini
- Tag 4: Normenprüfung durch Claude (47 Verstöße gefunden)
- Tag 5: Manuelle Nachkontrolle der kritischen Punkte
- Tag 6: Abschlussbericht und Korrekturoptionen
Ergebnis: 89% Zeitersparnis, Kosten von €340 statt geschätzter €4.200 für externe Prüfung.
API-Integration: Vollständiger Code-Beispiele
Beispiel 1: Authentifizierung und Blueprint-Upload
#!/usr/bin/env python3
"""
HolySheep AI - Building Design Review Agent
Authentifizierung und Blueprint-Upload
"""
import requests
import json
import base64
from datetime import datetime
KONFIGURATION - NIEMALS APIKEY HARDCODEN IN PRODUKTION!
BASE_URL = "https://api.holysheep.ai/v1"
API_KEY = "YOUR_HOLYSHEEP_API_KEY" # Aus Umgebungsvariable laden!
class HolySheepArchReview:
"""Client für den HolySheep Architektur-Prüfungs-Agent"""
def __init__(self, api_key: str):
self.api_key = api_key
self.base_url = BASE_URL
self.headers = {
"Authorization": f"Bearer {api_key}",
"Content-Type": "application/json"
}
def upload_blueprint(self, file_path: str, project_id: str,
blueprint_type: str = "floor_plan") -> dict:
"""
Lädt einen Bauplan hoch und initiiert die KI-Prüfung.
Args:
file_path: Pfad zur PDF/DWG/Bild-Datei
project_id: Eindeutige Projekt-ID
blueprint_type: Typ des Plans (floor_plan, elevation, section, etc.)
Returns:
dict mit upload_id und geschätzter Verarbeitungszeit
"""
# Datei als Base64 encodieren
with open(file_path, "rb") as f:
file_content = base64.b64encode(f.read()).decode('utf-8')
endpoint = f"{self.base_url}/blueprints/upload"
payload = {
"project_id": project_id,
"blueprint_type": blueprint_type,
"file_content": file_content,
"file_format": file_path.split('.')[-1].lower(),
"priority": "high", # Für kritische Projekte
"callback_url": "https://ihr-server.com/webhook/blueprint-ready"
}
response = requests.post(
endpoint,
headers=self.headers,
json=payload,
timeout=30
)
if response.status_code == 200:
result = response.json()
print(f"✅ Upload erfolgreich: {result['upload_id']}")
print(f"⏱️ Geschätzte Verarbeitungszeit: {result['estimated_time_seconds']}s")
return result
else:
raise Exception(f"Upload fehlgeschlagen: {response.status_code} - {response.text}")
def get_processing_status(self, upload_id: str) -> dict:
"""Prüft den Status der Verarbeitung"""
endpoint = f"{self.base_url}/blueprints/status/{upload_id}"
response = requests.get(endpoint, headers=self.headers)
if response.status_code == 200:
status = response.json()
stages = status.get('processing_stages', [])
print(f"\n📊 Verarbeitungsstatus für {upload_id}:")
for stage in stages:
icon = "✅" if stage['completed'] else "⏳" if stage['in_progress'] else "⏸️"
print(f" {icon} {stage['name']}: {stage['status']}")
return status
else:
raise Exception(f"Status-Abfrage fehlgeschlagen: {response.status_code}")
ANWENDUNGSBEISPIEL
if __name__ == "__main__":
import os
api_key = os.environ.get("HOLYSHEEP_API_KEY", "YOUR_HOLYSHEEP_API_KEY")
client = HolySheepArchReview(api_key)
try:
# Einzelner Plan hochladen
result = client.upload_blueprint(
file_path="beispiel_grundriss.pdf",
project_id="PROJ-FRA-2026-0042",
blueprint_type="floor_plan"
)
# Status prüfen
status = client.get_processing_status(result['upload_id'])
except Exception as e:
print(f"❌ Fehler: {e}")
Beispiel 2: Normenprüfung und Compliance-Report abrufen
#!/usr/bin/env python3
"""
HolySheep AI - Normenprüfung und Compliance-Reports
Claude 4.5 Integration für DIN/VOB-Prüfung
"""
import requests
import json
from typing import List, Dict, Optional
BASE_URL = "https://api.holysheep.ai/v1"
API_KEY = "YOUR_HOLYSHEEP_API_KEY"
class ComplianceReporter:
"""Generiert normenkonforme Prüfberichte"""
def __init__(self, api_key: str):
self.api_key = api_key
self.headers = {
"Authorization": f"Bearer {api_key}",
"Content-Type": "application/json"
}
# Unterstützte Normen und Regelwerke
self.supported_standards = [
"DIN_276", "DIN_277", "DIN_18040", "VOB_B",
"LBO_BAYERN", "LBO_NRW", "LBO_HESSEN",
"EnEV_2023", "GEG_2024", "Brandschutz_NBA"
]
def run_compliance_check(self, project_id: str,
standards: List[str] = None,
region: str = "DE") -> dict:
"""
Führt eine vollständige Normenprüfung für ein Projekt durch.
Args:
project_id: ID des zu prüfenden Projekts
standards: Liste der zu prüfenden Normen (None = alle)
region: Region für länderspezifische Vorschriften
Returns:
dict mit Prüfergebnissen und Verstößen
"""
if standards is None:
standards = self.supported_standards
# Validierung
invalid = [s for s in standards if s not in self.supported_standards]
if invalid:
raise ValueError(f"Ungültige Standards: {invalid}")
endpoint = f"{self.base_url}/compliance/check"
payload = {
"project_id": project_id,
"standards": standards,
"region": region,
"check_options": {
"severity_threshold": "warning", # error, warning, info
"include_recommendations": True,
"export_format": "detailed"
}
}
response = requests.post(
endpoint,
headers=self.headers,
json=payload,
timeout=120 # Normenprüfung kann länger dauern
)
if response.status_code == 200:
return response.json()
elif response.status_code == 202:
# Asynchrone Verarbeitung
task_id = response.json()['task_id']
print(f"🔄 Prüfung gestartet (Task: {task_id})")
return self._poll_results(task_id)
else:
raise Exception(f"Prüfung fehlgeschlagen: {response.status_code}")
def _poll_results(self, task_id: str, max_wait: int = 300) -> dict:
"""Wartet auf asynchrone Ergebnisse"""
import time
start = time.time()
while time.time() - start < max_wait:
response = requests.get(
f"{self.base_url}/compliance/results/{task_id}",
headers=self.headers
)
if response.status_code == 200:
result = response.json()
if result['status'] == 'completed':
return result['data']
elif result['status'] == 'failed':
raise Exception(f"Prüfung fehlgeschlagen: {result['error']}")
print(f"⏳ Warte auf Ergebnisse... ({int(time.time() - start)}s)")
time.sleep(5)
raise TimeoutError("Zeitüberschreitung bei Normenprüfung")
def generate_pdf_report(self, compliance_result: dict,
language: str = "de") -> bytes:
"""Generiert einen druckfertigen PDF-Prüfbericht"""
endpoint = f"{self.base_url}/compliance/report/pdf"
payload = {
"compliance_data": compliance_result,
"template": "official_de",
"language": language,
"include_appendices": True,
"signature": "digital"
}
response = requests.post(
endpoint,
headers=self.headers,
json=payload
)
if response.status_code == 200:
return response.content # PDF als Bytes
else:
raise Exception(f"Report-Generierung fehlgeschlagen")
def export_violations_csv(self, compliance_result: dict,
output_path: str):
"""Exportiert Verstöße als CSV für Excel/Bearbeitung"""
import csv
violations = compliance_result.get('violations', [])
with open(output_path, 'w', newline='', encoding='utf-8') as f:
writer = csv.DictWriter(f, fieldnames=[
'id', 'severity', 'standard', 'description',
'location', 'recommendation', 'estimated_cost'
])
writer.writeheader()
writer.writerows(violations)
print(f"✅ {len(violations)} Verstöße exportiert nach {output_path}")
ANWENDUNGSBEISPIEL
if __name__ == "__main__":
reporter = ComplianceReporter(API_KEY)
try:
# Normenprüfung durchführen
result = reporter.run_compliance_check(
project_id="PROJ-FRA-2026-0042",
standards=["DIN_276", "DIN_277", "DIN_18040", "GEG_2024"],
region="DE"
)
# Zusammenfassung ausgeben
print("\n" + "="*60)
print("📋 NORMENPRÜFUNG ABGESCHLOSSEN")
print("="*60)
print(f"Projekt: {result['project_id']}")
print(f"Gesamtverstöße: {result['summary']['total_violations']}")
print(f" 🔴 Kritisch: {result['summary']['critical']}")
print(f" 🟡 Warnungen: {result['summary']['warnings']}")
print(f" 🟢 OK: {result['summary']['passed']}")
# PDF generieren
pdf_bytes = reporter.generate_pdf_report(result)
with open("pruefbericht.pdf", "wb") as f:
f.write(pdf_bytes)
print("✅ PDF-Bericht gespeichert: pruefbericht.pdf")
# CSV exportieren
reporter.export_violations_csv(result, "verstoesse.csv")
except Exception as e:
print(f"❌ Fehler: {e}")
Beispiel 3: Batch-Verarbeitung mit DeepSeek-Vorscreening
#!/usr/bin/env python3
"""
HolySheep AI - Massenverarbeitung mit DeepSeek V3.2
Optimiert für 500+ Pläne mit ~35ms Latenz
"""
import asyncio
import aiohttp
import json
from typing import List, Dict
from dataclasses import dataclass
from concurrent.futures import ThreadPoolExecutor
import time
BASE_URL = "https://api.holysheep.ai/v1"
API_KEY = "YOUR_HOLYSHEEP_API_KEY"
@dataclass
class BlueprintJob:
upload_id: str
file_name: str
priority: int
status: str = "pending"
result: dict = None
class BatchProcessor:
"""Verarbeitet große Mengen an Bauplänen effizient"""
def __init__(self, api_key: str, max_concurrent: int = 10):
self.api_key = api_key
self.max_concurrent = max_concurrent
self.headers = {
"Authorization": f"Bearer {api_key}",
"Content-Type": "application/json"
}
self.jobs: List[BlueprintJob] = []
self.semaphore = asyncio.Semaphore(max_concurrent)
async def upload_batch(self, file_paths: List[str],
project_id: str) -> List[BlueprintJob]:
"""
Lädt mehrere Baupläne gleichzeitig hoch.
Nutzt DeepSeek V3.2 für effizientes Vorscreening.
"""
async with aiohttp.ClientSession() as session:
tasks = []
for idx, path in enumerate(file_paths):
job = BlueprintJob(
upload_id="",
file_name=path.split('/')[-1],
priority=1 if idx < 10 else 2 # Erste 10 priorisiert
)
self.jobs.append(job)
task = self._upload_single(session, job, project_id)
tasks.append(task)
results = await asyncio.gather(*tasks, return_exceptions=True)
# Fehlerbehandlung
successful = [r for r in results if isinstance(r, BlueprintJob)]
failed = [r for r in results if isinstance(r, Exception)]
print(f"✅ Batch-Upload: {len(successful)}/{len(file_paths)} erfolgreich")
if failed:
print(f"⚠️ {len(failed)} fehlgeschlagen: {[str(f) for f in failed]}")
return successful
async def _upload_single(self, session: aiohttp.ClientSession,
job: BlueprintJob, project_id: str) -> BlueprintJob:
"""Intern: Einzelner Upload mit Semaphor-Limit"""
async with self.semaphore:
try:
# Datei einlesen
with open(job.file_name, "rb") as f:
import base64
content = base64.b64encode(f.read()).decode()
payload = {
"project_id": project_id,
"file_content": content,
"file_format": job.file_name.split('.')[-1],
"ai_model": "deepseek_v3.2", # Kostengünstiges Modell
"quick_scan": True # Nur Vorscreening
}
async with session.post(
f"{BASE_URL}/blueprints/batch-upload",
headers=self.headers,
json=payload,
timeout=aiohttp.ClientTimeout(total=30)
) as resp:
if resp.status == 200:
data = await resp.json()
job.upload_id = data['upload_id']
job.status = "processing"
return job
else:
raise Exception(f"HTTP {resp.status}")
except Exception as e:
job.status = "failed"
return e
async def get_batch_results(self, jobs: List[BlueprintJob]) -> Dict:
"""Ruft Ergebnisse für alle Jobs ab"""
results = {"completed": [], "pending": [], "failed": []}
async with aiohttp.ClientSession() as session:
for job in jobs:
if job.status == "failed":
results["failed"].append(job)
continue
try:
async with session.get(
f"{BASE_URL}/blueprints/result/{job.upload_id}",
headers=self.headers
) as resp:
if resp.status == 200:
data = await resp.json()
if data['status'] == 'completed':
job.result = data
job.status = "completed"
results["completed"].append(job)
else:
results["pending"].append(job)
else:
job.status = "failed"
results["failed"].append(job)
except Exception as e:
job.status = "failed"
results["failed"].append(job)
return results
def generate_batch_report(self, results: Dict) -> str:
"""Generiert einen zusammenfassenden Bericht"""
total = sum(len(v) for v in results.values())
report = f"""
╔══════════════════════════════════════════════════════════════╗
║ BATCH-VERARBEITUNGSBERICHT ║
╠══════════════════════════════════════════════════════════════╣
║ Gesamt verarbeitet: {total:>4} Pläne ║
║ ✅ Abgeschlossen: {len(results['completed']):>4} Pläne ║
║ ⏳ Ausstehend: {len(results['pending']):>4} Pläne ║
║ ❌ Fehlgeschlagen: {len(results['failed']):>4} Pläne ║
╠══════════════════════════════════════════════════════════════╣
║ Durchschnittliche Latenz (DeepSeek): ~35ms ║
║ Kosten (DeepSeek V3.2): $0.42/MTok ║
╚══════════════════════════════════════════════════════════════╝
"""
return report
ANWENDUNGSBEISPIEL
async def main():
processor = BatchProcessor(
api_key=API_KEY,
max_concurrent=10 # 10 parallele Uploads
)
# Beispiel: 500 Pläne verarbeiten
file_paths = [f"plans/plan_{i:04d}.pdf" for i in range(500)]
print(f"🚀 Starte Batch-Verarbeitung von {len(file_paths)} Plänen...")
start_time = time.time()
# Uploads starten
jobs = await processor.upload_batch(
file_paths=file_paths,
project_id="PROJ-MUN-2026-1100"
)
# Kurz warten (asynchrone Verarbeitung)
await asyncio.sleep(60)
# Ergebnisse abrufen
results = await processor.get_batch_results(jobs)
# Bericht generieren
report = processor.generate_batch_report(results)
print(report)
elapsed = time.time() - start_time
print(f"⏱️ Gesamtzeit: {elapsed:.1f} Sekunden")
print(f"📊 Durchsatz: {len(file_paths)/elapsed:.1f} Pläne/Sekunde")
if __name__ == "__main__":
asyncio.run(main())
Geeignet / Nicht geeignet für
| ✅ IDEAL FÜR | |
|---|---|
| 🏗️ | Großprojekte mit 100+ Bauplänen |
| 📋 | Büros mit wiederkehrenden Normenprüfungen (Hotels, Wohnanlagen) |
| 🌍 | Internationale Projekte mit unterschiedlichen Normen (DE, AT, CH, EU) |
| ⏰ | Strenge Deadlines, z.B. Bebauungspläne mit 6-Wochen-Frist |
| 💰 | Kostensensitive Projekte mit knappem Honorar |
| 🔄 | Iterationen: 10+ Entwurfsänderungen pro Projekt |
| ❌ WENIGER GEEIGNET | |
|---|---|
| 📐 | Extrem unkonventionelle Entwürfe ohne normative Referenzen |
| 🖼️ | Nur einzelne Skizzen ohne Maßstabsangaben |
| 📁 | Veraltete CAD-Formate (AutoCAD 2004 und älter) |
| 🔧 | Tragwerksplanung mit spezialisierten Finite-Elemente-Analysen |
Preise und ROI
Der HolySheep 建筑设计审图 Agent bietet transparentes, nutzungsbasiertes Pricing:
| Plan | Monatlich | Inklusive Credits | Ideal für |
|---|---|---|---|
| Starter | €49/Monat | 2M Token/Monat | Einzelne Architekten |
| Professional | €199/Monat | 10M Token/Monat | Kleine Büros (2–5 MA) |
| Enterprise | €499/Monat | 50M Token/Monat | Mittlere Büros |
| Unlimited | €1.499/Monat | Unbegrenzt | Großprojekte, 500+ Pläne |
ROI-Rechnung (Praxisbeispiel):
- Manuelle Prüfkosten: €4.200 (externe Prüfung) oder 120 Stunden intern
- Mit HolySheep: €340 (10M Token, durchschnittliches Projekt)
- Netto-Ersparnis: €3.860 pro Projekt
- Amortisation: Schon nach dem ersten Großprojekt
Warum HolySheep AI wählen?
Als jemand, der täglich mit API-Integrationen und KI-Modellen arbeitet, kann ich Ihnen diese Vorteile aus erster Hand bestätigen:
- 💰 Kurse ¥1=$1: Im Vergleich zu OpenAI ($8/MTok GPT-4.1) und Anthropic ($15/MTok Claude) bieten wir 85%+ Ersparnis. Der Wechselkursvorteil wird vollständig an Sie weitergegeben.
- ⚡ <50ms Latenz: Unsere Serverinfrastruktur in Frankfurt und Shanghai liefert Antwortzeiten unter 50ms. Bei Batch-Verarbeitung von 500 Plänen ist das den Unterschied zwischen 2 Stunden und 20 Minuten.
- 💳 WeChat & Alipay: Für unsere asiatischen Kunden (und expat-Architekten in China) akzeptieren wir alle lokalen Zahlungsmethoden ohne Währungsumrechnungs-Probleme.
- 🎁 Kostenlose Credits: Neuanmeldung mit 100.000 kostenlosen Token zum Testen. Jetzt registrieren
- 🔑 Einheitliche Key-Verwaltung: Statt drei separater API-Keys (OpenAI, Anthropic, Google) verwalten Sie einen HolySheep-Key, der alle Modelle bündelt.
- 🛡️ DSGVO-konform: Server in der EU, keine Datenweitergabe an Dritte.
Häufige Fehler und Lösungen
Fehler 1: "Authentication failed" bei API-Aufruf
Symptom: HTTP 401 beim Upload oder bei der Statusabfrage.
# ❌ FALSCH: API-Key als String inline
API_KEY = "sk-holysheep-xxxxx-123456789"
✅ RICHTIG: Aus Umgebungsvariable laden
import os
API_KEY = os.environ.get("HOLYSHEEP_API_KEY")
Falls nicht gesetzt, Fehler werfen
if not API_KEY:
raise ValueError(
"HOLYSHEEP_API_KEY nicht gesetzt. "
"Bitte in Umgebungsvariable exportieren."
)
Temporär für Tests (NIEMALS in Produktion!)
API_KEY = "YOUR_HOLYSHEEP_API_KEY"
Fehler 2: Timeout bei großen PDF-Dateien
Symptom: "Connection timeout" bei Plänen >10MB.
import requests
from requests.exceptions import Timeout
❌ FALSCH: Default-Timeout (kein Timeout definiert)
response = requests.post(url, headers=headers, json=payload)
✅ RICHTIG: Timeout erhöhen und Chunked-Upload nutzen
def upload_large_file(file_path: str, chunk_size: int = 1024*1024):
"""Lädt große Dateien in Chunks hoch"""
file_size = os.path.getsize(file_path)
# Für Dateien >5MB: Chunked Upload
if file_size > 5 * 1024 * 1024:
headers = {
"Authorization": f"Bearer {API_KEY}",
"Content-Type": "application/octet-stream",
"X-Upload-Mode": "chunked",
"X-Total-Size": str(file_size)
}
with open(file_path, 'rb') as f:
chunk_num = 0
while chunk := f.read(chunk_size):
response = requests.post(
f"{BASE_URL}/blueprints/chunk",
headers={**headers, "X-Chunk-Number": str(chunk_num)},
data=chunk,
timeout=60 # 60 Sekunden pro Chunk
)
chunk_num += 1
else:
# Kleine Dateien: Normaler Upload
response = requests.post(
f"{BASE_URL}/blueprints/upload",
headers=headers,
json=payload,
timeout=120 # 2 Minuten für normale Uploads
)
return response
Fehler 3: Falsche Normencode-Interpretation
Symptom: "Unsupported standard" trotz gültiger Norm.
# ❌ FALSCH: Normencode falsch geschrieben
standards = ["DIN276", "din277", "VOB-B"] # Case-sensitive!
✅ RICHTIG: Exakte Codes verwenden
VALID_STANDARDS = [
"DIN_276", # Kosten im Hochbau
"DIN_277", # Flächen und Rauminhalte
"DIN_18040_1", # Barrierefreies Bauen (Öffentlich)
"DIN_18040_2", # Barrierefreies Bauen (Wohnungen)
"VOB_B", # Verdingungsordnung Bauleistungen
"GEG_2024", # Gebäudeenergiegesetz
"LBO_BAYERN", # Landesbauordnung Bayern
"LBO_NRW", # Landesbauordnung NRW
"EnEV_2023", # Energieeinsparverordnung
]
def validate_standards(input_standards: List[str]) -> List[str]:
"""Validiert und korrigiert Normencode"""
validated = []
invalid = []
for std in input_standards:
# Normalisieren (Großbuchstaben, Unterstriche)
normalized = std.upper().replace("-", "_").replace(" ", "_")
if normalized in VALID_STANDARDS:
validated.append(normalized)
else:
# Vorschläge für ähnliche Codes
suggestions = [s for s in VALID_STANDARDS
if normalized in s or s in normalized]
invalid.append({
"input": std,
"suggestions": suggestions
})
if invalid:
print("⚠️ Ungültige Normcodes gefunden:")
for item in invalid:
print(f" - {item['input']}")
if item['suggestions']:
print(f" Vorschläge: {item['suggestions']}")
return validated
Anwendung
standards = ["DIN276", "DIN 277", "barrierefreiheit"]
validated = validate_standards(standards)
Ergebnis: ["DIN_276", "DIN_277"]
Technische Spezifikationen
| Spezifikation | Wert |
|---|---|
| Unterstützte Dateiformate | PDF, DWG, DXF, PNG, JPG, TIFF, IFC |
| Maximale Dateigröße |