Allgemeine Frage zur Programierung

[Joshua666]

Guten Tag
Ich möchte mir aus meiner Börsensoftware (Atas) ein Handelsjournal aufbauen.
( ich möchte Daten aus einer .xlsl aufbereiten und in ein Word Dokument einlesen)

Ich habe das mit Chat Gpt versucht allerdings funktioniert das nur sehr sporadisch.

Gibt es hier jemanden der sich daran versuchen möchte ?
Oder kann mir jemand sagen wo ich diesbezüglich Hilfe suchen könnte?

Vielen Dank
Mfg
Joshua

[snafu]

Gibt es hier jemanden der sich daran versuchen möchte ?

Die Idee dieses Forums ist nicht die Vergabe von IT-Jobs (ganz gleich, ob bezahlt oder unbezahlt), falls die Frage dahingehend gemeint war. Hier erhält man stattdessen Hilfe zur Selbsthilfe. Dass sich manchmal trotzdem jemand per PN meldet, will ich natürlich nicht ausschließen.

Hast du denn bereits Code vorliegen? Dann stell ihn hier gerne rein und wir schauen, wie wir dich unterstützen können. Welche konkreten Anforderungen hast du, wie die spätere docx-Datei aufgebaut sein soll? Wie sieht der vorliegende Export aus deiner Software aus? Einige Datensätze daraus wären als Grundlage sicherlich nützlich.

Dann kann man sehen, ob man gemeinsam weiterkommt.

Oder kann mir jemand sagen wo ich diesbezüglich Hilfe suchen könnte?

Falls du dennoch einen Job vergeben willst, dann schau dich auf sogenannten Freelancer-Portalen um.

[sparrow]

@Joshua666: Weil er für mich nicht aus deinem Post hervor geht: Wo ist der Bezug zu Python?

[noisefloor]

Hallo,

ich sehe da auch eher wenig Zusammenhang zu irgendeiner Programmiersprache außer vielleicht Visual Basic.

Daten aufbereiten kannst du doch direkt in Excel selber. Entweder mit den an Bord befindlichen Funktionen oder VB Macros. Wenn du Office 365 hat geht natürlich auch die Python-Integration, die Excel sieht ~1 Jahr (?) an Bord hat. Dazu findet man online aber (noch) eher wenig und deswegen wissen die ChatBots davon auch eher wenig. Und wenn du die Datenaufbereitung in Excel hast, kannst du die doch direkt in Word übernehmen.

Und da du dich komplett im Microsoft Universum bewegst, nimm' CoPilot+ statt ChatGPT. CoPilot+ ist inzwischen relativ tief (und, IMHO, brauchbar) in Office365 integriert, damit solltest du schneller weiter kommen als mit ChatGPT.

Gruß, noisefloor

[Joshua666]

Hallo & erstmal Danke für eure Antworten!

Ich will mein Vorhaben mal etwas detaillierter beschreiben:

Ich möchte aus meiner Handelsstatistik (Bild Excel 1 ,2 ,3) folgende Daten per Mausklick in ein Word Dokument übertragen:
1: Tag und Uhrzeit (soll ausgelesen werden)
2: Handelsinstrument (immer gleich )
3: Kontraktanzahl ( immer 2 MNQ Kontrakte)
4 Entry: (soll ausgelesen werden)
5 Exit: (soll ausgelesen werden)
6 Gewinn/Verlust (soll ausgelesen werden)
7 Screenshot ( es soll ein .png aus einem "Screenshot Ordner" eingefügt werden zb. nur in diesem Format : 09.09.205 Trade 1

dann kommt ein Word dokument für persönliche Notizen, da schreibe ich details zum Trade rein.
Bild( Word 1 + 2)

Das ganze läuft dann für 3 Trades an einem Tag- das Ganze also mal 3.

Die letzten Probleme waren:
-die Kontrakte immer falsch berechnet wurden. ( die Preise bei "Entry " sind manchmal unterschiedlich)
-die Screenshots konnten nicht gefunden werden trotz richtiger Schreibweise /Pfadeingabe etc.
-meine persönlichen Notizen wurden immer bei starten des "Tradematchers" überschrieben.

Ich hab dann ein paar Fixe mit Powershell gemacht aber kein stabiles Ergebnis mit Chat-gpt erreicht.

Hier sind die Bilder:

https://imgur.com/a/vKdFjGF

Für Hilfe jeglicher Art bei meinem Projekt wäre ich dankbar.


Hier ist der Phyton Code des tradematchers,den ich über eine .bat starte :

# -*- coding: utf-8 -*-
"""
TradeMatcher_Clean.py
Voraussetzungen (einmalig):
pip install pandas python-docx openpyxl
"""

import os, re, glob, unicodedata, datetime as dt
import pandas as pd
from docx import Document
from docx.shared import Pt, Inches

# ======= KONFIG =======
DESKTOP = os.path.normpath(os.path.join(os.environ.get("USERPROFILE",""), "Desktop"))
ATAS_GLOB = os.path.join(DESKTOP, "ATAS_statistics_realtime*.xlsx") # neueste Datei wird genommen
EXPORT_DIR = os.path.join(DESKTOP, "Trade Archiv")
SCREEN_DIR = os.path.join(DESKTOP, "Trades_Phyton") # Screenshot-Ordner (ohne Umlaut)
SECONDS_GROUP = 120 # ±2 Min zu einem Trade zusammenfassen
# ======================

def log(x): print(str(x), flush=True)
def ensure_dir(p): os.makedirs(p, exist_ok=True); return p

# ---- ATAS laden ----
def find_latest_atas(pattern: str) -> str:
files = sorted(glob.glob(pattern), key=os.path.getmtime, reverse=True)
if not files:
raise FileNotFoundError(f"Keine ATAS-Datei gefunden (Muster: {pattern})")
return files[0]

def load_journal(xlsx_path: str) -> pd.DataFrame:
xl = pd.ExcelFile(xlsx_path)
sheet = next((n for n in xl.sheet_names if "ournal" in n.lower()), xl.sheet_names[0])
df = xl.parse(sheet)
for c in ("Open time","Close time"):
if c in df.columns:
df[c] = pd.to_datetime(df[c], errors="coerce")
return df

# ---- Trades gruppieren ----
def coalesce_trades(df: pd.DataFrame, seconds: int = SECONDS_GROUP) -> pd.DataFrame:
if df is None or df.empty: return df
need = ["Instrument","Open time"]
for c in need:
if c not in df.columns:
raise ValueError(f"Spalte fehlt im Journal: {c}")

df = df.sort_values("Open time").reset_index(drop=True)
tol = pd.Timedelta(seconds=seconds)
used=set(); groups=[]

for i,row in df.iterrows():
if i in used: continue
cur=; used.add(i)
for j in range(i+1, len(df)):
if j in used: continue
r2 = df.iloc[j]
if str(row["Instrument"]) != str(r2["Instrument"]): continue
t1, t2 = row["Open time"], r2["Open time"]
if pd.notna(t1) and pd.notna(t2) and abs(t2 - t1) <= tol:
cur.append(j); used.add(j)
else:
if pd.notna(t1) and pd.notna(t2) and (t2 - t1) > tol:
break
groups.append(cur)

rows=[]
for idxs in groups:
g = df.iloc[idxs]
base = {}
base["Open time"] = pd.to_datetime(g["Open time"]).min()
base["Close time"] = pd.to_datetime(g["Close time"], errors="coerce").max() if "Close time" in g.columns else pd.NaT
base["Instrument"] = str(g["Instrument"].iloc[0])
base["Open price"] = pd.to_numeric(g["Open price"], errors="coerce").iloc[0] if "Open price" in g.columns else pd.NA
base["Close price"]= pd.to_numeric(g["Close price"],errors="coerce").iloc[-1] if "Close price" in g.columns else pd.NA

# KONTRAKTE = MAX(abs(Open volume))
if "Open volume" in g.columns:
contracts = pd.to_numeric(g["Open volume"], errors="coerce").abs().max()
else:
contracts = pd.NA
base["__contracts"] = float(contracts) if (contracts is not pd.NA and pd.notna(contracts)) else pd.NA

# PnL / Ticks summieren
if "PnL" in g.columns:
base["PnL"] = pd.to_numeric(g["PnL"], errors="coerce").fillna(0).sum()
if "Profit (ticks)" in g.columns:
base["Profit (ticks)"] = pd.to_numeric(g["Profit (ticks)"], errors="coerce").fillna(0).sum()

rows.append(base)

out = pd.DataFrame(rows).sort_values("Open time").reset_index(drop=True)
return out

# ---- Screenshot-Finder (rekursiv, Mehrfach-Zuordnung) ----
def _norm(s:str)->str:
s = unicodedata.normalize("NFC", s or "")
return re.sub(r"\s+", " ", s.strip())

def find_screens_for_day(day: dt.date, root: str) -> dict:
"""
Map {trade_nr -> path}. Akzeptiert:
DD.MM, DD.MM.YYYY, YYYY-MM-DD + 'Trade N'
Mehrfach: 'Trade 1 (2 +3)' -> gilt für 1,2,3
"""
mapping={}
if not os.path.isdir(root):
log(f"[SHOT] Ordner fehlt: {root}")
return mapping

dd,mm,yy = day.day, day.month, day.year
pat_date = re.compile(rf"(?:{yy}-{mm:02d}-{dd:02d}|0?{dd}[.\-_/]\s*0?{mm}(?:[.\-_/]\s*{yy})?)", re.I)
pat_ext = re.compile(r"\.(?:png|jpg|jpeg)$", re.I)
pat_main = re.compile(r"trade\s*(\d+)", re.I)
pat_extra= re.compile(r"\(([^)]*)\)")

for dirpath, dirnames, filenames in os.walk(root):
for name in filenames:
if not pat_ext.search(name): continue
n=_norm(name)
if not pat_date.search(n): continue
m=pat_main.search(n)
if not m: continue
nums=[int(m.group(1))]
m2=pat_extra.search(n)
if m2:
for part in re.split(r"[,+\s]+", m2.group(1)):
part=part.strip()
if part.isdigit():
nums.append(int(part))
fpath=os.path.join(dirpath, name)
for no in nums:
mapping.setdefault(no, fpath)

log(f"[SHOT] Zuordnung {day}: {mapping}")
return mapping

# ---- Word-Helfer ----
def add_bold_line(doc, label, value):
p = doc.add_paragraph()
r = p.add_run(f"{label}: ")
r.bold = True
if value is None or (isinstance(value,float) and pd.isna(value)):
p.add_run("–")
else:
p.add_run(str(value))

def add_notes_page_for_trade(doc, trade_nr):
# neue Seite
doc.add_page_break()

# Überschrift
h = doc.add_paragraph()
r = h.add_run(f"Notizen zu Trade {trade_nr}")
r.bold = True
r.font.size = Pt(16)

# Allgemeine Überschrift
p0 = doc.add_paragraph()
r0 = p0.add_run("Erwartungen loslassen")
r0.bold = True
r0.font.size = Pt(12)

doc.add_paragraph() # Leerzeile

def block(label, empty_lines=6):
p = doc.add_paragraph()
rb = p.add_run(f"{label}:")
rb.bold = True
for _ in range(empty_lines):
doc.add_paragraph("")

block("Setup")
block("Struktur/Kontext")
block("Kommentar mit Trademanagement")
block("Emotionaler Stop? Wenn ja warum")

def write_day(doc, df_day: pd.DataFrame, day: dt.date, shots: dict):
section = doc.sections[0]
mg = Pt(24)
section.top_margin = section.bottom_margin = section.left_margin = section.right_margin = mg

doc.add_heading(f"Trade Übersicht – {day.strftime('%Y-%m-%d')}", level=1)

EMU=914400
usable = (section.page_width - section.left_margin - section.right_margin)/EMU

for i,row in df_day.reset_index(drop=True).iterrows():
trade_nr = i+1
doc.add_heading(f"Trade {trade_nr}", level=2)

t = row.get("Open time")
zeit = pd.to_datetime(t).strftime("%d.%m.%Y %H:%M:%S") if pd.notna(t) else "–"

add_bold_line(doc, " Tag + Uhrzeit", zeit)
add_bold_line(doc, " Handelsinstrument", row.get("Instrument","–"))
add_bold_line(doc, " Kontraktanzahl", row.get("__contracts","–"))
add_bold_line(doc, " Entry", row.get("Open price","–"))
add_bold_line(doc, " Exit", row.get("Close price","–"))
pnl = row.get("PnL","–"); ticks = row.get("Profit (ticks)","–")
add_bold_line(doc, " Gewinn/Verlust", f"{pnl} $ ({ticks} Ticks)")

label = f"{day.day:02d}.{day.month:02d} Trade {trade_nr}"
add_bold_line(doc, " Screenshot", label)
path = shots.get(trade_nr)
if path and os.path.exists(path):
try:
doc.add_picture(path, width=Inches(usable*0.98))
except Exception as e:
doc.add_paragraph(f"(Fehler beim Einfügen des Screenshots: {e})")
else:
doc.add_paragraph("(Kein Screenshot gefunden)")

# direkt danach Notizseite
add_notes_page_for_trade(doc, trade_nr)

def export_day(df_day, day: dt.date, shots: dict) -> str:
doc = Document()
write_day(doc, df_day, day, shots)
ensure_dir(EXPORT_DIR)
out = os.path.join(EXPORT_DIR, f"Trade_Übersicht_{day.strftime('%Y-%m-%d')}.docx")
doc.save(out)
log(f"[OK] {out}")
return out

def main():
ensure_dir(EXPORT_DIR)
ensure_dir(SCREEN_DIR)

xlsx = find_latest_atas(ATAS_GLOB)
log(f"[ATAS] Datei: {xlsx}")
df = load_journal(xlsx)
dfg = coalesce_trades(df, seconds=SECONDS_GROUP)
if dfg.empty:
log("[FAIL] Keine Trades gefunden."); return

dfg["__date__"] = pd.to_datetime(dfg["Open time"]).dt.date
days = sorted([d for d in dfg["__date__"].dropna().unique()])

results=[]
for d in days:
d = d if isinstance(d, dt.date) else d.to_pydatetime().date()
df_day = dfg[dfg["__date__"]==d].copy().reset_index(drop=True)
shots = find_screens_for_day(d, SCREEN_DIR)
results.append(export_day(df_day, d, shots))

log("Fertig.")
for r in results: log(" - " + r)

if __name__ == "__main__":
main()

[geraldfo]

Schreib bitte den Python-Code in Code-Tags, damit die Einrückungen nicht verloren gehen!

[oldboyJR]

Da Python eine Sprache hat die super gut einen Text einlesen kann und daraus Argumente generieren kann. Ist es glaube ich einfacher einen Button mit der Funktion exportiere in eine CSV Datei in Excel mit hilfe von Visual Basic zu bauen und aus Exel heraus dann das Pythonprogramm aufzurufen. In Phyton gibt es ja die schicke Funktion commagetrennte Werte als Argumentenliste abzuarbeiten. Alternativ eine HTLM Seite generieren (export HTLM) und auf Xampp Server speichern (computerinterner server). Und die Postwerte mittels Python abzugreifen und sie dann zu verarbeiten. Oder alles in eine SQL Datenbank exportieren
wie mysql welches ebenfalls in Xampp vorhanden ist. Die schwerste Arbeit wird sein den Export und den Import Befehl zu generieren Tip " 'wert' "

[snafu]

Und da du dich komplett im Microsoft Universum bewegst, nimm' CoPilot+ statt ChatGPT. CoPilot+ ist inzwischen relativ tief (und, IMHO, brauchbar) in Office365 integriert, damit solltest du schneller weiter kommen als mit ChatGPT.

Also ich habe die Copilot-Integration zumindest innerhalb von GitHub mal an einem kleineren Projekt getestet. Es liefert grundsätzlich gute Ideen, kennt aber häufig die neueren Features aktueller Python-Versionen nicht und schreibt tendenziell untypischen Code. Ich konnte nichts davon 1:1 übernehmen, aber hatte ein paar gute Ansätze. Das Tool hat mir auch von selbst Erweiterungen vorgeschlagen, die ich ohnehin mal vornehmen wollte. Man kann auch sagen: "Schreibe mir etwas, damit folgender Code funktioniert..." und das Ergebnis funktioniert dann auch tatsächlich, ist nur meist nicht so kompakt und flexibel, wie wenn man es als Python-Programmierer mit einer gewissen Erfahrung selber geschrieben hätte. Ich fand's teilweise witzig, wie mich die KI dann gelobt hatte als ich meine Nachbearbeitung zu dessen Vorschlag vorgelegt habe.

Es war jedenfalls eine interessante Erfahrung für mich. Dass mir kein perfekter Code innerhalb von 5 Minuten geliefert wird, war mir vorher klar. Man muss als Anwender auch lernen wie man gute Prompts formuliert. Und man sollte schon eine genaue Vorstellung davon haben, wo die Reise hingehen soll und eben auch die Zwischenergebnisse der KI verstehen und bearbeiten können. Jedenfalls werde ich weiter dranbleiben und bin natürlich auf die weitere Entwicklung auf diesem Gebiet gespannt. Übrigens bezog ich mich auf das Angebot für 10 USD / Monat. Ich hatte abwechselnd Claude Sonnet und GPT-5 in verschiedenen Stadien meines Codes benutzt, denn es war auch ein Wechsel der KI innerhalb einer laufenden Konversation möglich.

[noisefloor]

Ich habe mit CoPilot+ mal testweise in Word, Excel und BC365 genutzt. Wenn man sich da Zusammenfassung / Pivottabellen bzw. Reports generieren lässt, ist das schon ganz brauchbar. Auf dem Zusammenfassen von Daten in Excel hatte ich CoPilot+ auch bezogen. Das ganze läuft mit einer Firmenlizenz - keine Ahnung, ob das in der privaten Office365 Lizenz anders aussieht.

kennt aber häufig die neueren Features aktueller Python-Versionen nicht und schreibt tendenziell untypischen Code.

Das ist halt das typische "Problem" von KIs - die lernen ja nur von dem, was ihnen vorlegt wird. Wenn jetzt z.B. das kommende Python 3.14 voll das Killerfeature für was auch immer hätte, dann brauchen die KI vermutlich mindestens einen Python-Release, bis sie das "wissen". Weil es dann bis dahin genug Blogeinträge, Forenposts etc. gibt, die das Thema behandeln.

Gruß, noisefloor