romfast/solduri2roa
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
f23b3367d8bc4589914cdf9634f466c710a41fca
solduri2roa/genereaza_xlsx.py
Marius Mutu f23b3367d8 Lane contract: config/conturi_parteneri.csv, divergenta Oracle, poarta de regresie 
Setul de conturi cu parteneri iese din literali si trece in
config/conturi_parteneri.csv, cu categorie si motiv. Comportamentul e neschimbat;
lipsa fisierului opreste cu eroare, nu cade pe set gol.

CONFIG_CONT_IREG ramane consultativ: tools/divergenta_parteneri.py raporteaza
divergenta, nu o aplica. Constatarea (27 conturi in Oracle si nu la noi, 3 la noi
si nu in Oracle - 5121, 5124, 5311) e scrisa in docs/decizii_import.md.

tests/test_regresie.py compara iesirea codului de azi cu tests/golden/ pe valori
de celula, prin anonimizatorul refolosit ca functie. Trece pe FUNDATIA si MASTER;
verificat ca pica la o schimbare reala de set de conturi.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01EYeAtVxeS8m4oXekjX8Am2
2026-09-21 15:53:00 +03:00

528 lines
22 KiB
Python
Raw Blame History

"""Genereaza fisierele xlsx de initializare ROACONT din balantele SAGA (CSV).
Produce (pentru fiecare firma):
init_<FIRMA>_2025_12.xlsx - un sheet, randul 1 = capul de tabel,
datele de la randul 2 in jos
docs/verificare_<FIRMA>.md - verificarile obligatorii
Reguli: docs/decizii_import.md (pct. 11-15) si docs/conturi_cu_analitice.md.
Forma randurilor (revizuit 20.09.2026, vezi pct. 14-15):
- cont obisnuit: doar BALANTA per frunza (acont completat).
- 401/4092/4111/461/462/4551: un BALANTA agregat pe sintetic (acont gol) + cate
un FACTURA per analitic (acont gol).
- 5121/5124: analiticele raman analitice; per analitic un BALANTA cu acont SI un
FACTURA cu ACELASI acont.
- 5311: BALANTA + FACTURA pe sintetic (acont gol), partener CENTRALA.
- 5125: cont obisnuit cu analitice (fara parteneri).
- diferenta neta parinte/copii (postare directa pe sintetic): la nepartener si la
5121/5124 devine rand BALANTA de diferenta (analitic nou, fara FACTURA); la
ceilalti parteneri se include in BALANTA agregat. NU se mai emite FACTURA de
diferenta (o rezolva formularul, prin NEREPARTIZAT).
- analiticul cu sold pe latura opusa celei fixate de formular (':379') primeste
FACTURA, cu suma scrisa cu semn negativ pe latura formularului (atat in BALANTA
cat si in sold-ul FACTURA); soldul ramane pe latura corecta si nu apare NEREPARTIZAT.
"""
import csv
import os
from openpyxl import load_workbook
AN = 2025
LUNA = 12
DATA = "01.12.2025"
DATASCAD = "31.12.2025"
SERIE = None
VALUTA = None
TEMPLATE = "init_facturi_balanta_note.xlsx"
# Latura pe care formularul pune randurile FACTURA (frm...sc2:379/'383'):
# conturile din lista merg pe CREDIT, tot restul pe DEBIT.
LATURA_CREDIT = {"401", "404", "462", "419", "408", "4551"}
# Setul operational de conturi cu parteneri: config/conturi_parteneri.csv (validat
# in productie; CONFIG_CONT_IREG e doar consultativ, vezi docs/decizii_import.md).
# Categoriile CSV corespund celor trei seturi: BANCA, SINTETIC, FARA_ANALITICE.
CONFIG_PARTENERI = os.path.join(os.path.dirname(os.path.abspath(__file__)),
"config", "conturi_parteneri.csv")
class Stop(Exception):
"""Conditie neprevazuta: nu ghicim, raportam."""
def citeste_conturi_parteneri(path=CONFIG_PARTENERI):
"""(BANCA, SINTETIC, FARA_ANALITICE) din CSV; fisier lipsa = eroare, nu set gol."""
if not os.path.exists(path):
raise Stop(f"lipseste fisierul de configurare a partenerilor: {path}")
seturi = {"BANCA": set(), "SINTETIC": set(), "FARA_ANALITICE": set()}
with open(path, encoding="utf-8-sig", newline="") as f:
for r in csv.DictReader(f):
cont = (r.get("cont") or "").strip()
categorie = (r.get("categorie") or "").strip()
if not cont:
continue
if categorie not in seturi:
raise Stop(f"categorie necunoscuta in {path}: {categorie!r}")
seturi[categorie].add(cont)
return seturi["BANCA"], seturi["SINTETIC"], seturi["FARA_ANALITICE"]
# BANCA (5121/5124): analiticele raman analitice SI primesc partener.
# SINTETIC: un singur BALANTA agregat pe sintetic + FACTURA per analitic.
# FARA_ANALITICE (5311): fara analitice, BALANTA + FACTURA pe sintetic.
(PARTENER_BANCA, PARTENER_SINTETIC,
PARTENER_FARA_ANALITICE) = citeste_conturi_parteneri()
PARTENER = PARTENER_BANCA | PARTENER_SINTETIC | PARTENER_FARA_ANALITICE
FIRME = [
("FUNDATIA", "balanta_FUNDATIA.csv"),
("MASTER", "balanta_MASTERJOB.csv"),
]
def citeste_header():
wb = load_workbook(TEMPLATE, read_only=True)
ws = wb.active
hdr = [c.value for c in ws[1]]
wb.close()
return hdr
def citeste_balanta(path):
rows = []
with open(path, encoding="utf-8-sig", newline="") as f:
for r in csv.DictReader(f):
cont = (r["cont"] or "").strip()
if r["este_total"] == "1" or cont == "":
continue
rows.append({
"cont": cont,
"denumire": (r["denumire"] or "").strip(),
"total_d": float(r["total_d"]),
"total_c": float(r["total_c"]),
})
return rows
def citeste_totaluri(path):
with open(path, encoding="utf-8-sig", newline="") as f:
for r in csv.DictReader(f):
if "totaluri" in (r["denumire"] or "").lower():
return float(r["total_d"]), float(r["total_c"])
return None
def arbore(rows):
by = {r["cont"]: r for r in rows}
children = {}
for c in by:
p = ".".join(c.split(".")[:-1])
if p in by:
children.setdefault(p, []).append(c)
return by, children
def este_partener(cont):
return cont.split(".")[0] in PARTENER
def latura_factura(cont):
"""Latura fixa pe care formularul pune randurile FACTURA ale contului."""
return "C" if cont.split(".")[0] in LATURA_CREDIT else "D"
def split_cont(cont):
seg = cont.split(".")
return seg[0], "".join(seg[1:])
def diferente(by, children):
"""(cont_parinte, diferenta_net) pentru parintii cu postare directa."""
out = []
for cont, r in by.items():
kids = children.get(cont)
if not kids:
continue
pnet = round(r["total_d"] - r["total_c"], 2)
cnet = round(sum(by[k]["total_d"] - by[k]["total_c"] for k in kids), 2)
d = round(pnet - cnet, 2)
if abs(d) > 0.005:
out.append((cont, d))
return out
def acont_diferenta(parent, kids):
"""Primul cod liber de forma 99 (segmente scurte) / 9999 (segmente lungi)."""
seg = parent.split(".")
base = "".join(seg[1:])
style = 2 if max(len(k.split(".")[-1]) for k in kids) <= 2 else 4
cod = "99" if style == 2 else "9999"
ac = base + cod
if len(ac) > 4:
raise Stop(f"acont diferenta prea lung pentru {parent}: '{ac}'")
frati = {split_cont(k)[1] for k in kids}
if ac in frati:
raise Stop(f"acont diferenta '{ac}' deja folosit sub {parent}")
return ac
def rand(header, **kw):
r = {h: None for h in header}
r.update(an=AN, luna=LUNA, data=DATA, datascad=DATASCAD,
serie=SERIE, valuta=VALUTA)
r.update(kw)
return r
def este_latura_formular(net, side):
return (net > 0) == (side == "D")
def genereaza(rows, header):
by, children = arbore(rows)
diffs = diferente(by, children)
diff_by_parent = dict(diffs)
# verificarile de structura care nu se ghicesc
for cont in by:
if este_partener(cont):
continue
if cont not in children:
cont4, ac = split_cont(cont)
if len(cont4) > 4 or len(ac) > 4:
raise Stop(f"cont/acont prea lung: {cont} -> ({cont4},{ac})")
for parent in diff_by_parent:
if not este_partener(parent) or parent.split(".")[0] in PARTENER_BANCA:
acont_diferenta(parent, children[parent])
for p in {c.split(".")[0] for c in by if este_partener(c)}:
for k in children.get(p, []):
if k in children:
raise Stop(f"analitic partener cu sub-analitice: {k}")
out = []
leaf_map = {} # frunza -> randurile dedicate (folosite la dubluri)
leaf_rep = set() # toate frunzele reprezentate (inclusiv in BALANTA agregat)
negative = [] # (cont, analitic, sold_semnat, latura_formular)
def add(r, leaf=None):
out.append(r)
if leaf is not None:
leaf_map.setdefault(leaf, []).append(len(out) - 1)
leaf_rep.add(leaf)
# A. conturi nepartener: cate un BALANTA per frunza
for r in rows:
if este_partener(r["cont"]) or r["cont"] in children:
continue
cont4, ac = split_cont(r["cont"])
add(rand(header, TIP="BALANTA", cont=cont4, acont=ac, numar=1,
nume=r["denumire"], totdeb=round(r["total_d"], 2),
totcred=round(r["total_c"], 2)), leaf=r["cont"])
# A. analitic de diferenta pe parinte nepartener (postare directa pe sintetic)
for cont, d in diffs:
if este_partener(cont):
continue
ac = acont_diferenta(cont, children[cont])
add(rand(header, TIP="BALANTA", cont=cont.split(".")[0], acont=ac,
numar=1, nume="DIFERENTA SINTETIC SAGA",
totdeb=d if d > 0 else None,
totcred=-d if d < 0 else None))
parteneri = sorted({c.split(".")[0] for c in by if este_partener(c)})
for p in parteneri:
direct = children.get(p, [])
side = latura_factura(p)
if p in PARTENER_BANCA and direct:
# 5121/5124: BALANTA cu acont + FACTURA cu ACELASI acont.
for k in direct:
kd = by[k]
kac = split_cont(k)[1]
net = round(kd["total_d"] - kd["total_c"], 2)
if net != 0 and not este_latura_formular(net, side):
neg = -abs(net)
negative.append((p, k, neg, side))
if side == "D":
td, tc = neg, None
else:
td, tc = None, neg
else:
td, tc = round(kd["total_d"], 2), round(kd["total_c"], 2)
add(rand(header, TIP="BALANTA", cont=p, acont=kac, numar=1,
nume=kd["denumire"], totdeb=td, totcred=tc), leaf=k)
if net == 0:
continue
sold = abs(net) if este_latura_formular(net, side) else -abs(net)
add(rand(header, TIP="FACTURA", cont=p, acont=kac,
numar=k.replace(".", ""),
nume=kd["denumire"] or f"FURNIZOR {k}",
cod_fiscal=k, sold=sold, explicatia=side))
if p in diff_by_parent:
d = diff_by_parent[p]
ac = acont_diferenta(p, direct)
add(rand(header, TIP="BALANTA", cont=p, acont=ac, numar=1,
nume="DIFERENTA SINTETIC SAGA",
totdeb=d if d > 0 else None,
totcred=-d if d < 0 else None))
continue
# 401/4092/4111/461/462/4551 si 5311
if direct:
base_d = 0.0
base_c = 0.0
for k in direct:
net = round(by[k]["total_d"] - by[k]["total_c"], 2)
if net != 0 and not este_latura_formular(net, side):
neg = -abs(net)
negative.append((p, k, neg, side))
if side == "D":
base_d += neg
else:
base_c += neg
else:
base_d += by[k]["total_d"]
base_c += by[k]["total_c"]
d = diff_by_parent.get(p, 0.0)
add(rand(header, TIP="BALANTA", cont=p, acont=None, numar=1,
nume=by[p]["denumire"],
totdeb=round(base_d + (d if d > 0 else 0.0), 2),
totcred=round(base_c + (-d if d < 0 else 0.0), 2)))
for k in direct:
net = round(by[k]["total_d"] - by[k]["total_c"], 2)
if net == 0:
leaf_rep.add(k)
continue
sold = abs(net) if este_latura_formular(net, side) else -abs(net)
add(rand(header, TIP="FACTURA", cont=p, acont=None,
numar=k.replace(".", ""),
nume=by[k]["denumire"] or f"FURNIZOR {k}",
cod_fiscal=k, sold=sold, explicatia=side),
leaf=k)
else:
net = round(by[p]["total_d"] - by[p]["total_c"], 2)
if net != 0 and not este_latura_formular(net, side):
neg = -abs(net)
negative.append((p, p, neg, side))
if side == "D":
td, tc = neg, None
else:
td, tc = None, neg
else:
td = round(by[p]["total_d"], 2)
tc = round(by[p]["total_c"], 2)
add(rand(header, TIP="BALANTA", cont=p, acont=None, numar=1,
nume=by[p]["denumire"], totdeb=td, totcred=tc), leaf=p)
if net != 0:
nume = "CENTRALA" if p == "5311" else by[p]["denumire"]
sold = abs(net) if este_latura_formular(net, side) else -abs(net)
add(rand(header, TIP="FACTURA", cont=p, acont=None,
numar=p, nume=nume, cod_fiscal=p, sold=sold,
explicatia=side))
return out, diffs, leaf_map, leaf_rep, negative
def scrie_xlsx(header, rows, path):
wb = load_workbook(TEMPLATE)
ws = wb.active
if ws.max_row > 1:
ws.delete_rows(2, ws.max_row - 1)
for i, r in enumerate(rows, start=2):
for j, h in enumerate(header, start=1):
v = r.get(h)
if h == "explicatia": # coloana temporara de control
v = None
ws.cell(i, j, v)
wb.save(path)
def verifica(firma, csv_path, xlsx_path, rows, out, diffs, leaf_map, leaf_rep,
negative, header):
by, children = arbore(rows)
leaves = [c for c in by if c not in children]
diff_by_parent = dict(diffs)
totdeb = round(sum(r["totdeb"] or 0 for r in out), 2)
totcred = round(sum(r["totcred"] or 0 for r in out), 2)
net = round(totdeb - totcred, 2)
toturi = citeste_totaluri(csv_path)
pierdute = sorted(set(leaves) - leaf_rep)
duplicate_leaf = sorted(c for c, v in leaf_map.items() if len(v) != 1)
# lungimi + dubluri (cont,acont) pe BALANTA
lungimi = []
bal_pairs = {}
for r in out:
if len(r["cont"]) > 4:
lungimi.append(("cont", r["cont"]))
if r["acont"] and len(r["acont"]) > 4:
lungimi.append(("acont", r["acont"]))
if r["TIP"] == "BALANTA":
bal_pairs.setdefault((r["cont"], r["acont"]), []).append(r)
dubluri_bal = {k: v for k, v in bal_pairs.items() if len(v) > 1}
# parteneri: SUM(sold FACTURA cu semn) + NEREPARTIZAT asteptat = net sintetic
part_rows = {}
for r in out:
if r["TIP"] == "FACTURA":
semn = 1 if latura_factura(r["cont"]) == "D" else -1
part_rows[r["cont"]] = part_rows.get(r["cont"], 0.0) + semn * (r["sold"] or 0)
part_verif = []
for p in sorted({c.split(".")[0] for c in by if este_partener(c)}):
net_sint = round(by[p]["total_d"] - by[p]["total_c"], 2)
suma = round(part_rows.get(p, 0.0), 2)
direct = round(diff_by_parent.get(p, 0.0), 2)
asteptat = direct
diferenta = round(net_sint - suma, 2)
ok = abs(diferenta - asteptat) <= 0.005
part_verif.append((p, suma, net_sint, direct, asteptat, diferenta, ok))
ok_bal = abs(net) <= 0.005
ok_leaves = not pierdute and not duplicate_leaf
ok_part = all(x[6] for x in part_verif)
ok_lung = not lungimi and not dubluri_bal
L = []
L.append(f"# Verificare `{os.path.basename(xlsx_path)}`")
L.append("")
L.append(f"Generat de `genereaza_xlsx.py` din `{os.path.basename(csv_path)}`. "
f"Randuri de date: {len(out)} ({sum(1 for r in out if r['TIP']=='BALANTA')} BALANTA, "
f"{sum(1 for r in out if r['TIP']=='FACTURA')} FACTURA).")
L.append("")
L.append("## 1. Balanta generala (SUM totdeb = SUM totcred)")
L.append("")
L.append(f"- SUM(totdeb) = {totdeb}")
L.append(f"- SUM(totcred) = {totcred}")
L.append(f"- diferenta (totdeb - totcred) = {net} -> {'OK' if ok_bal else '**ESEC**'}")
if toturi:
td, tc = toturi
L.append(f"- Totaluri balanta: total_d={td} total_c={tc} "
f"net={round(td - tc, 2)}")
L.append(f"- NET xlsx ({net}) vs NET Totaluri ({round(td - tc, 2)}) -> "
f"{'OK' if abs(net - (td - tc)) <= 0.005 else '**ESEC**'}")
L.append(f"- Nota: SUM(totdeb)={totdeb} difera de Totaluri.total_d={td} cu "
f"{round(totdeb - td, 2)}; suma pe laturi a PDF-ului nu se poate "
f"reconstrui din frunze acolo unde SAGA a netat sinteticul (gross-ul "
f"parintelui e netat). Netul se pastreaza exact.")
L.append("")
L.append("## 2. Conturi frunza din CSV, reprezentate o singura data")
L.append("")
L.append(f"- frunze in CSV: {len(leaves)}")
L.append(f"- reprezentate in xlsx: {len(leaf_rep)}")
L.append(f"- conturi pierdute: {pierdute if pierdute else '[] (gol)'} -> "
f"{'OK' if not pierdute else '**ESEC**'}")
L.append(f"- frunze cu mai putin/mai mult de un rand dedicat: "
f"{duplicate_leaf if duplicate_leaf else '[] (gol)'} -> "
f"{'OK' if not duplicate_leaf else '**ESEC**'}")
L.append("")
L.append("## 3. Conturi partener: FACTURA + NEREPARTIZAT = net sintetic")
L.append("")
L.append("Formularul scade din randul BALANTA suma randurilor FACTURA de pe "
"acelasi `(cont, acont, latura)` si lasa restul pe partenerul "
"`NEREPARTIZAT`. Deci: `net sintetic - SUM(sold FACTURA cu semn) = "
"postare directa pe sintetic`.")
L.append("")
L.append("| cont | SUM(sold FACTURA) | net sintetic | postare directa | NEREPARTIZAT asteptat | diferenta | rezultat |")
L.append("|---|---|---|---|---|---|---|")
for p, suma, net_sint, direct, asteptat, diferenta, ok in part_verif:
L.append(f"| {p} | {suma} | {net_sint} | {direct} | {asteptat} "
f"| {diferenta} | {'OK' if ok else '**ESEC**'} |")
L.append("")
L.append(f"Rezultat: {'OK' if ok_part else '**ESEC**'}")
L.append("")
L.append("## 4. Analitice cu semn negativ (sold pe latura opusa formularului)")
L.append("")
L.append("Latura FACTURA e fixa in cod (`:379`): `401,404,462,419,408,4551` -> "
"CREDIT, orice alt cont -> DEBIT. Un analitic cu sold pe latura opusa "
"primeste totusi rand FACTURA, iar suma se scrie cu **semn negativ pe "
"latura formularului**, atat in randul BALANTA cat si in `sold`-ul "
"randului FACTURA. Soldul ramane pe latura corecta, balanta ramane "
"inchisa, iar randul FACTURA consuma exact randul BALANTA (fara "
"`NEREPARTIZAT`).")
L.append("")
if not negative:
L.append("Niciunul.")
else:
L.append("| cont | analitic | sold (semnat) | latura formularului |")
L.append("|---|---|---|---|")
for cont, k, s, side in negative:
L.append(f"| {cont} | {k} | {s} | {side} |")
L.append("")
L.append("## 5. Lungimi si dubluri")
L.append("")
L.append(f"- cont > 4 sau acont > 4: {lungimi if lungimi else '[] (gol)'} -> "
f"{'OK' if not lungimi else '**ESEC**'}")
L.append(f"- perechi (cont, acont) duplicate la BALANTA: "
f"{list(dubluri_bal) if dubluri_bal else '[] (gol)'} -> "
f"{'OK' if not dubluri_bal else '**ESEC**'}")
L.append("")
L.append("## 6. Randuri de diferenta generate (pct. 13-15)")
L.append("")
if not diffs:
L.append("Niciunul (toate diferentele nete sunt zero).")
for cont, d in diffs:
base = cont.split(".")[0]
if base in PARTENER_BANCA:
kind = "BALANTA (analitic de diferenta, fara FACTURA)"
elif este_partener(cont):
kind = "inclus in BALANTA agregat al sinteticului (fara FACTURA)"
else:
kind = "BALANTA (analitic de diferenta)"
L.append(f"- {cont}: diferenta neta {d} -> {kind}")
L.append("")
L.append("Nota: randurile FACTURA de tip `DIFERENTA SINTETIC` au fost eliminate; "
"diferenta nu se mai inventa, o rezolva formularul prin `NEREPARTIZAT`.")
L.append("")
L.append("## Verdict")
L.append("")
toate = ok_bal and ok_leaves and ok_part and ok_lung
L.append(f"{'TOATE verificarile au trecut.' if toate else '**UNA SAU MAI MULTE VERIFICARI AU PICAT - datele NU au fost ajustate.**'}")
L.append("")
L.append("Nota: coloana `explicatia` (D/C la FACTURA) a fost folosita doar ca "
"control intern si este goala in xlsx-ul final (capul de tabel o pastreaza).")
L.append("")
with open(os.path.join("docs", f"verificare_{firma}.md"), "w",
encoding="utf-8") as f:
f.write("\n".join(L))
return {"bal": ok_bal, "leaves": ok_leaves, "part": ok_part, "lung": ok_lung,
"totdeb": totdeb, "totcred": totcred, "net": net,
"pierdute": pierdute, "dubluri_leaf": duplicate_leaf,
"dubluri_bal": list(dubluri_bal), "lungimi": lungimi,
"part_verif": part_verif, "negative": negative}
def main():
header = citeste_header()
assert len(header) == 39, f"cap de tabel neasteptat: {len(header)} coloane"
for firma, csv_path in FIRME:
rows = citeste_balanta(csv_path)
out, diffs, leaf_map, leaf_rep, negative = genereaza(rows, header)
xlsx_path = f"init_{firma}_2025_12.xlsx"
scrie_xlsx(header, out, xlsx_path)
rez = verifica(firma, csv_path, xlsx_path, rows, out, diffs, leaf_map,
leaf_rep, negative, header)
print(f"=== {firma} ===")
print(f" rows: {len(out)} totdeb={rez['totdeb']} totcred={rez['totcred']} net={rez['net']}")
print(f" balanta={'OK' if rez['bal'] else 'ESEC'} "
f"frunze={'OK' if rez['leaves'] else 'ESEC'} "
f"parteneri={'OK' if rez['part'] else 'ESEC'} "
f"lungimi={'OK' if rez['lung'] else 'ESEC'}")
print(f" scris {xlsx_path} si docs/verificare_{firma}.md")
if rez["negative"]:
print(f" analitice cu semn negativ: {rez['negative']}")
if rez["pierdute"] or rez["dubluri_leaf"] or rez["dubluri_bal"] or rez["lungimi"]:
print(" ATENTIE:", rez["pierdute"], rez["dubluri_leaf"],
rez["dubluri_bal"], rez["lungimi"])
if __name__ == "__main__":
main()
Reference in New Issue View Git Blame Copy Permalink