Skip to content
TheChatArchiveThe Chat Archive
gpt-4o-mini-2024-07-18· OpenAIAi2 WildChat-4.8M (AI2)

cosa fa questo codice: from datetime import date, timedelta, datetime from…

  1. User

    cosa fa questo codice:

    from datetime import date, timedelta, datetime from dateutil.relativedelta import relativedelta from decimal import Decimal, ROUND_DOWN, ROUND_HALF_UP from reportlab.lib.pagesizes import letter from reportlab.lib import colors from reportlab.pdfgen import canvas from reportlab.platypus import Table, TableStyle import locale

    Imposta la locale appropriata (ad esempio per l'italiano)

    try: locale.setlocale(locale.LC_ALL, 'it_IT.UTF-8') # Prova questa prima except locale.Error: try: locale.setlocale(locale.LC_ALL, 'Italian_Italy') # Prova questa se fallisce except locale.Error: locale.setlocale(locale.LC_ALL, 'Italian') # Ultima possibilità class InstallmentPlan: HOLIDAYS = [ (1, 1), # Capodanno (1, 6), # Epifania (4, 25), # Festa della Liberazione (5, 1), # Festa del Lavoro (6, 2), # Festa della Repubblica (8, 15), # Ferragosto (11, 1), # Ognissanti (12, 8), # Immacolata Concezione (12, 25), # Natale (12, 26) # Santo Stefano ]

    def __init__(self, total_debt, communication_date, processing_date, is_electronic, num_installments):
        self.total_debt = Decimal(str(total_debt)).quantize(Decimal('0.01'))
        self.communication_date = communication_date
        self.processing_date = processing_date
        self.is_electronic = is_electronic
        self.num_installments = min(num_installments, 20)
        self.installments = []
        self.interest_start_date = self._calculate_interest_start_date()
        self._generate_payment_schedule()
    
    def _is_holiday(self, d):
        return d.weekday() >= 5 or (d.month, d.day) in self.HOLIDAYS or d == self._calculate_easter(d.year)
    
    def _next_working_day(self, d):
        while self._is_holiday(d):
            d += timedelta(days=1)
        return d
    
    def _calculate_easter(self, year):
        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 _calculate_interest_start_date(self):
        start_date = self.processing_date + relativedelta(months=2)
        start_date = start_date.replace(day=1)
        return self._next_working_day(start_date)
    
    def _calculate_first_due_date(self):
        base_days = 30
        suspension_start = date(self.communication_date.year, 8, 1)
        suspension_end = date(self.communication_date.year, 9, 5)
    
        if self.communication_date < suspension_start:
            temp_due_date = self.communication_date + timedelta(days=base_days)
            if temp_due_date < suspension_start:
                raw_due_date = temp_due_date
            else:
                days_before_suspension = (suspension_start - self.communication_date).days
                remaining_days = base_days - days_before_suspension
                raw_due_date = suspension_end + timedelta(days=remaining_days)
        elif self.communication_date < suspension_end:
            raw_due_date = suspension_end + timedelta(days=base_days)
        else:
            raw_due_date = self.communication_date + timedelta(days=base_days)
    
        adjusted_due_date = self._next_working_day(raw_due_date)
        return raw_due_date, adjusted_due_date
    
    def _generate_payment_schedule(self):
        if self.num_installments == 0:
            return
    
        rata_base = (self.total_debt / self.num_installments).quantize(Decimal('0.01'), ROUND_DOWN)
        totale_ripartito = rata_base * self.num_installments
        differenza_totale = self.total_debt - totale_ripartito
    
        raw_first, adjusted_first = self._calculate_first_due_date()
        self.installments.append({
            'raw_due_date': raw_first,
            'due_date': adjusted_first,
            'principal': rata_base + differenza_totale,
            'interest': Decimal('0')
        })
    
        raw_date = raw_first
        for _ in range(self.num_installments - 1):
            raw_date = (raw_date + relativedelta(months=3)).replace(day=1) + relativedelta(months=1) - timedelta(days=1)
            adjusted_date = self._next_working_day(raw_date)
            self.installments.append({
                'raw_due_date': raw_date,
                'due_date': adjusted_date,
                'principal': rata_base,
                'interest': None
            })
    
    def calculate_interest(self, installment_num):
        if installment_num == 0 or installment_num >= len(self.installments):
            return Decimal('0')
    
        rata = self.installments[installment_num]
        capitale = rata['principal']
        interest_start = self.interest_start_date
        due_date = rata['raw_due_date']
        giorni = (due_date - interest_start).days +1
        print(interest_start)
        print(due_date)
        print(capitale)
        print(giorni)
        print((capitale * Decimal('0.035') * Decimal(giorni) / Decimal('365')).quantize(Decimal('0.01'), ROUND_HALF_UP))
        return (capitale * Decimal('0.035') * Decimal(giorni) / Decimal('365')).quantize(Decimal('0.01'), ROUND_HALF_UP)
        
    
    def get_payment_schedule(self):
        schedule = []
        total_days = 0
        total_interest = Decimal('0')
        for i, rata in enumerate(self.installments):
            interest = self.calculate_interest(i) if i > 0 else Decimal('0')
            total_interest += interest
            total_days += (rata['raw_due_date'] - self.interest_start_date).days + 1
            schedule.append({
                'raw_due_date': rata['raw_due_date'],
                'due_date': rata['due_date'],
                'principal': rata['principal'],
                'interest': interest
            })
        daily_interest = total_interest / total_days if total_days > 0 else Decimal('0')
        return schedule, total_days, daily_interest
    
    def get_annual_interest_summary(self):
        summary = {}
        schedule, _, _ = self.get_payment_schedule()
        for rata in schedule:
            year = rata['raw_due_date'].year
            if year not in summary:
                summary[year] = {
                    'interest': Decimal('0'),
                    'start_date': rata['raw_due_date'],
                    'end_date': rata['raw_due_date'],
                    'days_count': 0  # Aggiunta per il conteggio dei giorni
                }
            summary[year]['interest'] += rata['interest']
            summary[year]['end_date'] = rata['raw_due_date']  # Aggiorna sempre la data di fine
    
        return summary
    

    class PDFGenerator: def init(self, filename): self.filename = filename

    def format_number(self, value):
            """Formatta un numero decimale in stringa senza zeri non necessari."""
            # Arrotonda il numero a due cifre decimali per la formattazione
            rounded_value = value.quantize(Decimal('0.01'), rounding=ROUND_HALF_UP)
            
            # Formatta il numero in una stringa
            formatted_value = f"{rounded_value:,.2f}".replace(",", " ").replace(".", ",")  # Sostituisce i punti con virgole
            return formatted_value
        
    
    def arrotonda_personalizzato(self, valore):
        if isinstance(valore, (int, float)):  # Applica l'arrotondamento solo se il valore è numerico
            intero_centi = int(valore * 100)
            successiva = int((valore * 1000) % 10)
    
            if successiva > 5:
                intero_centi += 1
    
            return intero_centi / 100
        return valore
        
    
    def generate_pdf(self, plan):
        c = canvas.Canvas(self.filename, pagesize=letter)
        c.setFont("Helvetica", 10)
    
        # Stampare il codice atto prima della tabella
        
        c.drawString(50, 750, f"Codice atto: {codice_atto} "+ f" Debito: {total_debt_input} " + f" Data notifica: {communication_date_input} " + f" Data elabotazione comunicazione: {processing_date_input} ")  # Imposta la posizione per il codice atto
        
        
        schedule, total_days, daily_interest = plan.get_payment_schedule()
        annual_summary = plan.get_annual_interest_summary()
    
        # Imposta i margini
        left_margin = 50
        y_position_start_table = 90
        
        data = [['Rata', 'Scadenza', 'Scadenza feriale', 'Capitale', 'Interessi', 'Totale']]
        total_interest = Decimal('0')
    
        for i, rata in enumerate(schedule):
            totale = rata['principal'] + (rata['interest'] if rata['interest'] is not None else 0)
            total_interest += rata['interest']
            data.append([
                i + 1,
                rata['raw_due_date'].strftime('%d/%m/%Y'),
                rata['due_date'].strftime('%d/%m/%Y'), 
                f"€{self.format_number(rata['principal'])}",
                f"€{self.arrotonda_personalizzato(rata['interest'] if rata['interest'] is not None else 0)}", 
                f"€{self.arrotonda_personalizzato(totale)}"
            ])
    
        # Creare la tabella delle rate
        table = Table(data, colWidths=[50, 90, 100, 80, 80, 80])
        table.setStyle(TableStyle([ 
            ('TEXTCOLOR', (0, 0), (-1, 0), colors.white),
            ('BACKGROUND', (0, 0), (-1, 0), colors.black),
            ('ALIGN', (0, 0), (-1, -1), 'CENTER'),
            ('GRID', (0, 0), (-1, -1), 0.5, colors.black),
            ('FONTNAME', (0, 0), (-1, 0), 'Helvetica-Bold'),
            ('FONTNAME', (0, 1), (-1, -1), 'Helvetica'),
        ]))
    
        # Controllo dell'altezza della tabella
        table_height = table.wrap(0, 0)[1]  # Ottieni l'altezza della tabella
        
        # Disegnare la tabella delle rate
        y_position = y_position_start_table
        if y_position - table_height < 50:  # Se non c'è spazio
            #c.showPage()  # Aggiungi una nuova pagina se necessario
            y_position = 730  # Ripristina la posizione in alto
    
        table.drawOn(c, left_margin, y_position - table_height)
        
        # Differenza tra la prima e l'ultima scadenza
        first_due_date = schedule[0]['raw_due_date']
        last_due_date = schedule[-1]['raw_due_date']
    
        # Calcolare il numero totale di giorni tra la prima e l'ultima scadenza
        total_days = (last_due_date - first_due_date).days + 1
        daily_interest = Decimal(total_interest / total_days).quantize(Decimal('0.00000000'))
    
        # Stampa informazioni aggiuntive sotto la tabella delle rate
        y_position -= table_height + 20  # Sposta indietro il cursore
        c.drawString(left_margin, y_position, f"Giorni totali: {total_days}")
        y_position -= 20
        c.drawString(left_margin, y_position, f"Interessi totali: €{self.format_number(total_interest)}")
        y_position -= 20
        c.drawString(left_margin, y_position, f"Quota giornaliera di interessi: {daily_interest}")
    
        c.drawString(left_margin, y_position - 20, "Riepilogo annuale degli interessi:")
        y_position -= 30  # Spazio extra per il riepilogo annuale
    
        # Creazione della sintassi per la tabella del riepilogo annuale
        annual_data = [['Anno', 'Int. da piano', 'Data inizio', 'Data fine', 'Giorni', 'Quota int. annuale', 'Rateo/Risconto']]
        
        previous_rateo_riscatto = Decimal('0')  # Inizializzazione del rateo/riscatto
    
        for index, year in enumerate(sorted(annual_summary.keys())):
            if index == 0:  # Primo anno
                start_date = annual_summary[year]['start_date']
                end_date = date(year, 12, 31)  # Termina al 31/12 dell'anno
            elif year == max(annual_summary.keys()):  # Ultimo anno
                start_date = date(year, 1, 1)  # Inizio al 01/01
                end_date = schedule[-1]['raw_due_date']  # Ultima scadenza
            else:  # Anni intermedi
                start_date = date(year, 1, 1)  # Inizio al 01/01
                end_date = date(year, 12, 31)  # Termina al 31/12
    
            # Calcola il numero di giorni tra le due date
            days_count = (end_date - start_date).days + 1
    
            # Calcola gli interessi di competenza
            interest_for_period = self.arrotonda_personalizzato((days_count * daily_interest))
    
            # Calcolo del Rateo/Risconto
            current_interest = self.arrotonda_personalizzato(annual_summary[year]['interest'])
    
            if index == 0:  # Primo anno
                # Calcola rateo o risconto
                rateo_risconto =  self.arrotonda_personalizzato((interest_for_period - current_interest))  # Risconto
                print("primo " + str(rateo_risconto))
            else:  # Anni successivi
                # Calcolo del rateo/riscatto per gli anni successivi
                rateo_risconto = self.arrotonda_personalizzato((interest_for_period - (current_interest - previous_rateo_risconto)))
                print("rateo " + str(index )+" " + str( rateo_risconto))
    
            # Aggiornamento della variabile previous_rateo_riscatto senza modifiche aggiuntive
            previous_rateo_risconto = rateo_risconto
            print ("rateo perido precedente " + str( previous_rateo_risconto))
    
            # Aggiunta dei dati annuali
            annual_data.append([
            year,
            self.format_number(current_interest),       # Formattazione per gli interessi annuali
            start_date.strftime('%d/%m/%Y'),           # Data di inizio
            end_date.strftime('%d/%m/%Y'),             # Data di fine
            days_count,                                 # Numero di giorni
            self.format_number(interest_for_period),     # Quota interessi di competenza
            self.format_number(rateo_risconto)           # Rateo/Risconto
        ])
        # Creare la tabella del riepilogo annuale
        annual_table = Table(annual_data, colWidths=[50, 80, 90, 90, 50, 80, 80])
        annual_table.setStyle(TableStyle([ 
            ('TEXTCOLOR', (0, 0), (-1, 0), colors.white),
            ('BACKGROUND', (0, 0), (-1, 0), colors.black),
            ('ALIGN', (0, 0), (-1, -1), 'CENTER'),
            ('GRID', (0, 0), (-1, -1), 0.5, colors.black),
            ('FONTNAME', (0, 0), (-1, 0), 'Helvetica-Bold'),
            ('FONTNAME', (0, 1), (-1, -1), 'Helvetica'),
        ]))
    
        # Controllo dell'altezza della tabella del riepilogo annuale
        annual_table_height = annual_table.wrap(0, 0)[1]  # Ottieni l'altezza della tabella
    
        # Disegnare la tabella del riepilogo annuale
        if y_position - annual_table_height < 50:  # Se non c'è spazio
            c.showPage()  # Aggiungi una nuova pagina
            y_position = 750  # Ripristina la posizione in alto
    
        annual_table.drawOn(c, left_margin, y_position - annual_table_height)
    
        c.save()
    

    Codice di esempio per eseguire la generazione del PDF

    if name == "main": total_debt_input = input("Inserisci il debito totale (es. 123,45): ") total_debt = Decimal(total_debt_input.replace(',', '.'))

    communication_date_input = input("Inserisci la data di ricezione della comunicazione (gg/mm/aaaa): ")
    communication_date = datetime.strptime(communication_date_input, "%d/%m/%Y").date()
    
    processing_date_input = input("Inserisci la data di elaborazione della comunicazione (gg/mm/aaaa): ")
    processing_date = datetime.strptime(processing_date_input, "%d/%m/%Y").date()
    
    num_installments = int(input("Inserisci il numero di rate (max 20): "))
    
    is_electronic_input = input("Il pagamento è elettronico? (S/N): ")
    is_electronic = True if is_electronic_input.strip().upper() == "S" else False
    
    codice_atto = input("Inserisci il codice atto: ")
    
    piano = InstallmentPlan(
        total_debt=total_debt,
        communication_date=communication_date,
        processing_date=processing_date,
        is_electronic=is_electronic,
        num_installments=num_installments
    )
    
    pdf_generator = PDFGenerator("codice_atto-"+codice_atto +".pdf")
    pdf_generator.generate_pdf(piano)
    
    print("PDF generato e salvato come " +"codice_atto-"+codice_atto +".pdf")
    
  2. Assistant

    Il codice fornito è un programma Python che genera un piano di rateizzazione e produce un documento PDF contenente informazioni dettagliate su questo piano. Di seguito vengono descritti i principali passaggi e funzionalità del codice:

    Struttura del Codice:

    1. Importazione delle Librerie:

      • Importa diverse librerie per gestire date, decimali e per la generazione di PDF.
    2. Impostazione della Locale:

      • Configura la locale per l'italiano per garantire che il programma gestisca correttamente la formattazione dei numeri e delle date.
    3. Classe InstallmentPlan:

      • Questa classe gestisce un piano di rateizzazione.
      • Variabili di Classe: Contiene le festività italiane per escludere giorni non lavorativi nel calcolo delle scadenze.
      • Costruttore (__init__): Inizializza variabili come debito totale, date di comunicazione e elaborazione, e il numero massimo di rate (fino a 20). Calcola anche la data di inizio degli interessi e il programma di pagamento.
      • Metodi Privati:
        • Verifica se una data è festiva.
        • Calcola la prossima giornata lavorativa.
        • Calcola la data della Pasqua per gestire i giorni festivi mobili.
        • Genera un programma di pagamento basato sulla comunicazione ricevuta.
      • Calcolo degli Interessi: Calcola gli interessi sulle rate e restituisce il piano di pagamento.
      • Riepilogo degli Interessi Annuali: Fornisce un riepilogo annuale degli interessi.
    4. Classe PDFGenerator:

      • Gestisce la creazione del PDF.
      • Include metodi per formattare i numeri e generare il PDF con le informazioni del piano di rateizzazione.
      • Crea una tabella contenente le rate, le date di scadenza, il capitale, gli interessi e il totale per ciascuna rata.
      • Stampa un riepilogo annuale degli interessi nel PDF.
    5. Esecuzione del Programma (__main__):

      • Raccoglie input dall'utente per i parametri di debito, date e numero di rate.
      • Crea un'istanza del piano di rateizzazione e un generatore PDF, poi genera e salva il PDF.

    Funzionalità Principali:

    • Calcolo del Piano di Rateizzazione: Suddivide il debito totale in rate, calcola le scadenze tenendo conto degli orari lavorativi e delle festività, e determina gli interessi su ciascuna rata.

    • Generazione di PDF: Crea un documento PDF con informazioni chiare e formattate su ciascuna rata e un riepilogo degli interessi annuali.

    • Gestione delle Festività e dei Giorni Lavorativi: Garantisce che le scadenze non cadano in giorni festivi o nel fine settimana.

    Utilizzo:

    L'utente deve eseguire il programma, quindi verrà guidato a inserire le informazioni necessarie per generare il piano di rateizzazione. Alla fine, verrà generato un file PDF contenente dettagli sul piano di pagamento e sugli interessi.

    Considerazioni:

    Si tratta di un'applicazione utile per la pianificazione e la gestione dei pagamenti di debito, che potrebbe essere utilizzata in contesti finanziari, legali o di consulenza.

  3. User

    da quando vengono calcolati gli interessi?

  4. Assistant

    Nel codice fornito, gli interessi attuali vengono calcolati a partire dalla data di inizio degli interessi (che è calcolata nella funzione _calculate_interest_start_date) e cominciano a decorrere:

    1. Data di Elaborazione: Gli interessi iniziano a essere calcolati due mesi dopo la data di elaborazione della comunicazione (processing_date).

    2. Arrotondamento alla Prima Data del Mese: La data di inizio degli interessi viene impostata come il primo giorno del mese successivo alla data di elaborazione, e se quella data è una festività o un giorno non lavorativo, viene spostata al giorno lavorativo successivo.

    Quindi, per riassumere:

    • Gli interessi vengono calcolati a partire dalla data che segue la data di elaborazione della comunicazione, dopo un periodo di sospensione di due mesi, e il calcolo inizia dal primo giorno del mese successivo alla scadenza impostata.

    Questo significa che, se ad esempio la data di elaborazione è il 15 gennaio, gli interessi inizieranno a essere calcolati a partire dal primo giorno di marzo (se la data di inizio coincide con un giorno lavorativo), tenendo conto della logica delle festività e giorni lavorativi.

  5. User

    La data di inizio degli interessi viene impostata come il primo giorno del mese successivo alla data di elaborazione, e se quella data è una festività o un giorno non lavorativo, viene spostata al giorno lavorativo successivo. Il principio che viene sposta se è festivo o un giorno non lavorativo, non vale per la data di inizio del conteggio degli interessi.

  6. Assistant

    Hai ragione, mi scuso per la confusione. Diamo un'occhiata più attenta a come sono gestiti i calcoli della data di inizio degli interessi nel codice.

    Nel codice, la data di inizio degli interessi è calcolata come segue:

    1. Calcolo della Data di Inizio: Nella funzione _calculate_interest_start_date, viene prima aggiunto un periodo di due mesi alla data di elaborazione. Viene quindi impostata al primo giorno di quel mese.

    2. Prossimo Giorno Lavorativo: Questa data viene poi passata alla funzione _next_working_day, che controlla se cade in un giorno festivo o durante il weekend. Se è così, la data viene incrementata fino a trovare il primo giorno lavorativo successivo.

    Quindi, il processo si può riassumere nei seguenti passaggi chiave:

    • Aggiunta di Due Mesi alla Data di Elaborazione: La data di inizio degli interessi è effettivamente calcolata come il primo giorno del mese successivo che segue la data di elaborazione, ma non viene spostata se questa data è un giorno festivo. Se il primo giorno del mese successivo è un giorno festivo o weekend, solo in quel caso viene spostata al giorno lavorativo successivo.

    Da questo punto di vista, la regola che hai menzionato (ovvero che la data di inizio del conteggio degli interessi non viene spostata automaticamente per festivi o weekend, ma solo se inizia effettivamente nella data di inizio calcolata) è corretta.

    Quindi, per chiarire:

    • La data di inizio del conteggio degli interessi è il primo giorno lavorativo dopo due mesi dalla data di elaborazione e sarà modificata solo se il primo giorno del mese risultante è un giorno festivo o un weekend.

    Grazie per la tua osservazione e mi scuso per l'errore nella mia spiegazione precedente.

  7. User

    correggiamo il codice solo per la data di decorrenza degli interessi togliendo la questionde dei giorni festivi o non lavorativi

  8. Assistant

    Certo! Se desideri rimuovere la gestione dei giorni festivi o non lavorativi riguardo alla decorrenza degli interessi, dovrai modificare il metodo _calculate_interest_start_date della classe InstallmentPlan. In questo modo, la data di inizio degli interessi sarà sempre il primo giorno del mese che segue la data di elaborazione, senza considerare se è un giorno festivo o non lavorativo.

    Ecco come apparirebbe il codice modificato per il metodo _calculate_interest_start_date:

    Codice Modificato:

    def _calculate_interest_start_date(self):
        # Calcola la data di inizio aggiungendo 2 mesi alla data di elaborazione e impostando il giorno al primo
        start_date = self.processing_date + relativedelta(months=2)
        start_date = start_date.replace(day=1)  # Imposta il giorno al primo del mese
        return start_date  # Restituisce la data senza controllo per giorni festivi
    

    Rimozione della Chiamata alla Funzione _next_working_day:

    Con questa modifica, non è più necessario passare la data a _next_working_day, quindi puoi restituire direttamente start_date.

    Aggiornamento Completo:

    Ecco l'intero metodo _calculate_interest_start_date aggiornato per chiarezza:

    def _calculate_interest_start_date(self):
        # Calcola la data di inizio aggiungendo 2 mesi alla data di elaborazione e impostando il giorno al primo
        start_date = self.processing_date + relativedelta(months=2)
        start_date = start_date.replace(day=1)  # Imposta il giorno al primo del mese
        return start_date  # Restituisce la data direttamente
    

    Conclusione

    Questa modifica ora farà in modo che la data di inizio degli interessi sia sempre il primo giorno del mese successivo alla data di elaborazione, senza alcuna considerazione per festività o giorni non lavorativi. Tutte le altre funzionalità del codice rimarranno inalterate. Se hai bisogno di ulteriori modifiche o chiarimenti, fammelo sapere!