pyoe2-craftpath 0.5.1

A tool for Path of Exile 2 to find the best craftpaths based on the categories: *most likely, most efficient and cheapest*, between a starting item and a target item.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121

use num_format::{Locale, ToFormattedString};

use crate::api::{
    calculator::{DynStatisticAnalyzerCurrencyGroups, GroupRoute, StatisticAnalyzerCurrencyGroups},
    provider::{
        item_info::ItemInfoProvider,
        market_prices::{MarketPriceProvider, PriceInDivines, PriceKind},
    },
};
use std::fmt::Write;

impl GroupRoute {
    pub fn to_pretty_string(
        &self,
        item_provider: &ItemInfoProvider,
        market_provider: &MarketPriceProvider,
        grouped_statistic_analyzer: &dyn StatisticAnalyzerCurrencyGroups,
    ) -> String {
        let mut out = String::new();

        let cost_per_1 = grouped_statistic_analyzer.calculate_cost_per_craft(
            &self.group,
            &item_provider,
            &market_provider,
        );

        let tries_for_60 = ((((1.0_f64 - 0.6_f64).ln()
            / (1.0_f64 - self.chance.get_raw_value()).ln())
        .ceil()) as u64)
            .max(1);

        let cost_per_60 =
            PriceInDivines::new((tries_for_60 as f64) * cost_per_1.get_divine_value());

        writeln!(
            &mut out,
            "Group Chance: {:.5}% | Unique Routes: {} | Tries needed for 60%: {} | Cost per Craft: {} | Cost for 60%: {}{}",
            self.chance.get_raw_value() * 100_f64,
            self.amount_subpaths.get_raw_value().to_formatted_string(&Locale::en),
            tries_for_60.to_formatted_string(&Locale::en),
            format!(
                "{} EX",
                (market_provider
                    .currency_convert(&cost_per_1, &PriceKind::Exalted)
                    .ceil() as u64)
                    .to_formatted_string(&Locale::en)
            ),
            format!(
                "{} EX",
                (market_provider
                    .currency_convert(&cost_per_60, &PriceKind::Exalted)
                    .ceil() as u64)
                    .to_formatted_string(&Locale::en)
            ),
            match grouped_statistic_analyzer.format_display_more_info(
                &self,
                &item_provider,
                &market_provider
            ) {
                Some(e) => e,
                None => "".to_string(),
            }
        )
        .unwrap();

        for (index, currency_list) in self.group.iter().enumerate() {
            let index_weight = grouped_statistic_analyzer.calculate_chance_for_group_step_index(
                &self.unique_route_weights,
                self.amount_subpaths.clone(),
                index,
            );

            writeln!(
                &mut out,
                "{}. {} [ROUGH (!) avg. chance: {:.5}%]",
                index + 1,
                currency_list
                    .list
                    .iter()
                    .map(|e| {
                        let currency_value = market_provider
                            .try_lookup_currency_in_divines_default_if_fail(&e, &item_provider);
                        let currency_value_ex = market_provider
                            .currency_convert(&currency_value, &PriceKind::Exalted)
                            .ceil() as u32;

                        format!(
                            "{} ({} EX)",
                            e.get_item_name(&item_provider),
                            currency_value_ex.to_formatted_string(&Locale::en)
                        )
                    })
                    .collect::<Vec<String>>()
                    .join(" + "),
                index_weight.get_raw_value() * 100_f64
            )
            .unwrap();
        }

        out
    }
}

#[cfg(feature = "python")]
#[cfg_attr(feature = "python", pyo3_stub_gen::derive::gen_stub_pymethods)]
#[cfg_attr(feature = "python", pyo3::prelude::pymethods)]
impl GroupRoute {
    #[pyo3(name = "to_pretty_string")]
    pub fn to_pretty_string_py(
        &self,
        item_provider: &ItemInfoProvider,
        market_provider: &MarketPriceProvider,
        statistic_analyzer: &DynStatisticAnalyzerCurrencyGroups,
    ) -> String {
        self.to_pretty_string(
            item_provider,
            market_provider,
            statistic_analyzer.0.as_ref(),
        )
    }
}