ThomasMoreAI/legal-skills-open / br/litigation/skills/juriscan-brunobracaioli
juriscan-brunobracaioli
VerifiedAnálise forense de processos judiciais brasileiros. Extrai, classifica e cruza peças processuais, detecta contradições, calcula prazos CPC e gera relatórios de risco com exportação para Obsidian. Use quando mencionar: processo judicial, petição, sentença, acórdão, contradições, prazos, timeline, análise forense, Obsidian.
scripts/prazo_calculator.py
View on GitHub#!/usr/bin/env python3
"""
prazo_calculator.py — CPC-compliant procedural deadline calculator.
Implements CPC Art. 219-232 rules:
- Business day counting (Art. 219)
- Start/end rules (Art. 224)
- Court holidays (forense) + state holidays
- Recesso forense (Art. 220): Dec 20 - Jan 20
- Suspension ranges
Usage:
python3 prazo_calculator.py --analysis analyzed.json --output prazos.json
python3 prazo_calculator.py --date 2025-03-15 --tipo contestação --state SP
"""
from __future__ import annotations
import argparse
import json
import os
import sys
import unicodedata
from datetime import date, timedelta
from typing import Literal
def _strip_accents(s: str) -> str:
"""Remove diacritics from a string while preserving the base characters."""
return ''.join(
c for c in unicodedata.normalize('NFD', s)
if unicodedata.combining(c) == 0
)
REFERENCES_DIR = os.path.join(os.path.dirname(__file__), '..', 'references')
def _easter(year: int) -> date:
"""Calculate Easter Sunday using Butcher/Meeus algorithm."""
a = year % 19
b = year // 100
c = year % 100
d = b // 4
e = b % 4
f = (b + 8) // 25
g = (b - f + 1) // 3
h = (19 * a + b - d - g + 15) % 30
i = c // 4
k = c % 4
l = (32 + 2 * e + 2 * i - h - k) % 7
m = (a + 11 * h + 22 * l) // 451
month = (h + l - 7 * m + 114) // 31
day = ((h + l - 7 * m + 114) % 31) + 1
return date(year, month, day)
def load_feriados(state: str | None = None, year: int | None = None) -> set[date]:
"""Load court holidays for a given year (defaults to current year).
Includes: national fixed + mobile (Easter-based) + optional state holidays.
"""
if year is None:
year = date.today().year
feriados_path = os.path.join(REFERENCES_DIR, 'feriados_forenses.json')
with open(feriados_path, 'r', encoding='utf-8') as f:
data = json.load(f)
holidays: set[date] = set()
# National fixed holidays
for h in data.get('nacionais_fixos', []):
try:
holidays.add(date(year, h['mes'], h['dia']))
except ValueError:
continue
# Mobile holidays (Easter-based)
easter = _easter(year)
offsets = data.get('moveis', {}).get('offsets_from_easter', {})
for name, offset in offsets.items():
holidays.add(easter + timedelta(days=offset))
# State holidays
if state:
state_holidays = data.get('estaduais', {}).get(state.upper(), [])
for h in state_holidays:
try:
holidays.add(date(year, h['mes'], h['dia']))
except ValueError:
continue
return holidays
def is_recesso(d: date) -> bool:
"""Check if a date falls within the recesso forense (CPC Art. 220).
Recesso: Dec 20 to Jan 20 (inclusive).
"""
if d.month == 12 and d.day >= 20:
return True
if d.month == 1 and d.day <= 20:
return True
return False
def is_business_day(d: date, feriados: set[date]) -> bool:
"""Check if a date is a business day (dia útil forense)."""
if d.weekday() >= 5: # Saturday or Sunday
return False
if d in feriados:
return False
if is_recesso(d):
return False
return True
def next_business_day(d: date, feriados: set[date]) -> date:
"""Find the next business day on or after the given date.
CPC Art. 224 §1: if deadline falls on non-business day, extends to next business day.
"""
while not is_business_day(d, feriados):
d += timedelta(days=1)
return d
def calculate_prazo(
start_date: date,
days: int,
unit: Literal['úteis', 'corridos'] = 'úteis',
feriados: set[date] | None = None,
suspended_ranges: list[tuple[date, date]] | None = None,
) -> date:
"""Calculate procedural deadline per CPC rules.
CPC Art. 224: Exclude start day, include end day.
CPC Art. 219: Count only business days (for 'úteis').
CPC Art. 224 §1: If deadline falls on non-business day, extend to next business day.
Args:
start_date: Date of intimation/publication (dia do começo — excluded).
days: Number of days for the deadline.
unit: 'úteis' (business days) or 'corridos' (calendar days).
feriados: Set of holiday dates.
suspended_ranges: List of (start, end) suspension periods.
"""
if feriados is None:
feriados = set()
def is_suspended(d: date) -> bool:
if suspended_ranges:
return any(start <= d <= end for start, end in suspended_ranges)
return False
current = start_date
counted = 0
if unit == 'úteis':
while counted < days:
current += timedelta(days=1)
if is_suspended(current):
continue
if is_business_day(current, feriados):
counted += 1
else: # corridos
while counted < days:
current += timedelta(days=1)
if is_suspended(current):
continue
counted += 1
# Even for corridos, deadline must end on business day
current = next_business_day(current, feriados)
return current
def get_standard_prazo(tipo: str) -> dict | None:
"""Look up the standard CPC deadline for a procedural act."""
prazos_path = os.path.join(REFERENCES_DIR, 'cpc_prazos.json')
with open(prazos_path, 'r', encoding='utf-8') as f:
data = json.load(f)
tipo_normalized = _strip_accents(tipo.lower().strip().replace(' ', '_'))
for prazo in data.get('prazos_legais', []):
if _strip_accents(prazo['ato']) == tipo_normalized:
return prazo
# Fuzzy match
for prazo in data.get('prazos_legais', []):
ato_normalized = _strip_accents(prazo['ato'])
if tipo_normalized in ato_normalized or ato_normalized in tipo_normalized:
return prazo
return None
VALID_PROCESS_STATES = {
"ativo",
"transito_em_julgado",
"suspenso",
"arquivado",
"desconhecido",
}
# Phase 5 Step 5.2 — state-aware behaviour
# When the process has already transited in rem judicatam, recursal deadlines
# are meaningless; only the voluntary compliance deadline (CPC art. 523) is
# relevant. When the process is suspended, all deadlines are frozen. When it
# is archived, nothing is computed.
_CUMPRIMENTO_VOLUNTARIO = {
"dias": 15,
"unidade": "dias úteis",
"fundamento": "CPC art. 523 — cumprimento voluntário da sentença",
"tipo": "cumprimento voluntário",
}
def check_prazo_status(
intimation_date: date,
prazo_type: str,
current_date: date | None = None,
state: str | None = None,
process_state: str | None = None,
) -> dict | None:
"""Check the status of a procedural deadline.
Returns dict with deadline, days_remaining, and status.
Phase 5 Step 5.2: when ``process_state`` is provided, recursal deadlines
are computed only when the process is 'ativo' or 'desconhecido'. For
'transito_em_julgado', only the voluntary compliance deadline (CPC
art. 523) is computed regardless of ``prazo_type``. For 'suspenso' all
deadlines are marked suspended. For 'arquivado' nothing is returned.
"""
if current_date is None:
current_date = date.today()
# --- Phase 5.2 gate ---
if process_state is not None:
if process_state not in VALID_PROCESS_STATES:
raise ValueError(
f"invalid process_state: {process_state!r} "
f"(expected one of {sorted(VALID_PROCESS_STATES)})"
)
if process_state == "arquivado":
return None
if process_state == "suspenso":
return {
"tipo": prazo_type,
"status": "suspenso",
"data_intimacao": intimation_date.isoformat(),
"fundamento_legal": "processo suspenso — prazos paralisados",
"process_state": process_state,
}
if process_state == "transito_em_julgado":
# Recursal deadlines are no longer valid; switch to CPC 523.
feriados = load_feriados(state, intimation_date.year)
if intimation_date.year != current_date.year:
feriados |= load_feriados(state, current_date.year)
deadline = calculate_prazo(
start_date=intimation_date,
days=_CUMPRIMENTO_VOLUNTARIO["dias"],
unit=_CUMPRIMENTO_VOLUNTARIO["unidade"],
feriados=feriados,
)
if current_date > deadline:
status = "vencido"
elif current_date == deadline:
status = "ultimo_dia"
else:
status = "em_prazo"
return {
"tipo": _CUMPRIMENTO_VOLUNTARIO["tipo"],
"fundamento_legal": _CUMPRIMENTO_VOLUNTARIO["fundamento"],
"data_intimacao": intimation_date.isoformat(),
"data_limite": deadline.isoformat(),
"dias": _CUMPRIMENTO_VOLUNTARIO["dias"],
"unidade": _CUMPRIMENTO_VOLUNTARIO["unidade"],
"status": status,
"process_state": process_state,
"note": (
f"prazo recursal {prazo_type!r} ignorado porque o processo "
f"já transitou em julgado; computado apenas o prazo de "
f"cumprimento voluntário (CPC art. 523)."
),
}
# "ativo" or "desconhecido" -> fall through to normal calculation
prazo_info = get_standard_prazo(prazo_type)
if not prazo_info:
return None
# Load holidays for both the intimation year and deadline year
feriados = load_feriados(state, intimation_date.year)
if intimation_date.year != current_date.year:
feriados |= load_feriados(state, current_date.year)
deadline = calculate_prazo(
start_date=intimation_date,
days=prazo_info['dias'],
unit=prazo_info['unidade'],
feriados=feriados,
)
days_remaining = None
if current_date <= deadline:
# Count business days remaining
d = current_date
count = 0
while d < deadline:
d += timedelta(days=1)
if is_business_day(d, feriados):
count += 1
days_remaining = count
if current_date > deadline:
status = 'vencido'
elif current_date == deadline:
status = 'ultimo_dia'
else:
status = 'em_prazo'
result = {
'tipo': prazo_type,
'fundamento_legal': prazo_info['fundamento'],
'data_intimacao': intimation_date.isoformat(),
'data_limite': deadline.isoformat(),
'dias': prazo_info['dias'],
'unidade': prazo_info['unidade'],
'status': status,
'dias_restantes': days_remaining,
}
if process_state is not None:
result['process_state'] = process_state
return result
def main():
parser = argparse.ArgumentParser(description='CPC Prazo Calculator')
parser.add_argument('--date', '-d', help='Intimation date (YYYY-MM-DD)')
parser.add_argument('--tipo', '-t', help='Prazo type (e.g., contestação, apelação)')
parser.add_argument('--state', '-s', help='State for holidays (e.g., SP, RJ)')
parser.add_argument('--analysis', '-a', help='Path to analyzed.json for batch calculation')
parser.add_argument('--output', '-o', help='Output path for prazos.json')
args = parser.parse_args()
if args.date and args.tipo:
# Single calculation mode
intimation = date.fromisoformat(args.date)
result = check_prazo_status(intimation, args.tipo, state=args.state)
if result:
print(json.dumps(result, ensure_ascii=False, indent=2))
else:
print(f"[ERROR] Unknown prazo type: {args.tipo}", file=sys.stderr)
sys.exit(1)
elif args.analysis:
# Batch mode from analyzed.json
with open(args.analysis, 'r', encoding='utf-8') as f:
analysis = json.load(f)
from utils.dates import parse_brazilian_date
prazos = []
unknown_tipo = 0
unparseable_date = 0
missing_start = 0
seen_any = False
for ci, chunk in enumerate(analysis.get('chunks', [])):
for pj, prazo in enumerate(chunk.get('prazos', [])):
seen_any = True
tipo = prazo.get('tipo', '')
start = prazo.get('data_inicio')
if not start:
missing_start += 1
print(
f"WARN: chunk[{ci}].prazos[{pj}] tipo={tipo!r} sem data_inicio — pulando",
file=sys.stderr,
)
continue
d = parse_brazilian_date(start)
if not d:
unparseable_date += 1
print(
f"WARN: chunk[{ci}].prazos[{pj}] data_inicio={start!r} não parseável — pulando",
file=sys.stderr,
)
continue
result = check_prazo_status(d, tipo, state=args.state)
if result is None:
unknown_tipo += 1
print(
f"WARN: chunk[{ci}].prazos[{pj}] tipo={tipo!r} não reconhecido — pulando",
file=sys.stderr,
)
continue
prazos.append(result)
output_path = args.output or os.path.join(os.path.dirname(args.analysis), 'prazos.json')
with open(output_path, 'w', encoding='utf-8') as f:
json.dump(prazos, f, ensure_ascii=False, indent=2)
dropped = unknown_tipo + unparseable_date + missing_start
if dropped > 0:
print(
f"WARN: {dropped} prazo(s) descartado(s) "
f"(tipo desconhecido: {unknown_tipo}, "
f"data não parseável: {unparseable_date}, "
f"sem data_inicio: {missing_start})",
file=sys.stderr,
)
print(f"Calculated {len(prazos)} deadline(s). Output: {output_path}")
if seen_any and len(prazos) == 0:
# Input had prazos but everything was dropped — likely upstream bug
sys.exit(1)
else:
parser.print_help()
if __name__ == '__main__':
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: 196k | 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: 196k | 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: 196k | Updated | Claude CodeCodex | Verified | Install |