Add opt-in per-transaction rounding (default off per Art. 63 OP)

Per tax advisor consultation with Naczelna Izba Skarbowa and Art. 63
Ordynacja Podatkowa, rounding should only be applied to final tax base
and tax amount sums, not to individual transactions.

Change default behavior to carry full f32 precision through per-transaction
FX conversions. The previous per-transaction rounding to grosz is preserved
as an opt-in flag:
  - CLI: --round-per-transaction
  - GUI: Options menu toggle (MenuBar)

Also add default-run to Cargo.toml to resolve binary ambiguity.

Author: mbronk

Cargo.toml

@@ -11,6 +11,7 @@ readme = "README.md"
 keywords = ["etrade", "revolut"]
 repository = "https://github.com/jczaja/e-trade-tax-return-pl-helper"
 homepage = "https://github.com/jczaja/e-trade-tax-return-pl-helper"
+default-run = "etradeTaxReturnHelper"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 exclude = [

src/gui.rs

@@ -9,9 +9,10 @@ use fltk::{
     browser::MultiBrowser,
     button::Button,
     dialog,
-    enums::{Event, Font, FrameType, Key},
+    enums::{Event, Font, FrameType, Key, Shortcut},
     frame::Frame,
     group::Pack,
+    menu::{MenuBar, MenuFlag},
     prelude::*,
     text::{TextBuffer, TextDisplay},
     window,
@@ -77,6 +78,7 @@ fn create_clear_documents(
 
 fn create_execute_documents(
     browser: Rc<RefCell<MultiBrowser>>,
+    menubar: Rc<RefCell<MenuBar>>,
     tdisplay: Rc<RefCell<TextDisplay>>,
     sdisplay: Rc<RefCell<TextDisplay>>,
     ndisplay: Rc<RefCell<TextDisplay>>,
@@ -118,6 +120,12 @@ fn create_execute_documents(
         buffer.set_text("");
         tbuffer.set_text("");
         nbuffer.set_text("Running...");
+        let round_per_transaction = {
+            let mb = menubar.borrow();
+            mb.find_item("Options/Round per transaction")
+                .map(|item| item.value())
+                .unwrap_or(false)
+        };
         let rd: Box<dyn etradeTaxReturnHelper::Residency> = Box::new(PL {});
         let etradeTaxReturnHelper::TaxCalculationResult {
             gross_interests,
@@ -130,7 +138,7 @@ fn create_execute_documents(
             revolut_dividends_transactions: revolut_transactions,
             sold_transactions,
             revolut_sold_transactions,
-        } = match run_taxation(&rd, file_names,false, false) {
+        } = match run_taxation(&rd, file_names, false, false, round_per_transaction) {
             Ok(res) => {
                 nbuffer.set_text("Finished.\n\n (Double check if generated tax data (Summary) makes sense and then copy it to your tax form)");
                 res
@@ -229,7 +237,16 @@ pub fn run_gui() {
 
     wind.make_resizable(true);
 
-    let mut uberpack = Pack::new(0, 0, WIND_SIZE_X as i32, WIND_SIZE_Y as i32, "");
+    let mut menubar = MenuBar::new(0, 0, WIND_SIZE_X, 25, "");
+    menubar.add(
+        "Options/Round per transaction",
+        Shortcut::None,
+        MenuFlag::Toggle,
+        |_| {},
+    );
+    let menubar = Rc::new(RefCell::new(menubar));
+
+    let mut uberpack = Pack::new(0, 25, WIND_SIZE_X as i32, WIND_SIZE_Y as i32 - 25, "");
 
     let mut pack = Pack::new(0, 0, WIND_SIZE_X as i32, WIND_SIZE_Y / 2 as i32, "");
     pack.set_type(fltk::group::PackType::Horizontal);
@@ -328,6 +345,7 @@ pub fn run_gui() {
     );
     create_execute_documents(
         browser.clone(),
+        menubar.clone(),
         tdisplay.clone(),
         sdisplay.clone(),
         ndisplay.clone(),

src/lib.rs

@@ -298,32 +298,64 @@ fn round_to_grosz(val: f32) -> f32 {
     (val * 100.0).round() / 100.0
 }
 
-fn compute_div_taxation(transactions: &Vec<Transaction>) -> (f32, f32) {
+fn compute_div_taxation(
+    transactions: &Vec<Transaction>,
+    round_per_transaction: bool,
+) -> (f32, f32) {
     // Gross income from dividends in target currency (PLN, EUR etc.)
-    // Each transaction's FX-converted amount is rounded to 0.01 before summing.
     let gross_us_pl: f32 = transactions
         .iter()
-        .map(|x| round_to_grosz(x.exchange_rate * x.gross.value() as f32))
+        .map(|x| {
+            let v = x.exchange_rate * x.gross.value() as f32;
+            if round_per_transaction {
+                round_to_grosz(v)
+            } else {
+                v
+            }
+        })
         .sum();
     // Tax paid in US in PLN
     let tax_us_pl: f32 = transactions
         .iter()
-        .map(|x| round_to_grosz(x.exchange_rate * x.tax_paid.value() as f32))
+        .map(|x| {
+            let v = x.exchange_rate * x.tax_paid.value() as f32;
+            if round_per_transaction {
+                round_to_grosz(v)
+            } else {
+                v
+            }
+        })
         .sum();
     (gross_us_pl, tax_us_pl)
 }
 
-fn compute_sold_taxation(transactions: &Vec<SoldTransaction>) -> (f32, f32) {
+fn compute_sold_taxation(
+    transactions: &Vec<SoldTransaction>,
+    round_per_transaction: bool,
+) -> (f32, f32) {
     // Net income from sold stock in target currency (PLN, EUR etc.)
-    // Each transaction's FX-converted amount is rounded to 0.01 before summing.
     let gross_us_pl: f32 = transactions
         .iter()
-        .map(|x| round_to_grosz(x.exchange_rate_settlement * x.income_us))
+        .map(|x| {
+            let v = x.exchange_rate_settlement * x.income_us;
+            if round_per_transaction {
+                round_to_grosz(v)
+            } else {
+                v
+            }
+        })
         .sum();
     // Cost of income e.g. cost_basis[target currency]
     let cost_us_pl: f32 = transactions
         .iter()
-        .map(|x| round_to_grosz(x.exchange_rate_acquisition * x.cost_basis))
+        .map(|x| {
+            let v = x.exchange_rate_acquisition * x.cost_basis;
+            if round_per_transaction {
+                round_to_grosz(v)
+            } else {
+                v
+            }
+        })
         .sum();
     (gross_us_pl, cost_us_pl)
 }
@@ -387,6 +419,7 @@ pub fn run_taxation(
     names: Vec<String>,
     per_company: bool,
     multiyear: bool,
+    round_per_transaction: bool,
 ) -> Result<TaxCalculationResult, String> {
     validate_file_names(&names)?;
 
@@ -532,9 +565,10 @@ pub fn run_taxation(
         println!("{}", per_company_report);
     }
 
-    let (gross_etrade_interests, _) = compute_div_taxation(&interests);
-    let (gross_etrade_div, tax_etrade_div) = compute_div_taxation(&transactions);
-    let (gross_sold, cost_sold) = compute_sold_taxation(&sold_transactions);
+    let (gross_etrade_interests, _) = compute_div_taxation(&interests, round_per_transaction);
+    let (gross_etrade_div, tax_etrade_div) =
+        compute_div_taxation(&transactions, round_per_transaction);
+    let (gross_sold, cost_sold) = compute_sold_taxation(&sold_transactions, round_per_transaction);
 
     // Split Revolut transactions: savings interests (company=None, art. 30a pkt 1-3)
     // vs stock dividends (company=Some, art. 30a pkt 4).
@@ -548,9 +582,12 @@ pub fn run_taxation(
         .filter(|x| x.company.is_some())
         .cloned()
         .collect();
-    let (gross_revolut_interests, _) = compute_div_taxation(&revolut_interests_txns);
-    let (gross_revolut_div, tax_revolut) = compute_div_taxation(&revolut_div_txns);
-    let (gross_revolut_sold, cost_revolut_sold) = compute_sold_taxation(&revolut_sold_transactions);
+    let (gross_revolut_interests, _) =
+        compute_div_taxation(&revolut_interests_txns, round_per_transaction);
+    let (gross_revolut_div, tax_revolut) =
+        compute_div_taxation(&revolut_div_txns, round_per_transaction);
+    let (gross_revolut_sold, cost_revolut_sold) =
+        compute_sold_taxation(&revolut_sold_transactions, round_per_transaction);
     Ok(TaxCalculationResult {
         gross_interests: gross_etrade_interests + gross_revolut_interests,
         gross_div: gross_etrade_div + gross_revolut_div,
@@ -603,7 +640,7 @@ mod tests {
                 company: None,
             },
         ];
-        let (gross, _) = compute_div_taxation(&transactions);
+        let (gross, _) = compute_div_taxation(&transactions, true);
         // Per-transaction: round(1.005) + round(1.005) = 1.01 + 1.01 = 2.02
         assert_eq!(gross, 2.02);
         // Sanity check: rounding the raw sum would give a different answer
@@ -642,7 +679,7 @@ mod tests {
                 company: Some("TFC".to_owned()),
             },
         ];
-        let (gross, cost) = compute_sold_taxation(&transactions);
+        let (gross, cost) = compute_sold_taxation(&transactions, true);
         // Per-transaction: round(1.005) + round(1.005) = 1.01 + 1.01 = 2.02
         assert_eq!(gross, 2.02);
         assert_eq!(cost, 2.02);
@@ -722,7 +759,7 @@ mod tests {
             exchange_rate: 4.0,
             company: Some("INTEL CORP".to_owned()),
         }];
-        assert_eq!(compute_div_taxation(&transactions), (400.0, 100.0));
+        assert_eq!(compute_div_taxation(&transactions, false), (400.0, 100.0));
         Ok(())
     }
 
@@ -748,7 +785,7 @@ mod tests {
             },
         ];
         assert_eq!(
-            compute_div_taxation(&transactions),
+            compute_div_taxation(&transactions, false),
             (400.0 + 126.0 * 3.5, 100.0 + 10.0 * 3.5)
         );
         Ok(())
@@ -774,7 +811,7 @@ mod tests {
             },
         ];
         assert_eq!(
-            compute_div_taxation(&transactions),
+            compute_div_taxation(&transactions, false),
             (0.44 * 1.0 + 0.45 * 1.0, 0.0)
         );
         Ok(())
@@ -801,7 +838,7 @@ mod tests {
             },
         ];
         assert_eq!(
-            compute_div_taxation(&transactions),
+            compute_div_taxation(&transactions, false),
             (0.44 * 2.0 + 0.45 * 3.0, 0.0)
         );
         Ok(())
@@ -823,7 +860,7 @@ mod tests {
             company: Some("TFC".to_owned()),
         }];
         assert_eq!(
-            compute_sold_taxation(&transactions),
+            compute_sold_taxation(&transactions, false),
             (100.0 * 5.0, 70.0 * 6.0)
         );
         Ok(())
@@ -859,7 +896,7 @@ mod tests {
             },
         ];
         assert_eq!(
-            compute_sold_taxation(&transactions),
+            compute_sold_taxation(&transactions, false),
             (100.0 * 5.0 + 10.0 * 2.0, 70.0 * 6.0 + 4.0 * 3.0)
         );
         Ok(())

src/main.rs

@@ -58,6 +58,12 @@ fn create_cmd_line_pattern(myapp: Command) -> Command {
                 .help("Allow processing documents across more than year")
                 .action(clap::ArgAction::SetTrue)
         )
+        .arg(
+            Arg::new("round-per-transaction")
+                .long("round-per-transaction")
+                .help("Round each FX-converted amount to grosz before summing (off by default)")
+                .action(clap::ArgAction::SetTrue)
+        )
 }
 
 fn configure_dataframes_format() {
@@ -119,6 +125,7 @@ fn main() {
         pdfnames,
         matches.get_flag("per-company"),
         matches.get_flag("multiyear"),
+        matches.get_flag("round-per-transaction"),
     ) {
         Ok(res) => res,
         Err(msg) => panic!("\nError: Unable to compute taxes. \n\nDetails: {msg}"),
@@ -376,7 +383,7 @@ mod tests {
             .expect_and_log("error getting financial documents names");
         let pdfnames: Vec<String> = pdfnames.map(|x| x.to_string()).collect();
 
-        match etradeTaxReturnHelper::run_taxation(&rd, pdfnames, false, false) {
+        match etradeTaxReturnHelper::run_taxation(&rd, pdfnames, false, false, false) {
             Ok(_) => panic!("Expected an error from run_taxation, but got Ok"),
             Err(_) => Ok(()), // Expected error, test passes
         }
@@ -397,7 +404,7 @@ mod tests {
             .expect_and_log("error getting brokarage statements pdfs names");
         let pdfnames: Vec<String> = pdfnames.map(|x| x.to_string()).collect();
 
-        match etradeTaxReturnHelper::run_taxation(&rd, pdfnames, false, false) {
+        match etradeTaxReturnHelper::run_taxation(&rd, pdfnames, false, false, false) {
             Ok(TaxCalculationResult {
                 gross_interests,
                 gross_div,
@@ -431,7 +438,40 @@ mod tests {
             .expect_and_log("error getting brokarage statements pdfs names");
         let pdfnames: Vec<String> = pdfnames.map(|x| x.to_string()).collect();
 
-        match etradeTaxReturnHelper::run_taxation(&rd, pdfnames, false, false) {
+        match etradeTaxReturnHelper::run_taxation(&rd, pdfnames, false, false, false) {
+            Ok(TaxCalculationResult {
+                gross_interests,
+                gross_div,
+                tax: tax_div,
+                gross_sold,
+                cost_sold,
+                ..
+            }) => {
+                assert_eq!(
+                    (gross_interests, gross_div, tax_div, gross_sold, cost_sold),
+                    (0.0, 9142.319, 1207.08, 22988.617, 20163.5),
+                );
+                Ok(())
+            }
+            Err(x) => panic!("Error in taxation process: {x}"),
+        }
+    }
+
+    #[test]
+    fn test_revolut_sold_and_dividends_round_per_transaction() -> Result<(), clap::Error> {
+        let myapp = Command::new("etradeTaxHelper").arg_required_else_help(true);
+        let rd: Box<dyn etradeTaxReturnHelper::Residency> = Box::new(pl::PL {});
+
+        let matches = create_cmd_line_pattern(myapp).get_matches_from(vec![
+            "mytest",
+            "revolut_data/trading-pnl-statement_2022-11-01_2024-09-01_pl-pl_e989f4.csv",
+        ]);
+        let pdfnames = matches
+            .get_many::<String>("financial documents")
+            .expect_and_log("error getting brokarage statements pdfs names");
+        let pdfnames: Vec<String> = pdfnames.map(|x| x.to_string()).collect();
+
+        match etradeTaxReturnHelper::run_taxation(&rd, pdfnames, false, false, true) {
             Ok(TaxCalculationResult {
                 gross_interests,
                 gross_div,
@@ -465,7 +505,7 @@ mod tests {
             .expect_and_log("error getting brokarage statements pdfs names");
         let pdfnames: Vec<String> = pdfnames.map(|x| x.to_string()).collect();
 
-        match etradeTaxReturnHelper::run_taxation(&rd, pdfnames, false, false) {
+        match etradeTaxReturnHelper::run_taxation(&rd, pdfnames, false, false, false) {
             Ok(TaxCalculationResult {
                 gross_interests,
                 gross_div,
@@ -500,7 +540,7 @@ mod tests {
             .expect_and_log("error getting brokarage statements pdfs names");
         let pdfnames: Vec<String> = pdfnames.map(|x| x.to_string()).collect();
 
-        match etradeTaxReturnHelper::run_taxation(&rd, pdfnames, false, false) {
+        match etradeTaxReturnHelper::run_taxation(&rd, pdfnames, false, false, false) {
             Ok(TaxCalculationResult {
                 gross_interests,
                 gross_div,
@@ -532,7 +572,7 @@ mod tests {
             .expect_and_log("error getting brokarage statements pdfs names");
         let pdfnames: Vec<String> = pdfnames.map(|x| x.to_string()).collect();
 
-        match etradeTaxReturnHelper::run_taxation(&rd, pdfnames, false, false) {
+        match etradeTaxReturnHelper::run_taxation(&rd, pdfnames, false, false, false) {
             Ok(TaxCalculationResult {
                 gross_interests,
                 gross_div,