matematicsolutions/awesome-matematic-skills-pl / dokumenty/skills/chronologia-stanowiska-pl
chronologia-stanowiska-pl
VerifiedDla prawnika prowadzącego spór. Z tekstu akt (wynik akta-przeszukiwalne-pl) buduje chronologię zdarzeń albo zestawienie stanowisk stron (element roszczenia x twierdzenie x stanowisko przeciwnika x dowody x luka), a mechaniczna bramka sprawdza, czy każdy wpis wskazuje istniejący plik i stronę akt i czy cytat naprawdę na niej stoi. Wpis bez kotwicy w aktach nie przechodzi. Z perspektywy powoda albo pozwanego (także oskarżyciela i obrony). Nie ocenia, kto ma rację, nie rozstrzyga sprzeczności i nie liczy terminów. Używaj gdy: "zrób chronologię z akt", "oś czasu sprawy", "co się działo kiedy", "zestawienie stanowisk stron", "co przyznał pozwany", "czego nam brakuje do udowodnienia", "stan faktyczny do pisma", "chronologia dla świadka".
| File | Kind | Size |
|---|---|---|
| LICENSE | other | 11.1 KB |
| NOTICE | other | 3.8 KB |
| SKILL.md | skill md | 16.2 KB |
| scripts/bramka_lokatorow.py | script | 19.7 KB |
| tests/fixtures/akta-tekst/korespondencja.txt | markdown | 260 B |
| tests/fixtures/akta-tekst/odpowiedz-na-pozew.txt | markdown | 367 B |
| tests/fixtures/akta-tekst/pozew.txt | markdown | 528 B |
| tests/fixtures/akta-tekst/umowa.txt | markdown | 368 B |
| tests/fixtures/chronologia.json | config | 2.4 KB |
| tests/fixtures/zestawienie.json | config | 2.2 KB |
| tests/test_bramka.py | script | 6.7 KB |
| tests/test_odcisk_i_profil.py | script | 5.2 KB |
scripts/bramka_lokatorow.py
View on GitHub#!/usr/bin/env python3
"""Bramka lokatorow dla chronologii akt i zestawienia stanowisk.
Sprawdza mechanicznie (bez LLM, bez sieci), czy kazdy wpis chronologii albo
zestawienia stanowisk wskazuje plik i strone, ktore istnieja w tekscie akt
(wynik akta-przeszukiwalne-pl), i czy cytat naprawde stoi na tej stronie.
Kod wyjscia: 0 = OK, 10 = UWAGI, 20 = BLOKADA. Pusta lista wpisow = BLOKADA.
Na ekran trafiaja wylacznie liczby i identyfikatory wpisow; tresc akt zostaje
w pliku raportu obok pliku JSON.
Od v0.2.0:
- odcisk akt: wynik niesie `akta_odcisk` {plik: sha256 tekstu}; zmiana tekstu akt po
budowie wyniku (np. ponowny OCR) nie przechodzi po cichu (OD01-OD04),
- nieocenione != pusto: pole listy nieobecne = nie oceniono (NA01), `[]` = sprawdzono,
- `--profil sad`: watpliwosci, ktore w pracy roboczej sa UWAGAMI, przed sadem blokuja.
Uzycie:
python bramka_lokatorow.py WYNIK.json AKTA_TEKST_DIR [--csv OUT.csv] [--profil robocza|sad]
"""
from __future__ import annotations
import argparse
import csv
import datetime as dt
import hashlib
import json
import re
import sys
import unicodedata
from pathlib import Path
WERSJA = "0.2.0"
OK, UWAGI, BLOKADA = 0, 10, 20
NAZWA_STANU = {OK: "OK", UWAGI: "UWAGI", BLOKADA: "BLOKADA"}
# Kody, ktore w profilu "sad" przechodza z UWAG w BLOKADE. Lista jawna, nie "wszystko":
# do pisma nie idzie wynik z nieznanej wersji akt, nieoceniona komorka, cytat ze strony
# nieczytelnej albo zgodny tylko bez ogonkow, ani fakt spoza akt.
ZAOSTRZANE_W_SADZIE = {"OD01", "OD02", "OD03", "NA01", "ZR05", "ZR07", "ZR11", "ZR12"}
SHA_RE = re.compile(r"^[0-9a-f]{64}$")
PAGE_RE = re.compile(r"^===== (?:strona|page|página) (\d+) =====$", re.M)
NIECZYTELNA = "[STRONA NIECZYTELNA"
ENUM = {
"pewnosc_daty": {"dokladna", "miesiac", "rok", "przedzial", "przyblizona", "sporna"},
"rodzaj_daty": {"zdarzenia", "dokumentu", "nadania", "doreczenia", "wplywu", "posiedzenia"},
"waga": {"kluczowe", "istotne", "tlo"},
"status": {"dowod_bezposredni", "relacja", "twierdzenie_strony", "ustalenie_sadu",
"zdarzenie_procesowe", "wniosek"},
"pochodzenie": {"akta", "uzytkownik", "wiedza_modelu", "internet"},
"tajemnica": {"ok", "flaga", "do_przegladu"},
"postawa_tajemnicy": {"A", "B", "C"},
"stanowisko_przeciwnika": {"przyznanie", "przyznanie_z_zastrzezeniem", "zaprzeczenie",
"brak_stanowiska", "nie_dotyczy"},
"stan": {"wykazane", "czesciowo", "sporne", "luka", "do_uzupelnienia"},
}
DATA_RE = re.compile(r"^\d{4}(-\d{2}(-\d{2})?)?$")
FORMULA_START = ("=", "+", "-", "@", "\t", "\r")
# --- normalizacja tekstu -------------------------------------------------
def _norm(s: str) -> str:
s = s.replace("\u00ad", "") # miekki dywiz
s = re.sub(r"(\w)-\s*\n\s*(\w)", r"\1\2", s) # przeniesienie wyrazu
s = s.replace("\u201e", '"').replace("\u201d", '"').replace("\u201c", '"')
s = s.replace("\u2019", "'").replace("\u2013", "-").replace("\u2014", "-")
return re.sub(r"\s+", " ", s).strip().lower()
def _bez_ogonkow(s: str) -> str:
s = s.replace("ł", "l").replace("Ł", "L")
return "".join(c for c in unicodedata.normalize("NFKD", s) if not unicodedata.combining(c))
# --- akta ----------------------------------------------------------------
def wczytaj_akta(katalog: Path) -> dict[str, dict[int, str]]:
akta: dict[str, dict[int, str]] = {}
for p in sorted(katalog.glob("*.txt")):
tekst = p.read_text(encoding="utf-8", errors="replace")
strony: dict[int, str] = {}
znaczniki = list(PAGE_RE.finditer(tekst))
for i, m in enumerate(znaczniki):
koniec = znaczniki[i + 1].start() if i + 1 < len(znaczniki) else len(tekst)
strony[int(m.group(1))] = tekst[m.end():koniec]
if strony:
akta[p.stem.lower()] = strony
return akta
def odcisk_akt(katalog: Path) -> dict[str, str]:
"""sha256 TEKSTU kazdego pliku akt (konce linii ujednolicone do LF).
Nie skrot PDF z naglowka akta.py: ponowny OCR tego samego PDF zmienia tekst,
a skrot PDF zostaje ten sam - a cytaty sprawdzamy wlasnie na tekscie.
"""
wynik: dict[str, str] = {}
for p in sorted(katalog.glob("*.txt")):
tekst = p.read_bytes().decode("utf-8", errors="replace").replace("\r\n", "\n")
wynik[p.stem.lower()] = hashlib.sha256(tekst.encode("utf-8")).hexdigest()
return wynik
def _klucz_pliku(nazwa: str) -> str:
n = Path(str(nazwa)).name
for ext in (".txt", ".pdf"):
if n.lower().endswith(ext):
n = n[: -len(ext)]
return n.lower()
# --- kontrole ------------------------------------------------------------
class Wynik:
def __init__(self) -> None:
self.znaleziska: list[tuple[int, str, str, str]] = [] # (stan, id, kod, opis)
self.uzyte_pliki: set[str] = set() # pliki akt wskazane przez zrodla wyniku
def dodaj(self, stan: int, wid: str, kod: str, opis: str) -> None:
self.znaleziska.append((stan, wid, kod, opis))
def zaostrz(self, kody: set[str]) -> int:
"""Profil sad: UWAGI z podanymi kodami -> BLOKADA. Zwraca liczbe zaostrzonych."""
n = 0
for i, (s, wid, kod, opis) in enumerate(self.znaleziska):
if s == UWAGI and kod in kody:
self.znaleziska[i] = (BLOKADA, wid, kod, opis + " [profil sad]")
n += 1
return n
def stan_wpisu(self, wid: str) -> int:
return max([s for s, i, _, _ in self.znaleziska if i == wid], default=OK)
def sprawdz_zrodlo(z: dict, akta: dict, wid: str, w: Wynik, pole: str) -> None:
if not isinstance(z, dict):
w.dodaj(BLOKADA, wid, "ZR00", f"{pole}: zrodlo nie jest obiektem")
return
plik, strona, cytat = z.get("plik"), z.get("strona"), (z.get("cytat") or "").strip()
if not plik or strona is None:
w.dodaj(BLOKADA, wid, "ZR01", f"{pole}: brak pliku albo strony")
return
klucz = _klucz_pliku(plik)
w.uzyte_pliki.add(klucz)
if klucz not in akta:
w.dodaj(BLOKADA, wid, "ZR02", f"{pole}: pliku '{klucz}' nie ma w tekscie akt")
return
try:
strona = int(strona)
except (TypeError, ValueError):
w.dodaj(BLOKADA, wid, "ZR03", f"{pole}: strona '{strona}' nie jest liczba")
return
strony = akta[klucz]
if strona not in strony:
w.dodaj(BLOKADA, wid, "ZR04", f"{pole}: plik '{klucz}' nie ma strony {strona} (ma {len(strony)})")
return
tekst_strony = strony[strona]
if NIECZYTELNA in tekst_strony:
w.dodaj(UWAGI, wid, "ZR05", f"{pole}: strona {strona} pliku '{klucz}' nieczytelna w OCR - porownaj z oryginalem")
return
if len(cytat.split()) < 3:
w.dodaj(BLOKADA, wid, "ZR06", f"{pole}: cytat krotszy niz 3 slowa - nie da sie go zakotwiczyc")
return
n_cyt, n_str = _norm(cytat), _norm(tekst_strony)
if n_cyt in n_str:
return
if _bez_ogonkow(n_cyt) in _bez_ogonkow(n_str):
w.dodaj(UWAGI, wid, "ZR07", f"{pole}: cytat zgadza sie tylko bez polskich znakow (blad OCR?) - plik '{klucz}' s. {strona}")
return
inne = [nr for nr, t in strony.items() if nr != strona and n_cyt in _norm(t)]
if inne:
w.dodaj(BLOKADA, wid, "ZR08", f"{pole}: cytat jest w pliku '{klucz}', ale na stronie {inne[0]}, nie {strona}")
else:
w.dodaj(BLOKADA, wid, "ZR09", f"{pole}: cytatu nie ma na stronie {strona} pliku '{klucz}'")
def _enum(wpis: dict, pole: str, wid: str, w: Wynik, wymagane: bool = True) -> None:
v = wpis.get(pole)
if v is None:
if wymagane:
w.dodaj(BLOKADA, wid, "SC01", f"brak pola '{pole}'")
return
if v not in ENUM[pole]:
w.dodaj(BLOKADA, wid, "SC02", f"pole '{pole}' = '{v}' spoza listy {sorted(ENUM[pole])}")
def _data(wpis: dict, wid: str, w: Wynik) -> None:
d = str(wpis.get("data") or "").strip()
if not d:
w.dodaj(BLOKADA, wid, "DT01", "brak daty (wpis bez daty nie nalezy do chronologii - wpisz go w luki)")
return
czesci = d.split("/")
if len(czesci) > 2 or not all(DATA_RE.match(c) for c in czesci):
w.dodaj(BLOKADA, wid, "DT02", f"data '{d}' nie jest w formacie RRRR[-MM[-DD]] ani przedzialem A/B")
return
for c in czesci:
if len(c) == 10:
try:
dt.date.fromisoformat(c)
except ValueError:
w.dodaj(BLOKADA, wid, "DT03", f"data '{c}' nie istnieje w kalendarzu")
return
pewnosc = wpis.get("pewnosc_daty")
if pewnosc == "dokladna" and (len(czesci) != 1 or len(czesci[0]) != 10):
w.dodaj(UWAGI, wid, "DT04", "pewnosc 'dokladna', ale data nie jest pelnym dniem")
if pewnosc == "przedzial" and len(czesci) != 2:
w.dodaj(UWAGI, wid, "DT05", "pewnosc 'przedzial', ale data nie ma postaci A/B")
if pewnosc in ("przedzial", "przyblizona"):
# przedzial albo data przyblizona bywa wyznaczona przez model, a nie przepisana z akt
w.dodaj(UWAGI, wid, "DT06", f"data niepewna ('{pewnosc}') - sprawdz, czy wynika z akt, czy zostala wyznaczona")
def _zrodla_lub_pochodzenie(wpis: dict, pole: str, akta: dict, wid: str, w: Wynik) -> None:
zrodla = wpis.get(pole) or []
pochodzenie = wpis.get("pochodzenie", "akta")
if not zrodla:
if pochodzenie == "akta":
w.dodaj(BLOKADA, wid, "ZR10", f"{pole}: wpis 'z akt' bez zadnego zrodla")
else:
w.dodaj(UWAGI, wid, "ZR11", f"pochodzenie '{pochodzenie}' bez zrodla w aktach - zweryfikuj przed uzyciem")
return
for i, z in enumerate(zrodla):
sprawdz_zrodlo(z, akta, wid, w, f"{pole}[{i}]")
if pochodzenie != "akta":
w.dodaj(UWAGI, wid, "ZR12", f"pochodzenie '{pochodzenie}' - fakt spoza akt nigdy nie przechodzi jako OK, nawet z kotwica")
def sprawdz_chronologie(dane: dict, akta: dict, w: Wynik) -> list[dict]:
wpisy = dane.get("wpisy") or []
postawa = dane.get("postawa_tajemnicy")
for wpis in wpisy:
wid = str(wpis.get("id") or "?")
_data(wpis, wid, w)
for pole in ("pewnosc_daty", "rodzaj_daty", "waga", "status"):
_enum(wpis, pole, wid, w)
_enum(wpis, "pochodzenie", wid, w, wymagane=False)
if not (wpis.get("zdarzenie") or "").strip():
w.dodaj(BLOKADA, wid, "SC03", "puste pole 'zdarzenie'")
if postawa == "B":
_enum(wpis, "tajemnica", wid, w)
_zrodla_lub_pochodzenie(wpis, "zrodla", akta, wid, w)
if wpis.get("status") == "wniosek" and not (wpis.get("uwagi") or "").strip():
w.dodaj(UWAGI, wid, "WN01", "status 'wniosek' bez uzasadnienia w polu 'uwagi'")
kluczowe = sum(1 for x in wpisy if x.get("waga") == "kluczowe")
if len(wpisy) >= 4 and kluczowe > len(wpisy) / 2:
w.dodaj(UWAGI, "*", "WG01", f"{kluczowe} z {len(wpisy)} wpisow 'kluczowe' - gdy wszystko jest kluczowe, nic nie jest")
return wpisy
def sprawdz_zestawienie(dane: dict, akta: dict, w: Wynik) -> list[dict]:
elementy = dane.get("elementy") or []
for el in elementy:
wid = str(el.get("id") or "?")
if not (el.get("element") or "").strip():
w.dodaj(BLOKADA, wid, "SC03", "puste pole 'element'")
_enum(el, "stan", wid, w)
_enum(el, "stanowisko_przeciwnika", wid, w)
for pole in ("twierdzenia", "dowody_za", "dowody_przeciw"):
if pole not in el:
w.dodaj(UWAGI, wid, "NA01", f"pole '{pole}' nieobecne = nieocenione "
"(pusta lista [] znaczy: sprawdzono, nic nie ma)")
for pole in ("twierdzenia", "zrodla_stanowiska", "dowody_za", "dowody_przeciw"):
for i, z in enumerate(el.get(pole) or []):
sprawdz_zrodlo(z, akta, wid, w, f"{pole}[{i}]")
stan, za = el.get("stan"), el.get("dowody_za") or []
if stan == "wykazane" and not za:
w.dodaj(BLOKADA, wid, "ST01", "stan 'wykazane' bez zadnego dowodu za")
if stan == "luka" and za:
w.dodaj(UWAGI, wid, "ST02", "stan 'luka', a sa dowody za - sprawdz, czy to nie 'czesciowo'")
if el.get("stanowisko_przeciwnika") not in (None, "nie_dotyczy", "brak_stanowiska") \
and not el.get("zrodla_stanowiska"):
w.dodaj(BLOKADA, wid, "ST03", "stanowisko przeciwnika podane bez wskazania pisma, z ktorego wynika")
return elementy
def sprawdz_odcisk(dane: dict, aktualny: dict[str, str], w: Wynik) -> str:
"""Porownuje `akta_odcisk` wyniku z biezacym tekstem akt. Zwraca krotki stan do wydruku."""
zadeklarowany = dane.get("akta_odcisk")
if zadeklarowany is None:
w.dodaj(UWAGI, "naglowek", "OD01", "brak pola 'akta_odcisk' - nie da sie wykazac, na jakiej "
"wersji tekstu akt zbudowano wynik (odcisk do wpisania jest w tym raporcie)")
return "brak"
if not isinstance(zadeklarowany, dict) or not zadeklarowany \
or not all(isinstance(v, str) and SHA_RE.match(v) for v in zadeklarowany.values()):
w.dodaj(BLOKADA, "naglowek", "OD04", "'akta_odcisk' musi byc niepustym obiektem {plik: sha256 (64 znaki hex)}")
return "zly"
zadeklarowany = {_klucz_pliku(k): v for k, v in zadeklarowany.items()}
rozne = 0
for plik, sha in sorted(zadeklarowany.items()):
if plik not in aktualny:
w.dodaj(UWAGI, "naglowek", "OD02", f"plik '{plik}' z odcisku nie istnieje juz w tekscie akt")
rozne += 1
elif aktualny[plik] != sha:
w.dodaj(UWAGI, "naglowek", "OD02", f"tekst pliku '{plik}' zmienil sie od budowy wyniku "
"(np. ponowny OCR) - lokatory sprawdzono na NOWEJ wersji; przejrzyj wpisy z tego pliku")
rozne += 1
for plik in sorted(w.uzyte_pliki - set(zadeklarowany)):
if plik in aktualny:
w.dodaj(UWAGI, "naglowek", "OD03", f"plik '{plik}' jest wskazany w zrodlach, ale nie ma go w odcisku")
rozne += 1
return "zgodny" if not rozne else f"rozny ({rozne})"
# --- eksport CSV ---------------------------------------------------------
def _bezpieczna(v) -> str:
s = "" if v is None else str(v)
return "'" + s if s.startswith(FORMULA_START) else s
def _lokatory(zrodla) -> str:
return "; ".join(f"{_klucz_pliku(z.get('plik', ''))} s. {z.get('strona')}" for z in (zrodla or []) if isinstance(z, dict))
def eksport_csv(rodzaj: str, rekordy: list[dict], w: Wynik, out: Path) -> int:
zneutralizowane = 0
with out.open("w", encoding="utf-8-sig", newline="") as f:
pisz = csv.writer(f, delimiter=";")
if rodzaj == "chronologia":
pisz.writerow(["id", "data", "pewnosc_daty", "rodzaj_daty", "kto", "zdarzenie", "waga",
"status", "tajemnica", "zrodla", "bramka"])
for r in rekordy:
wiersz = [r.get("id"), r.get("data"), r.get("pewnosc_daty"), r.get("rodzaj_daty"),
r.get("kto"), r.get("zdarzenie"), r.get("waga"), r.get("status"),
r.get("tajemnica", ""), _lokatory(r.get("zrodla")),
NAZWA_STANU[w.stan_wpisu(str(r.get("id")))]]
bez = [_bezpieczna(x) for x in wiersz]
zneutralizowane += sum(1 for a, b in zip(wiersz, bez) if str(a or "") != b)
pisz.writerow(bez)
else:
pisz.writerow(["id", "element", "stan", "stanowisko_przeciwnika", "twierdzenia",
"dowody_za", "dowody_przeciw", "bramka"])
for r in rekordy:
wiersz = [r.get("id"), r.get("element"), r.get("stan"), r.get("stanowisko_przeciwnika"),
_lokatory(r.get("twierdzenia")), _lokatory(r.get("dowody_za")),
_lokatory(r.get("dowody_przeciw")), NAZWA_STANU[w.stan_wpisu(str(r.get("id")))]]
bez = [_bezpieczna(x) for x in wiersz]
zneutralizowane += sum(1 for a, b in zip(wiersz, bez) if str(a or "") != b)
pisz.writerow(bez)
return zneutralizowane
# --- main ----------------------------------------------------------------
def main(argv: list[str] | None = None) -> int:
ap = argparse.ArgumentParser(description="Bramka lokatorow chronologii i zestawienia stanowisk")
ap.add_argument("wynik", type=Path, help="plik JSON z chronologia albo zestawieniem")
ap.add_argument("akta", type=Path, help="katalog tekstu akt (wynik akta-przeszukiwalne-pl)")
ap.add_argument("--csv", type=Path, help="eksport do CSV (komorki zneutralizowane przed formulami)")
ap.add_argument("--profil", choices=("robocza", "sad"), default="robocza",
help="robocza (domyslnie): watpliwosci = UWAGI; sad: kody z ZAOSTRZANE_W_SADZIE = BLOKADA")
a = ap.parse_args(argv)
w = Wynik()
try:
dane = json.loads(a.wynik.read_text(encoding="utf-8"))
except (OSError, json.JSONDecodeError) as e:
print(f"BLOKADA: nie da sie wczytac {a.wynik.name}: {type(e).__name__}")
return BLOKADA
akta = wczytaj_akta(a.akta) if a.akta.is_dir() else {}
if not akta:
print(f"BLOKADA: w katalogu akt nie ma plikow .txt z naglowkami stron")
return BLOKADA
rodzaj = dane.get("rodzaj")
_enum(dane, "postawa_tajemnicy", "naglowek", w)
if dane.get("postawa_tajemnicy") == "C":
w.dodaj(BLOKADA, "naglowek", "TJ01", "postawa C - materialy nie przeszly przegladu tajemnicy; nie budujemy")
if rodzaj == "chronologia":
rekordy = sprawdz_chronologie(dane, akta, w)
elif rodzaj == "zestawienie":
rekordy = sprawdz_zestawienie(dane, akta, w)
else:
print(f"BLOKADA: pole 'rodzaj' musi byc 'chronologia' albo 'zestawienie'")
return BLOKADA
if not rekordy:
w.dodaj(BLOKADA, "*", "PU01", "pusta lista wpisow - brak wyniku to nie sukces")
ids = [str(r.get("id") or "?") for r in rekordy]
for d in {x for x in ids if ids.count(x) > 1}:
w.dodaj(BLOKADA, d, "SC04", "zdublowany identyfikator wpisu")
aktualny_odcisk = odcisk_akt(a.akta)
stan_odcisku = sprawdz_odcisk(dane, aktualny_odcisk, w)
zaostrzone = w.zaostrz(ZAOSTRZANE_W_SADZIE) if a.profil == "sad" else 0
stany = [w.stan_wpisu(i) for i in ids]
globalny = max([s for s, *_ in w.znaleziska], default=OK)
raport = a.wynik.with_suffix(".bramka.md")
linie = [f"# Bramka lokatorow v{WERSJA} - {a.wynik.name}", "",
f"Rodzaj: {rodzaj}. Profil: {a.profil}. Akta: {len(akta)} plikow, {sum(len(s) for s in akta.values())} stron.",
f"Mianownik: {len(rekordy)} = {stany.count(OK)} OK + {stany.count(UWAGI)} UWAGI + {stany.count(BLOKADA)} BLOKADA",
f"Odcisk akt: {stan_odcisku}" + (f"; zaostrzone w profilu sad: {zaostrzone}" if a.profil == "sad" else ""),
f"STAN: {NAZWA_STANU[globalny]}", "", "| stan | wpis | kod | opis |", "|---|---|---|---|"]
for s, wid, kod, opis in sorted(w.znaleziska, key=lambda x: (-x[0], x[1])):
linie.append(f"| {NAZWA_STANU[s]} | {wid} | {kod} | {opis.replace('|', '/')} |")
linie += ["", "## Odcisk biezacego tekstu akt", "",
"Wpisz do wyniku jako `akta_odcisk`, gdy budujesz go na tej wersji akt:", "",
"```json", json.dumps({"akta_odcisk": aktualny_odcisk}, ensure_ascii=False, indent=2), "```"]
raport.write_text("\n".join(linie) + "\n", encoding="utf-8")
print(f"bramka lokatorow v{WERSJA}: {rodzaj}, profil {a.profil}, akta {len(akta)} plikow, odcisk {stan_odcisku}")
print(f"Mianownik: {len(rekordy)} = {stany.count(OK)} OK + {stany.count(UWAGI)} UWAGI + {stany.count(BLOKADA)} BLOKADA")
for s in (BLOKADA, UWAGI):
dot = sorted({wid for st, wid, *_ in w.znaleziska if st == s})
if dot:
print(f"{NAZWA_STANU[s]}: {', '.join(dot)}")
if a.csv:
n = eksport_csv(rodzaj, rekordy, w, a.csv)
print(f"CSV: {a.csv.name} (zneutralizowane komorki: {n})")
print(f"Raport: {raport.name}")
print(f"STAN: {NAZWA_STANU[globalny]}")
return globalny
if __name__ == "__main__":
sys.exit(main())
Related skills
| Skill | Stars | Updated | Works with | Status | Install |
|---|---|---|---|---|---|
| slack-gif-creatoranthropics/skillsKnowledge and utilities for creating animated GIFs optimized for Slack. Provides constraints, validation tools, and animation concepts. Use when users request animated GIFs for Slack like "make me a GIF of X doing Y for Slack." | Stars: 198k | Updated | Claude CodeCodex | Verified | Install |
| ponytailDietrichGebert/ponytailLazy senior dev mode for any coding task: the smallest change that fully solves it, and a reply a busy human understands in one read. | Stars: 194k | Updated | Claude CodeCodex | Verified | Install |
| ponytail-debtDietrichGebert/ponytailHarvest every shortcut: comment into one debt ledger, so deferrals get tracked instead of forgotten. One-shot report. | Stars: 194k | Updated | Claude CodeCodex | Verified | Install |
| ponytail-debtDietrichGebert/ponytailList every `shortcut:` comment (and older `ponytail:` ones) as a debt ledger. One-shot report, changes nothing. Use for "ponytail debt", "what did ponytail defer", "list the shortcuts", /ponytail-debt. | Stars: 194k | Updated | Claude CodeCodex | Verified | Install |