rephorm 1.0.1__py3-none-any.whl

rephorm/object_mappers/_utilities/chart_mapper_utility.py

@@ -0,0 +1,34 @@
+import numpy as np
+
+def process_bar_data(neg_data, pos_data, flattened):
+    """
+    Processes a flattened array by slicing it into chunks if its length differs
+    from the target data arrays, then applies np.where per chunk and accumulates
+    the negative or positive values into the corresponding data arrays.
+
+    Args:
+        neg_data (np.ndarray): negative data array.
+        pos_data (np.ndarray): positive data array.
+        flattened (np.ndarray): Flattened input array. (The actual series data)
+
+    Returns:
+        Tuple[np.ndarray, np.ndarray]: Updated negative and positive data arrays.
+    """
+    target_length = neg_data.shape[0]
+    total_length = flattened.shape[0]
+
+    # If equal, direct add
+    if total_length == target_length:
+        neg_data += np.where(flattened < 0, flattened, 0)
+        pos_data += np.where(flattened > 0, flattened, 0)
+
+    # If longer, break into chunks
+    else:
+        num_full_chunks = total_length // target_length
+
+        for i in range(num_full_chunks):
+            chunk = flattened[i * target_length : (i + 1) * target_length]
+            neg_data += np.where(chunk < 0, chunk, 0)
+            pos_data += np.where(chunk > 0, chunk, 0)
+
+    return neg_data, pos_data

rephorm/object_mappers/_utilities/grid_mapper_utility.py

@@ -0,0 +1,11 @@
+def compute_grid_layout(nrow = 1, ncol = 1):
+    """
+    Computes the layout of a grid based on the number of rows and columns.
+    """
+    layout = []
+    for indx in range(nrow):
+        row_layout = []
+        for indx in range(ncol):
+            row_layout.append({})
+        layout.append(row_layout)
+    return layout

rephorm/object_mappers/_utilities/table_mapper_utility.py

@@ -0,0 +1,59 @@
+#TODO: extract this function to external module.
+from typing import Literal
+from rephorm.objects.table_section import TableSection
+from rephorm.objects.table_series import TableSeries
+
+# Adjustment for text width, because fpdf does not calculate it correctly
+# Todo: Investigate why, and if it is possible to fix it
+magic_number = 10
+
+def get_max_numerical_width(table, pdf, font_family, font_size, biggest_nr, table_element=None, max_width = 0):
+    """
+    Determine the maximum width needed for numerical values in the table.
+    Ensures width does not exceed max_width.
+
+    How it works: Finds the longest formatted numerical string within the whole table
+    """
+    pdf.set_font(font_family, size=font_size)
+    max_cap = pdf.get_string_width(str(biggest_nr)) + magic_number
+
+    table_element = table_element if table_element else table
+
+    for child in table_element.CHILDREN:
+        if isinstance(child, TableSeries):
+            series_data = child.data.get_values(child.settings.span)
+            for value in series_data:
+                formatted_value = f"{value:.{child.settings.decimal_precision}f}"
+                text_width = pdf.get_string_width(str(formatted_value)) + magic_number
+                if text_width > max_width:
+                    max_width = min(text_width, max_cap)
+
+        elif isinstance(child, TableSection):
+            section_max_width = get_max_numerical_width(table, pdf, font_family, font_size, biggest_nr, child, max_width)
+            max_width = max(max_width, section_max_width)
+
+    return max_width
+
+def get_max_width(table, pdf, font_family, font_size, table_element = None, parameter: Literal["title", "unit"] = "unit", max_width = 0):
+
+    pdf.set_font(font_family, size=font_size)
+
+    table_element = table_element if table_element else table
+
+    for child in table_element.CHILDREN:
+
+        if isinstance(child, TableSeries):
+            attr_value = getattr(child, parameter)
+            if attr_value is not None:
+                text_width = pdf.get_string_width(attr_value) + magic_number
+                if text_width > max_width:
+                    max_width = text_width
+
+        elif isinstance(child, TableSection):
+            if parameter == "title":
+                section_title_width = pdf.get_string_width(child.TITLE) + magic_number
+                if section_title_width > max_width:
+                    max_width = section_title_width
+            section_max_width = get_max_width(table, pdf, font_family, font_size, child, parameter)
+            max_width = max(max_width, section_max_width)
+    return max_width

rephorm/object_mappers/chapter_mapper.py

@@ -0,0 +1,82 @@
+from rephorm.utility.report.add_footnotes import add_footnotes_at_bottom
+from rephorm.utility.report.footnotes_counter import generate_footnote_numbers
+from rephorm.utility.report.layout_utility import LayoutManager
+from rephorm.utility.report.title_utility import add_title_with_references
+
+
+class ChapterMapper:
+    def __init__(self, chapter):
+        self.chapter = chapter
+
+    # Todo: Reconsider add_to_pdf method naming. it would make more sense "render" or "map" because we do
+    #  add things to the pdf and then go through the children here and eventually render them too...
+    def add_to_pdf(self, **kwargs):
+
+        pdf = kwargs["pdf"]
+        footer_last_y = kwargs["footer_last_y"] if "footer_last_y" in kwargs else None
+        starting_page = pdf.page_no()
+        n_children = len(self.chapter.CHILDREN)
+
+
+        rs = self.chapter.settings.styles["report"]
+        used_top_height = rs["header"]["height"] + rs["header"]["bottom_margin"]
+        footer_top_padding = rs["footer"]["top_padding"]
+        footer_top_margin = rs["footer"]["top_margin"]
+
+        pdf.set_y(used_top_height)
+
+        pdf.set_font(
+            family=self.chapter.settings.styles["chapter"]["font_family"],
+            size=self.chapter.settings.styles["chapter"]["font_size"],
+            style=self.chapter.settings.styles["chapter"]["font_style"],
+        )
+
+        if self.chapter.title is not None:
+            footnote_references = generate_footnote_numbers(self.chapter.footnotes)
+            title_y_pos = pdf.h / 2 - pdf.font_size / 2 # Todo: consider multiline title in the future (would need to calculate h of the text cell)
+            add_title_with_references(pdf, self.chapter.title, footnote_references,
+                                      font_family=self.chapter.settings.styles["chapter"]["title"]["font_family"],
+                                      font_size=self.chapter.settings.styles["chapter"]["title"]["font_size"],
+                                      font_style=self.chapter.settings.styles["chapter"]["title"]["font_style"],
+                                      title_y=title_y_pos, cell_width=pdf.epw)
+            if n_children > 0:
+                pdf.add_page()
+
+            if bool(self.chapter.footnotes):
+                footer_last_y = add_footnotes_at_bottom(
+                    pdf,
+                    self.chapter.footnotes,
+                    footnote_references,
+                    last_y=footer_last_y,
+                    font_family=self.chapter.settings.styles["footnotes"]["font_family"],
+                    font_size=self.chapter.settings.styles["footnotes"]["font_size"],
+                    font_style=self.chapter.settings.styles["footnotes"]["font_style"],
+                    footer_padding=footer_top_padding,
+                    footer_top_margin=footer_top_margin,
+                )
+
+        layout_manager = LayoutManager(
+            pdf,
+            used_top_height=used_top_height,
+        )
+
+        for i, item in enumerate(self.chapter.CHILDREN):
+
+            x, y, width, height = layout_manager.get_default_layout()
+
+            current_page_nr = pdf.page_no()
+            if current_page_nr > starting_page:
+                starting_page = current_page_nr
+                # footer_last_y = None
+
+            mapper = item._get_mapper()
+
+            # TODO: IMPORTANT: Review the design and implement everything in a way where we pass single Y position
+            #  across the object mappers, so we do not need Y - to set the position of chapter elements/objects,
+            #  then title_y to correctly set the titles. We should pass Y along, and render elements/titles from the
+            #  LAST known Y position (which is the last element rendered). This way we can avoid the need for
+            #  title_y and footer_last_y, and god knows how many more Y's :D
+            mapper.add_to_pdf(pdf=pdf, x=x, y=y, w=width, h=height, footer_last_y=footer_last_y)
+
+            if i < n_children - 1:
+                pdf.add_page()

rephorm/object_mappers/chart_mapper.py

@@ -0,0 +1,120 @@
+import os
+
+import irispie
+import numpy as np
+from plotly.graph_objects import Figure
+
+from rephorm.object_mappers._globals import set_figure_map
+from rephorm.object_mappers._utilities.chart_mapper_utility import process_bar_data
+from rephorm.utility.report.image_utility import to_image
+from rephorm.dict.update_layout import update_layout
+from rephorm.utility.report.resolve_color import resolve_highlight_color
+
+
+class ChartMapper:
+
+    def __init__(self, chart):
+        self.chart = chart
+        self.figure = Figure()
+        self.apply_report_layout = chart.settings.apply_report_layout
+
+    def add_to_pdf(self, **kwargs):
+        grid_size = kwargs.get("grid_size", 1)
+        pdf = kwargs["pdf"]
+        x = kwargs["x"]
+        y = kwargs["y"]
+        w = kwargs["w"]
+        h = kwargs["h"]
+
+        scale_f = pdf.k
+
+        img_w = w * scale_f
+        img_h = h * scale_f
+
+        if grid_size > 9:
+            img_w = None
+            img_h = None
+
+        # Todo: Directory creation and check, should be extracted from here, too many concerns...
+        directory = "./tmp/pdf_figures"
+        os.makedirs(directory, exist_ok=True)
+
+        self.figure = self.chart.figure or self._add_internal_figure()
+
+        if self.apply_report_layout and bool(self.chart.figure):
+            update_layout(self.chart.figure.layout.title.text, self.chart.settings, self.figure)
+
+        data = to_image(self.figure, image_format="pdf", width=img_w, height=img_h)
+
+        if data is None:
+            raise ValueError(f"ChartMapper: Failed to render chart image. Data is: {data}")
+
+        file_path = f"{directory}/{id(self.chart)}.pdf"
+        with open(file_path, "wb") as f:
+            f.write(data)
+
+        fig_map = ({"page": pdf.page_no(),
+                    "pdf_path": file_path,
+                    "x": x * scale_f,
+                    "y": y * scale_f,
+                    "width": w * scale_f,
+                    "height": h * scale_f})
+
+        set_figure_map(fig_map)
+
+    def _add_internal_figure(self):
+
+        min_y = None
+        max_y = None
+
+        span = self.chart._get_span()
+        span_length = len(span)
+        neg_stacked_bars_data = np.zeros(span_length)
+        pos_stacked_bars_data = np.zeros(span_length)
+        stacked_bars = False
+
+        for item in self.chart.CHILDREN:
+            for variant in range(1, item.data.num_variants + 1):
+                y_values = item.data.get_data_variant_from_until(span, variant).flatten()
+                if item.settings.series_type in ("barcon", "conbar", "contribution_bar", "bar_relative"):
+                    stacked_bars = True
+                    neg_stacked_bars_data, pos_stacked_bars_data = process_bar_data(
+                        neg_stacked_bars_data,
+                        pos_stacked_bars_data,
+                        y_values
+                    )
+                else:
+                    # Direct min/max calculation for non-barcon series
+                    current_min = y_values.min()
+                    current_max = y_values.max()
+
+                    min_y = current_min if min_y is None else min(min_y, current_min)
+                    max_y = current_max if max_y is None else max(max_y, current_max)
+
+            series_mapper = item._get_mapper()
+            series_mapper.add_to_pdf(
+                figure=self.figure)  # Todo: This add_to_pdf call is confusing, yes, we wanted to unify function names, but in this case it does not make sense.
+
+        if stacked_bars:
+            min_y = min(neg_stacked_bars_data) if min_y is None else min(min_y, min(neg_stacked_bars_data))
+            max_y = max(pos_stacked_bars_data) if max_y is None else max(max_y, max(pos_stacked_bars_data))
+
+        dy = max_y - min_y
+        y_range = [min_y - dy * 0.01, max_y + dy * 0.01]
+
+        update_layout(self.chart.title, self.chart.settings, self.figure, y_range)
+
+        # Adjusts view SPAN on charts. "Slices" any padding between.
+        # self.figure.layout.xaxis.range = [span.start.to_python_date(position="start"),
+        #                                   span.end.to_python_date(position="end")]
+
+        if self.chart.settings.highlight is not None:
+            irispie.plotly.highlight(self.figure, self.chart._get_highlight(),
+                                     color=resolve_highlight_color(
+                                         self.chart.settings.styles["chart"]["highlight_color"], alpha=0.25))
+
+            # Todo: This is a workaround for the issue with the highlight. It should be fixed in the irispie library.
+            #  therefore, delete update_shapes() call here, when it's fixed in iris-pie
+            self.figure.update_shapes({"layer": "below"})
+
+        return self.figure

rephorm/object_mappers/chart_series_mapper.py

@@ -0,0 +1,52 @@
+from rephorm.dict.update_traces import update_base_traces, apply_per_trace_styles
+
+
+class ChartSeriesMapper:
+    def __init__(self, series):
+        self.series = series
+
+    def add_to_pdf(self, **kwargs):
+
+        figure = kwargs["figure"]
+        num_variants = self.series.data.num_variants
+        # Here we will get either single value or a list of values, depends if multivariate or not:
+        line_colors = self.series.settings.styles["chart"]["series"]["line_color"]
+        line_widths = self.series.settings.styles["chart"]["series"]["line_width"]
+        line_styles = self.series.settings.styles["chart"]["series"]["line_style"]
+        bar_colors = self.series.settings.styles["chart"]["series"]["bar_face_color"]
+
+        def get_series_type(key):
+            mapping = {
+                "line": "line",
+                "bar": "bar",
+                "bar_stack": "bar_stack",
+                "contribution_bar": "bar_relative",
+                "conbar": "bar_relative",
+                "barcon": "bar_relative",
+                "bar_relative": "bar_relative",
+                "bar_group": "bar_group",
+                "bar_overlay": "bar_overlay",
+            }
+            return mapping.get(key)
+
+        fig = self.series.data.plot(
+            span=self.series.settings.span,
+            date_format_style="compact",
+            date_axis_mode="instant",
+            figure=figure,
+            chart_type=get_series_type(self.series.settings.series_type),
+            legend=self.series.settings.legend,
+            show_legend=self.series.settings.show_legend,
+            return_info=True,
+            show_figure=False,
+            update_traces=update_base_traces(self.series.settings)
+        )
+
+        apply_per_trace_styles(
+            fig["figure"],
+            line_colors,
+            line_widths,
+            line_styles,
+            bar_colors,
+            num_variants,
+        )

rephorm/object_mappers/grid_mapper.py

@@ -0,0 +1,106 @@
+from rephorm.object_mappers._utilities.grid_mapper_utility import compute_grid_layout
+from rephorm.utility.report.add_footnotes import add_footnotes_at_bottom
+from rephorm.utility.report.footnotes_counter import generate_footnote_numbers
+from rephorm.utility.report.layout_utility import LayoutManager
+from rephorm.utility.report.title_utility import add_title_with_references
+
+
+class GridMapper:
+    def __init__(self, grid):
+        self.grid = grid
+
+    def add_to_pdf(self, **kwargs):
+
+        pdf = kwargs["pdf"]
+        layout = self.grid.settings.layout
+        nrow = self.grid.settings.nrow
+        ncol = self.grid.settings.ncol
+        footer_last_y = kwargs["footer_last_y"] if "footer_last_y" in kwargs else None
+        starting_page = pdf.page_no()
+        rs = self.grid.settings.styles["report"]
+        footer_top_padding = rs["footer"]["top_padding"]
+        footer_top_margin = rs["footer"]["top_margin"]
+        title_bottom_padding = rs["title_bottom_padding"]
+        # Todo: For grid why we dont take as in chapter? The used top height calculation?
+        #  What is the reason to have Y coming from kwargs? Because then it takes Y from chapter/report layout calculations,
+        #  and here it passes to layout... So I guess this is what offsets it differently, when adding chart to
+        #  report/chapter directly and when having it inside 1x1 grid
+        y = kwargs["y"]
+        grid_size = self.grid.settings.ncol * self.grid.settings.nrow
+
+        if layout is None:
+            layout = compute_grid_layout(nrow=nrow, ncol=ncol)
+
+        if len(self.grid.CHILDREN) > grid_size:
+            raise Exception(
+                f"Grid capacity exceeded: attempting to add {len(self.grid.CHILDREN)} object(-s) to a grid with capacity for only "
+                f"{grid_size} object(-s) ({self.grid.settings.ncol}x{self.grid.settings.nrow}). "
+                f"Please either increase grid size or reduce the number of objects."
+            )
+
+        footnote_references = generate_footnote_numbers(self.grid.footnotes)
+        y = add_title_with_references(pdf, self.grid.title, footnote_references,
+                                  self.grid.settings.styles["grid"]["title"]["font_family"],
+                                  self.grid.settings.styles["grid"]["title"]["font_size"],
+                                  self.grid.settings.styles["grid"]["title"]["font_style"], title_y=y)
+
+        if bool(self.grid.footnotes):
+
+                footer_last_y = add_footnotes_at_bottom(
+                    pdf,
+                    self.grid.footnotes,
+                    footnote_references,
+                    last_y=footer_last_y,
+                    font_family=self.grid.settings.styles["footnotes"]["font_family"],
+                    font_size=self.grid.settings.styles["footnotes"]["font_size"],
+                    font_style=self.grid.settings.styles["footnotes"]["font_style"],
+                    footer_padding=footer_top_padding,
+                    footer_top_margin=footer_top_margin,
+                )
+
+        layout_manager = LayoutManager(
+            pdf=pdf,
+            used_top_height=y+title_bottom_padding,
+        )
+
+        positions = layout_manager.calculate_position(layout=layout, nrow=nrow, ncol=ncol)
+        valid_positions = list(positions.keys())
+        # Todo: set to the last chart | Do not remove, yet
+        # last_element = valid_positions[-1]
+        # last_element_data = positions[last_element]
+        # pdf.line(pdf.l_margin, last_element_data["y"] + last_element_data["height"], pdf.w - pdf.r_margin, last_element_data["y"] + last_element_data["height"])
+
+        for i, item in enumerate(self.grid.CHILDREN):
+
+            position = valid_positions[i]
+            pos_data = positions[position]
+
+            current_page = pdf.page_no()
+            if current_page > starting_page:
+                starting_page = current_page
+                footer_last_y = None
+
+
+            grid_size = self.grid.settings.ncol * self.grid.settings.nrow
+
+            mapper = item._get_mapper()
+            mapper.add_to_pdf(
+                pdf=pdf,
+                x=pos_data["x"],
+                y=pos_data["y"],
+                w=pos_data["width"],
+                h=pos_data["height"],
+                grid_size=grid_size,
+                footer_last_y=footer_last_y,
+                context="grid",
+            )
+
+            # For debugging
+            # pdf.set_draw_color(255, 0, 0)
+            # pdf.rect(
+            #     x=pos_data["x"],
+            #     y=pos_data["y"],
+            #     w=pos_data["width"],
+            #     h=pos_data["height"],
+            # )
+

rephorm/object_mappers/page_break_mapper.py

@@ -0,0 +1,8 @@
+
+class PageBreakMapper:
+    def __init__(self, page_break):
+        self.page_break = page_break
+
+    def add_to_pdf(self, **kwargs):
+        pdf = kwargs["pdf"]
+        pdf.add_page()

rephorm/object_mappers/report_mapper.py

@@ -0,0 +1,76 @@
+from logging import warning
+
+from fpdf import FPDF
+
+from rephorm.object_mappers._globals import get_figure_map
+from rephorm.utility.report.cleanup_utility import perform_cleanup
+from rephorm.utility.report.layout_utility import LayoutManager
+from rephorm.utility.merge.pdf_merger import overlay_pdfs
+from rephorm.utility.report.report_utility import set_title_page
+
+
+class ReportMapper:
+
+    def __init__(self, pdf: FPDF):
+        self.pdf = pdf
+
+    def compile(self, report, file_name: str, cleanup:bool = False):
+
+        rs = report.settings.styles["report"]
+
+        self.pdf.t_margin = rs["page_margin_top"]
+
+        # TODO: Currently, we offset all bottom spacing to the bottom margin because FPDF2
+        #  automatically breaks tables as soon as it reaches the bottom margin. This prevents
+        #  any overlap with the footer, since the footer is included in fpdf.b_margin.
+        #  We need to apply the same approach for the top margin and top spacing
+        #  (e.g., header, title padding, etc.).
+        # Also, make sure to verify whether any top padding or margin we have is actually
+        # padding or margin. Padding refers to inner spacing, while margin is outer spacing.
+        # Follow the standard convention.
+
+        self.pdf.b_margin = rs["page_margin_bottom"] + rs["footer"]["height"] + rs["footer"]["top_margin"]
+        self.pdf.l_margin = rs["page_margin_left"]
+        self.pdf.r_margin = rs["page_margin_right"]
+        self.pdf.c_margin = 0
+
+        self.pdf.add_page()
+        base_file_path = f"./tmp/report_tmp.pdf"
+        directory_path = "./tmp/pdf_figures"
+
+        used_top_height = rs["header"]["height"] + rs["header"]["bottom_margin"]
+
+        layout_manager = LayoutManager(pdf=self.pdf, used_top_height=used_top_height)
+
+        set_title_page(self.pdf, report)
+
+        n_children = len(report.CHILDREN)
+
+        for i, item in enumerate(report.CHILDREN):
+
+            x, y, w, h = layout_manager.get_default_layout()
+            mapper = item._get_mapper()
+            # reset width to default
+            # if children does not have width set by user, use the default width, if they do:
+            # check if it does not exceed pdf.w and then use children's width instead.
+            if hasattr(item, "width") and item.width is not None:
+                if item.width > self.pdf.w:
+                    warning(
+                        f"{repr(item)} width: ({item.width}) | exceeds the PDF page width: ({self.pdf.w}). Falling back to defaults"
+                    )
+                else:
+                    w = item.width
+
+            mapper.add_to_pdf( pdf = self.pdf, w = w, h = h, x = x, y = y)
+
+            if i < n_children-1:
+                self.pdf.add_page()
+
+        if not get_figure_map():
+            self.pdf.output(f"{file_name}.pdf")
+        else:
+            self.pdf.output(base_file_path)
+            overlay_pdfs(base_pdf_path=base_file_path, pdf_data=get_figure_map(),
+                         output_pdf_path=f"{file_name}.pdf")
+            perform_cleanup(cleanup, directory_path, base_file_path)
+