wbreport 1.43.1__py2.py3-none-any.whl

wbreport/pdf/charts/legend.py

@@ -0,0 +1,15 @@
+from reportlab.graphics.charts.legends import Legend
+from reportlab.graphics.shapes import Circle
+from reportlab.lib.colors import transparent
+
+
+class CustomLegend(Legend):
+    def _defaultSwatch(self, x, thisy, dx, dy, fillColor, strokeWidth, strokeColor):
+        return Circle(
+            x,
+            thisy + dx / 2,
+            dx / 2,
+            fillColor=fillColor,
+            strokeColor=transparent,
+            strokeWidth=strokeWidth,
+        )

wbreport/pdf/charts/pie.py

@@ -0,0 +1,169 @@
+from reportlab.graphics.charts.piecharts import Pie
+from reportlab.graphics.shapes import Drawing
+from reportlab.lib import colors
+from reportlab.lib.units import cm
+from wbreport.pdf.charts.legend import CustomLegend
+
+
+def get_data_and_labels_from_df(df, color_palette, percent=True):
+    data = list()
+    colornamepairs = list()
+
+    for index, row in enumerate(df.itertuples()):
+        data.append(float(row.weighting))
+
+        label = f"{row[2]*100:.1f}%" if percent else f"{row[2]:.1f}"
+        colornamepairs.append((colors.HexColor(color_palette[index]), f"{row[1]} {label}"))
+
+    return data, colornamepairs
+
+
+def get_legend_height(df, r2_legend=0.3 * cm, legend_padding=1, legend_max_cols=7):
+    return min(len(df), legend_max_cols) * (r2_legend + legend_padding)
+
+
+def get_pie_chart_vertical_height(
+    df,
+    r2=2.5 * cm,
+    padding=0.45 * cm,
+    r2_legend=0.3 * cm,
+    legend_padding=1,
+    legend_max_cols=7,
+):
+    return 3 * padding + r2 + get_legend_height(df, r2_legend, legend_padding, legend_max_cols)
+
+
+def get_pie_chart_vertical(
+    df,
+    width,
+    height,
+    color_palette,
+    r2=2.5 * cm,
+    padding=0.45 * cm,
+    r2_legend=0.3 * cm,
+    legend_padding=1,
+    legend_max_cols=7,
+):
+    drawing = Drawing(width, height)
+    pie = Pie()
+
+    pie.width = r2
+    pie.height = r2
+
+    pie.x = (width - r2) / 2
+    pie.y = height - r2 - padding
+    df = df.sort_values(by=["weighting"], ascending=False)
+    data, colornamepairs = get_data_and_labels_from_df(df, color_palette)
+
+    for i, color in enumerate(colornamepairs):
+        pie.slices[i].fillColor = color[0]
+        pie.slices[i].strokeColor = colors.transparent
+        pie.slices[i].strokeWidth = 0  # Border width for wedge
+    pie.slices.strokeWidth = 0  # Width of the border around the pie chart.
+    pie.data = data
+
+    drawing.add(pie)
+
+    legend = CustomLegend()
+
+    legend.alignment = "right"
+    legend.boxAnchor = "nw"
+    legend.x = 0
+    legend.y = height - r2 - 2 * padding
+    legend.dx = legend.dy = r2_legend
+    legend.strokeWidth = -1
+    legend.columnMaximum = legend_max_cols
+    legend.colorNamePairs = colornamepairs
+    legend.fontName = "customfont"
+    legend.fontSize = 6
+
+    legend.deltax = 0  # Here
+    legend.deltay = legend_padding
+    legend.swdx = 12
+    legend.swdy = 0
+
+    legend.dxTextSpace = r2_legend
+
+    legend.variColumn = True
+
+    drawing.add(legend)
+    return drawing
+
+
+def get_pie_chart_horizontal_height(
+    df,
+    r2=2.5 * cm,
+    padding=0.45 * cm,
+    r2_legend=0.3 * cm,
+    legend_padding=1,
+    legend_max_cols=7,
+):
+    return max(
+        2 * padding + r2,
+        2 * padding + get_legend_height(df, r2_legend, legend_padding, legend_max_cols),
+    )
+
+
+def get_pie_chart_horizontal(
+    df,
+    width,
+    height,
+    color_palette,
+    col_width,
+    r2=2.5 * cm,
+    padding=0.45 * cm,
+    r2_legend=0.3 * cm,
+    legend_padding=1,
+    legend_max_cols=7,
+    legend_x=None,
+):
+    drawing = Drawing(width, height)
+    pie = Pie()
+
+    pie.width = r2
+    pie.height = r2
+
+    pie.x = (col_width - r2) / 2
+    pie.y = height - r2 - padding
+    df = df.sort_values(by=["weighting"], ascending=False)
+    data, colornamepairs = get_data_and_labels_from_df(df, color_palette)
+
+    for i, color in enumerate(colornamepairs):
+        pie.slices[i].fillColor = color[0]
+        pie.slices[i].strokeColor = colors.transparent
+        pie.slices[i].strokeWidth = 0  # Border width for wedge.
+    pie.slices.strokeWidth = 0  # Width of the border around the pie chart.
+    pie.data = data
+
+    drawing.add(pie)
+
+    legend = CustomLegend()
+
+    # legend.x = 4.82 * cm
+    # legend.y += 0.78 * cm
+
+    legend_height = get_legend_height(df, r2_legend, legend_padding, legend_max_cols)
+
+    legend.alignment = "right"
+    legend.boxAnchor = "nw"
+
+    if legend_x:
+        legend.x = legend_x
+    else:
+        legend.x = width - col_width
+
+    legend.y = (height + legend_height) / 2
+    legend.dx = legend.dy = r2_legend
+    legend.strokeWidth = -1
+    legend.columnMaximum = legend_max_cols
+    legend.colorNamePairs = colornamepairs
+    legend.fontName = "customfont"
+    legend.fontSize = 6
+
+    legend.deltax = 0
+    legend.deltay = legend_padding
+    legend.swdx = 12
+    legend.swdy = 0
+
+    drawing.add(legend)
+    return drawing

wbreport/pdf/charts/timeseries.py

@@ -0,0 +1,77 @@
+from enum import Enum
+
+from reportlab.graphics.charts.axes import LogYValueAxis, NormalDateXValueAxis
+from reportlab.graphics.charts.lineplots import LinePlot, SimpleTimeSeriesPlot
+from reportlab.graphics.shapes import Drawing
+from reportlab.lib import colors
+from reportlab.lib.units import cm
+
+
+class Scale(Enum):
+    ARITHMETIC = 1
+    LOGARITHMIC = 2
+
+
+class LogScaleTimeSeriesPlot(LinePlot):
+    def __init__(self):
+        super().__init__()
+
+        class CustomYAxis(LogYValueAxis):
+            def _calcTickPositions(self):
+                return self._calcStepAndTickPositions()[1]
+
+        self.xValueAxis = NormalDateXValueAxis()
+        self.yValueAxis = CustomYAxis()
+
+
+def get_timeseries_chart(
+    data, width, height, color, fill_color, grid_color, scale, x_label_format="{mm}/{yy}", **chart_attributes
+):
+    width -= 0.65 * cm
+    chart_map = {
+        Scale.ARITHMETIC.value: SimpleTimeSeriesPlot,
+        Scale.LOGARITHMIC.value: LogScaleTimeSeriesPlot,
+    }
+    data = [list(filter(lambda x: x[1] > 0, data[0]))]
+    max_x_ticks = 20
+
+    # ensure that if the data count is too low (e.g. less than a month range), we don't overcrowds the X axis
+    if len(data[0]) < max_x_ticks:
+        x_label_format = "{dd}/{mm}/{yy}"
+        max_x_ticks = 10
+
+    drawing = Drawing(width, height)
+
+    chart = chart_map[scale]()
+    chart.width = width
+    chart.height = height
+
+    for key, value in chart_attributes.items():
+        setattr(chart, key, value)
+
+    chart.data = data
+
+    chart.lines[0].strokeWidth = 0.5
+    chart.lines[0].strokeColor = color
+    chart.lines[0].fillColor = fill_color
+    chart.lines[0].inFill = True
+
+    chart.yValueAxis.strokeWidth = -1
+    chart.yValueAxis.strokeColor = colors.white
+    chart.yValueAxis.labels.fontSize = 7
+    chart.yValueAxis.labels.fontName = "customfont"
+    chart.yValueAxis.labels.dx = width + 0.55 * cm
+    chart.yValueAxis.maximumTicks = 100
+    chart.yValueAxis.labelTextFormat = "%d"
+
+    chart.xValueAxis.strokeWidth = 0
+    chart.xValueAxis.labels.fontSize = 7
+    chart.xValueAxis.labels.fontName = "customfont"
+    chart.xValueAxis.maximumTicks = max_x_ticks
+    chart.xValueAxis.visibleGrid = 1
+    chart.xValueAxis.gridStrokeDashArray = (0.2, 0, 0.2)
+    chart.xValueAxis.gridStrokeColor = grid_color
+    chart.xValueAxis.xLabelFormat = x_label_format
+
+    drawing.add(chart)
+    return drawing

wbreport/pdf/flowables/risk.py

@@ -0,0 +1,88 @@
+from reportlab.lib.colors import HexColor, black, white
+from reportlab.lib.units import cm
+from reportlab.pdfbase.pdfmetrics import stringWidth
+from reportlab.platypus import Flowable, Paragraph
+
+
+class RiskScale(Flowable):
+    def __init__(self, risk, para_style, text=None):
+        super().__init__()
+        self.risk = risk
+        self.risk_text = "The actual risk can vary significantly if you cash in at an early stage and you may get back less. You may not be able to sell your product easily or you may have to sell at a price that significantly impacts on how much you get back."
+        self.additional_text = text
+        self.para_style = para_style
+        self.height = 3.564 * cm
+        if text:
+            self.height += 18
+
+    def draw(self):
+        width = 0.4 * cm
+        gap = 1.177 * cm
+
+        y = self.height - 0.868 * cm
+        x_offset = 0.883 * cm
+        self.canv.setFillColor(HexColor(0x9EA3AC))
+        for x in range(7):
+            _x = x * gap + x_offset
+            if x == self.risk - 1:
+                self.canv.setFillColor(HexColor(0x3C4859))
+                self.canv.circle(_x, y, width, fill=True, stroke=False)
+                self.canv.setFillColor(HexColor(0x9EA3AC))
+            else:
+                self.canv.circle(_x, y, width, fill=True, stroke=False)
+
+            self.canv.setFillColor(white)
+            self.canv.setFont("customfont-bd", 11)
+            self.canv.drawCentredString(_x, y - 4, str(x + 1))
+            self.canv.setFillColor(HexColor(0x9EA3AC))
+
+        self.canv.setFillColor(HexColor(0x6D7683))
+        self.canv.setStrokeColor(HexColor(0x6D7683))
+
+        arrow_offset = 0.2 * cm
+
+        p = self.canv.beginPath()
+        origin = (x_offset - arrow_offset, y - 0.868 * cm)
+        p.moveTo(*origin)
+        p.lineTo(origin[0] + 0.059 * cm, origin[1] + 0.08 * cm)
+        p.lineTo(origin[0] - 0.165 * cm, origin[1])
+        p.lineTo(origin[0] + 0.059 * cm, origin[1] - 0.08 * cm)
+        self.canv.drawPath(p, fill=True, stroke=False)
+
+        p = self.canv.beginPath()
+        origin = (6 * gap + x_offset + arrow_offset, y - 0.868 * cm)
+        p.moveTo(origin[0], origin[1])
+        p.lineTo(origin[0] - 0.059 * cm, origin[1] + 0.08 * cm)
+        p.lineTo(origin[0] + 0.165 * cm, origin[1])
+        p.lineTo(origin[0] - 0.059 * cm, origin[1] - 0.08 * cm)
+        self.canv.drawPath(p, fill=True, stroke=False)
+
+        self.canv.setLineWidth(0.02 * cm)
+        p = self.canv.beginPath()
+        self.canv.line(
+            x_offset - arrow_offset,
+            y - 0.868 * cm,
+            6 * gap + x_offset + arrow_offset,
+            y - 0.868 * cm,
+        )
+
+        self.canv.setFont("customfont", 6)
+        self.canv.setFillColor(black)
+        self.canv.drawString(x_offset - arrow_offset - 0.165 * cm, y - 1.2 * cm, "LOWER RISK")
+
+        text_width = stringWidth("HIGHER RISK", "customfont", 6)
+        self.canv.drawString(
+            6 * gap + x_offset + arrow_offset + 0.165 * cm - text_width,
+            y - 1.2 * cm,
+            "HIGHER RISK",
+        )
+
+        para = Paragraph(self.risk_text, style=self.para_style)
+        para.wrapOn(self.canv, 250, 8.954 * cm)
+        para.drawOn(self.canv, 0, y - 2.5 * cm)
+
+        if self.additional_text:
+            para = Paragraph(f"<i>* {self.additional_text}</i>", style=self.para_style)
+
+            para.wrapOn(self.canv, 250, 8.954 * cm)
+            para.drawOn(self.canv, 0, y - 3.2 * cm)

wbreport/pdf/flowables/textboxes.py

@@ -0,0 +1,143 @@
+from reportlab.graphics import renderPDF
+from reportlab.lib.colors import black
+from reportlab.lib.units import cm
+from reportlab.pdfbase.pdfmetrics import stringWidth
+from reportlab.platypus import Flowable, Image, Paragraph, Table, TableStyle
+from svglib.svglib import svg2rlg
+
+
+class TextBox(Flowable):
+    def __init__(
+        self,
+        width,
+        height,
+        text,
+        text_style,
+        box_color,
+        grid_width=0.30 * cm,
+        offset=None,
+        debug=False,
+    ):
+        super().__init__()
+        self.width = width
+        self.height = height
+        self.offset = offset or 0
+        self.grid_width = grid_width
+
+        self.text_table = Table([[Paragraph(text, style=text_style)]], rowHeights=[height - grid_width])
+        table_styles = [
+            ("BACKGROUND", (0, 0), (0, 0), box_color),
+            ("GRID", (0, 0), (0, 0), grid_width, box_color),
+            ("VALIGN", (0, 0), (0, 0), "MIDDLE"),
+        ]
+
+        if debug:
+            table_styles.extend(
+                [
+                    ("BOX", (0, 0), (-1, -1), 0.25, black),
+                    ("INNERGRID", (0, 0), (-1, -1), 0.25, black),
+                ]
+            )
+
+        self.text_table.setStyle(TableStyle(table_styles))
+
+    def draw(self):
+        self.text_table.wrapOn(self.canv, self.width - self.grid_width - self.offset, self.height)
+        self.text_table.drawOn(self.canv, (self.offset or 0) + (self.grid_width / 2), (self.grid_width / 2))
+
+
+class TextBoxWithImage(TextBox):
+    def __init__(
+        self,
+        width,
+        height,
+        img,
+        img_x,
+        img_y,
+        img_width,
+        img_height,
+        text,
+        text_style,
+        box_color,
+        grid_width=0.28 * cm,
+        svg=False,
+        offset=None,
+        debug=False,
+    ):
+        super().__init__(width, height, text, text_style, box_color, grid_width, offset, debug)
+        self.img = img
+        self.img_x = img_x
+        self.img_y = img_y
+        self.img_width = img_width
+        self.img_height = img_height
+        self.svg = svg
+
+    def draw(self):
+        super().draw()
+
+        if self.svg:
+            raise NotImplementedError("SVG is not yet implemented.")
+        else:
+            img = Image(self.img)
+            img.drawWidth = self.img_width
+            img.drawHeight = self.img_height
+            img.drawOn(self.canv, self.img_x, self.img_y)
+
+
+class TextWithIcon(Flowable):
+    def __init__(self, width, height, text, font, font_size, icon=None):
+        self.width = width
+        self.height = height
+        self.text = text
+        self.font = font
+        self.font_size = font_size
+        self.icon = icon
+        self.svg = None
+        if icon:
+            self.svg = self.icon.name.split(".")[-1] in ["svg", "SVG"]
+
+    def draw(self):
+        # Get text width and set font
+        text_width = stringWidth(self.text, self.font, self.font_size)
+        self.canv.setFont(self.font, self.font_size, leading=self.font_size)
+
+        # Get icon
+        icon = None
+        if self.svg:
+            icon = svg2rlg(self.icon)
+        elif self.icon and self.icon.name:
+            icon = Image(self.icon)
+
+        tx = self.width / (4 if icon else 2) - text_width / 2
+        ty = self.height / 2 - self.font_size / 2
+        self.canv.drawString(tx, ty, self.text)
+
+        if icon:
+            if self.svg:
+                icon_width = icon.width
+                icon_height = icon.height
+            else:
+                icon_width = icon.imageWidth
+                icon_height = icon.imageHeight
+
+            drawing_height = self.height / 2
+            scale = drawing_height / icon_height
+            drawing_width = icon_width * scale
+
+            allowed_width = (self.width / 2) - 0.2 * cm
+
+            if drawing_width > allowed_width:
+                drawing_width = allowed_width
+                scale = drawing_width / icon_width
+                drawing_height = icon_height * scale
+
+            dx = (self.width / 4) * 3 - (icon_width * scale) / 2
+            dy = (self.height - drawing_height) / 2
+
+            if self.svg:
+                icon.scale(scale, scale)
+                renderPDF.draw(icon, self.canv, dx, dy)
+            else:
+                icon.drawWidth = drawing_width
+                icon.drawHeight = drawing_height
+                icon.drawOn(self.canv, dx, dy)

wbreport/pdf/flowables/themes.py

@@ -0,0 +1,179 @@
+from reportlab.graphics.charts.barcharts import HorizontalBarChart
+from reportlab.graphics.charts.piecharts import Pie
+from reportlab.graphics.shapes import Drawing
+from reportlab.lib.colors import HexColor, transparent
+from reportlab.lib.formatters import DecimalFormatter
+from reportlab.lib.units import cm
+from reportlab.pdfbase.pdfmetrics import stringWidth
+from reportlab.platypus import Flowable
+from wbreport.pdf.charts.legend import CustomLegend
+
+
+class ThemeBreakdown(Flowable):
+    def __init__(self, df, width, grid_color):
+        # self.df = self.df[self.df["allocation_end"] > 0]
+        self.df = df[df["allocation_end"] != 0]
+        self.pie_padding = 0.45 * cm
+        self.pie_diameter = 2.5 * cm
+        self.pie_legend_diameter = 0.3 * cm
+        self.pie_legend_padding = 1
+        self.pie_legend_max_cols = len(self.df)
+
+        self.bar_width = 0.24 * cm
+        self.bar_padding = 0.3 * cm
+        self.bar_max_label_width = 3.35 * cm
+        self.bar_label_offset = 5
+
+        self.font_size = 6
+        self.font_name = "customfont"
+
+        self.width = width
+        self.height = self.get_height()
+
+        self.grid_color = grid_color
+
+    def get_pie_chart_legend_height(self):
+        return min(len(self.df), self.pie_legend_max_cols) * (self.pie_legend_diameter + self.pie_legend_padding)
+
+    def get_pie_chart_height(self):
+        return max(
+            2 * self.pie_padding + self.pie_diameter,
+            2 * self.pie_padding + self.get_pie_chart_legend_height(),
+        )
+
+    def get_bar_chart_height(self):
+        num_bars = len(self.df) * 2
+
+        return num_bars * self.bar_width + num_bars / 2 * self.bar_padding
+
+    def get_height(self):
+        pie_chart_height = self.get_pie_chart_height()
+        bar_chart_height = self.get_bar_chart_height()
+
+        return pie_chart_height + bar_chart_height + 40
+
+    def get_pie_chart_with_legend(self):
+        pie = Pie()
+
+        pie.x = (self.width / 2 - self.pie_diameter) / 2
+        pie.y = self.height - self.pie_diameter - self.pie_padding
+        pie.width = self.pie_diameter
+        pie.height = self.pie_diameter
+
+        pie_data = list()
+        pie_colornamepairs = list()
+        max_width_colornamepair = 0
+
+        self.df = self.df.sort_values(by=["allocation_end"], ascending=False).rename(
+            columns={"underlying_instrument__title_repr": "underlying_instrument__name_repr"}
+        )
+        for index, row in enumerate(self.df.itertuples()):
+            if row.allocation_end > 0:
+                label = f"{row.underlying_instrument__name_repr} {row.allocation_end*100:.1f}%"
+                pie_data.append(float(row.allocation_end))
+                pie.slices[index].fillColor = HexColor(row.color)
+                pie.slices[index].strokeColor = transparent
+            else:
+                label = f"{row.underlying_instrument__name_repr}"
+            pie_colornamepairs.append((HexColor(row.color), label))
+            max_width_colornamepair = max(max_width_colornamepair, stringWidth(label, "customfont", 6))
+
+        pie.slices.strokeWidth = -1
+        pie.data = pie_data
+
+        legend = CustomLegend()
+
+        legend.fontSize = 6
+        legend.fontName = "customfont"
+        legend.alignment = "right"
+        legend.boxAnchor = "nw"
+        legend.x = self.width / 2 - pie.width / 2 + self.pie_padding
+        legend.y = self.height - self.pie_padding
+        legend.dx = legend.dy = self.pie_legend_diameter
+        legend.columnMaximum = self.pie_legend_max_cols
+        legend.colorNamePairs = pie_colornamepairs
+        legend.strokeWidth = -1
+
+        legend.deltax = 0
+        legend.deltay = self.pie_legend_padding
+        legend.swdx = 12
+        legend.swdy = 0
+
+        return pie, legend
+
+    def get_bar_chart_with_legend(self):
+        bar = HorizontalBarChart()
+
+        self.df["contribution_total"] = self.df["contribution_total"] * 100
+        self.df["performance_total"] = self.df["performance_total"] * 100
+        self.df = self.df.sort_values(by=["performance_total"])
+
+        bar.data = [self.df.contribution_total.to_list(), self.df.performance_total.to_list()]
+
+        bar.x = 0
+        bar.y = 40
+
+        bar.width = self.width - self.bar_label_offset - stringWidth("00.00%", self.font_name, self.font_size)
+        bar.height = self.get_bar_chart_height()
+
+        bar.barLabels.dx = self.bar_label_offset
+        bar.barLabelFormat = DecimalFormatter(1, suffix="%")
+        bar.barLabels.dy = 0
+        bar.barLabels.boxAnchor = "w"
+        bar.barLabels.boxTarget = "hi"
+        bar.barLabels.fontSize = self.font_size
+        bar.barLabels.fontName = self.font_name
+        bar.barLabels.boxFillColor = None
+        bar.barLabels.boxStrokeColor = None
+
+        bar.groupSpacing = self.bar_padding
+        bar.barWidth = self.bar_width
+        bar.bars.strokeWidth = 0
+        bar.bars.strokeColor = None
+
+        for index, color in enumerate(self.df.color):
+            bar.bars[(0, index)].fillColor = HexColor(f"{color}80", hasAlpha=True)
+            bar.bars[(1, index)].fillColor = HexColor(color)
+
+        bar.valueAxis.labelTextFormat = DecimalFormatter(0, suffix="%")
+        bar.valueAxis.labels.fontName = "customfont"
+        bar.valueAxis.labels.fontSize = 6
+        bar.valueAxis.maximumTicks = 10
+        bar.valueAxis.strokeWidth = 0.5
+        bar.valueAxis.gridStrokeColor = self.grid_color
+        bar.valueAxis.gridStrokeDashArray = (0.2, 0, 0.2)
+        bar.valueAxis.visibleGrid = True
+        bar.valueAxis.forceZero = True
+
+        bar.categoryAxis.tickLeft = 0
+        bar.categoryAxis.strokeWidth = 0.5
+
+        legend = CustomLegend()
+        legend.x = 30
+        legend.y = 0
+
+        legend.alignment = "right"
+        legend.boxAnchor = "sw"
+        legend.strokeWidth = -1
+        legend.columnMaximum = 1
+        legend.colorNamePairs = [
+            (HexColor(0xAAAAAA), "Monthly Performance"),
+            (HexColor(0xAAAAAA80, hasAlpha=True), "Monthly Contribution"),
+        ]
+        legend.fontName = self.font_name
+        legend.fontSize = self.font_size
+        legend.deltax = 0
+        legend.swdx = 12
+        legend.swdy = 0
+
+        return bar, legend
+
+    def draw(self):
+        drawing = Drawing(self.width, self.height)
+        pie_chart, pie_legend = self.get_pie_chart_with_legend()
+        bar_chart, bar_legend = self.get_bar_chart_with_legend()
+        drawing.add(pie_chart)
+        drawing.add(pie_legend)
+        drawing.add(bar_chart)
+        drawing.add(bar_legend)
+        drawing.drawOn(self.canv, 0, 0)

wbreport/pdf/sandbox/run.py

@@ -0,0 +1,17 @@
+import importlib
+import sys
+from datetime import datetime
+
+from wbportfolio.models import Product
+
+report = sys.argv[1]
+
+module = importlib.import_module("wbreport.pdf.sandbox.templates.{report}")
+product = Product.objects.get(id=sys.argv[2])
+
+start = datetime.strptime(sys.argv[3], "%Y-%m-%d").date()
+end = datetime.strptime(sys.argv[4], "%Y-%m-%d").date()
+context = product.report._get_file_context(start=start, end=end)
+result = module.generate_report(context)
+with open("portfolio/report/pdf/sandbox/templates/testfile.pdf", "wb") as test_file:
+    test_file.write(result.read())