Example #1
0
 def get_info(self):
     if not self.portfolio:
         return []
     change, percent = self.portfolio.current_change
     change_text = gui_utils.get_string_from_float(percent) + '%' + ' | ' + gui_utils.get_currency_format_from_float(change)
     o_change, o_percent = self.portfolio.overall_change
     o_change_text = gui_utils.get_string_from_float(o_percent) + '%' + ' | ' + gui_utils.get_currency_format_from_float(o_change)
     return [(_('Day\'s gain'), gui_utils.get_green_red_string(change, change_text)),
             (_('Overall gain'), gui_utils.get_green_red_string(o_change, o_change_text)),
             ('Investments', gui_utils.get_currency_format_from_float(self.portfolio.get_current_value())),
             ('# positions', self.portfolio.active_positions_count),
             ('Last update', gui_utils.datetime_format(self.portfolio.last_update, False))
             ]
Example #2
0
    def add_chart(self):
        self.vbox.remove(self.current_chart)
        date1 = date.today()
        date2 = self.get_date2(self.current_zoom, date1)

        data = self.stock.get_quotations(date2)
        if len(data) == 0:
            if not self.noDataLabelShown:
                self.noDataLabelShown = True
                self.vbox.pack_end(Gtk.Label(label='No historical data found!'), True, True, 0)
                self.show_all()
            return
        controller = chart_controller.StockChartPlotController(data)
        self.current_chart = charts.SimpleLineChart(controller, 600)
        self.vbox.pack_end(self.current_chart, True, True, 0)

        change = controller.y_values[0][1][-1] - controller.y_values[0][1][0]
        if controller.y_values[0][1][0] == 0.1:
            safeDiv = 1
        else:
            safeDiv = controller.y_values[0][1][0]
        change_str = gui_utils.get_green_red_string(change, gui_utils.get_currency_format_from_float(change) + ' (' + str(round(change / safeDiv * 100, 2)) + '%)')
        self.change_label.set_markup(gui_utils.get_date_string(date2) + ' - ' + gui_utils.get_date_string(date1) + '     ' + change_str)

        self.show_all()
Example #3
0
 def on_updated(self, item):
     iterator = self.selected_item[1]
     row = self.tree.get_model()[iterator]
     if row:
         # row[1] = item
         row[2] = item.name
         row[3] = gui_utils.get_currency_format_from_float(item.balance)
Example #4
0
def current_price_markup(column, cell, model, iterator, column_id):
    try:
        asset = model.get_value(iterator, 0).asset
        # why? model.get_value(iterator, column_id)
        markup = "%s\n<small>%s</small>" % (gui_utils.get_currency_format_from_float(asset.price), gui_utils.get_datetime_string(asset.date))
        cell.set_property('markup', markup)
    except:
        pass
 def get_info(self):
     count = 0
     total = 0.0
     for pos in self.portfolio.get_closed_positions():
         count += 1
         total += pos.sell_total
     return [('# positions', count),
             ('Sum', gui_utils.get_currency_format_from_float(total))
             ]
Example #6
0
 def insert_portfolio(self, item):
     new_iter = self.tree.get_model().append(self.pf_iter,
                                     [item, 'portfolio',
                                      item.name,
                                      gui_utils.get_currency_format_from_float(item.get_current_value()),
                                      True,
                                      True])
     item.connect("positions_changed", self.on_container_updated, new_iter)
     item.connect("updated", self.on_container_updated, new_iter)
     return new_iter
Example #7
0
    def on_move(self, event):
        if not event.inaxes:
            self.line.set_visible(False)
            self.annotation.set_visible(False)
            event.canvas.draw()
            return

        x_val = min(int(round(event.xdata, 0)), len(self.controller.x_values) - 1)
        self.line.set_xdata(x_val)
        self.line.set_visible(True)
        self.annotation.set_visible(True)
        self.annotation.xy = x_val, event.ydata
        text = self.controller.x_values[x_val] + "\n"
        for name, vals in self.controller.y_values:
            text += name + ": " + gui_utils.get_currency_format_from_float(vals[x_val]) + "\n"
        self.annotation.set_text(text)
        event.canvas.draw()
 def get_info(self):
     transaction_sum = sum([row[0].amount for row in self.modelfilter])
     return [('# transactions', len(self.modelfilter)),
             ('Sum', gui_utils.get_currency_format_from_float(transaction_sum))]
Example #9
0
    def __init__(self, pf=None, date=None, price=None, position=None, dividend=None, parent=None):
        Gtk.Dialog.__init__(
            self,
            _("Add dividend"),
            parent,
            Gtk.DialogFlags.MODAL | Gtk.DialogFlags.DESTROY_WITH_PARENT,
            (Gtk.STOCK_CANCEL, Gtk.ResponseType.REJECT, "Add", Gtk.ResponseType.ACCEPT),
        )
        self.dividend = dividend
        vbox = self.get_content_area()
        table = Gtk.Table()
        vbox.pack_start(table, True, True, 0)

        table.attach(Gtk.Label(label=_("Position")), 0, 1, 0, 1)
        if dividend is not None:
            position = dividend.position
        self.pos_selector = dialogs.PosSelector(pf, position)
        self.pos_selector.connect("changed", self.on_changed_pos)
        table.attach(self.pos_selector, 1, 2, 0, 1)
        self.selected_pos = position

        table.attach(Gtk.Label(label=_("Amount")), 0, 1, 1, 2)
        self.value_entry = Gtk.SpinButton(
            adjustment=Gtk.Adjustment(lower=0, upper=100000, step_increment=0.1, value=1.0), digits=2
        )
        self.value_entry.connect("value-changed", self.on_change)
        table.attach(self.value_entry, 1, 2, 1, 2)

        table.attach(Gtk.Label(label=_("Transaction costs")), 0, 1, 2, 3)
        self.tacosts_entry = Gtk.SpinButton(
            adjustment=Gtk.Adjustment(lower=0, upper=100000, step_increment=0.1, value=0.0), digits=2
        )
        self.tacosts_entry.connect("value-changed", self.on_change)
        table.attach(self.tacosts_entry, 1, 2, 2, 3)

        table.attach(Gtk.Label(label=_("Total")), 0, 1, 3, 4)
        self.total = Gtk.Label()
        self.total.set_markup("<b>" + gui_utils.get_currency_format_from_float(0.0) + "</b>")
        table.attach(self.total, 1, 2, 3, 4, xoptions=Gtk.AttachOptions.SHRINK, yoptions=Gtk.AttachOptions.SHRINK)

        self.calendar = Gtk.Calendar()
        table.attach(self.calendar, 0, 2, 4, 5)

        if date is not None:
            self.calendar.select_month(date.month - 1, date.year)
            self.calendar.select_day(date.day)
        if price is not None:
            self.value_entry.set_value(price)
            self.on_change()

        if dividend is not None:
            self.calendar.select_month(dividend.date.month - 1, dividend.date.year)
            self.calendar.select_day(dividend.date.day)
            self.value_entry.set_value(dividend.price)
            self.tacosts_entry.set_value(dividend.cost)
            self.on_change()

        self.set_response_sensitive(Gtk.ResponseType.ACCEPT, self.selected_pos is not None)
        self.show_all()
        response = self.run()
        self.process_result(response)
        self.destroy()
Example #10
0
 def on_change(self, widget=None):
     total = self.value_entry.get_value() - self.tacosts_entry.get_value()
     self.total.set_markup("<b>" + gui_utils.get_currency_format_from_float(total) + "</b>")
Example #11
0
 def insert_account(self, account):
     new_iter = self.tree.get_model().append(self.accounts_iter, [account, 'account', account.name, gui_utils.get_currency_format_from_float(account.balance), True, True])
     account.connect("balance_changed", self.on_balance_changed, new_iter)
     return new_iter
Example #12
0
 def on_container_updated(self, item, iterator):
     self.tree.get_model()[iterator][3] = gui_utils.get_currency_format_from_float(item.get_current_value())
Example #13
0
 def on_balance_changed(self, item, balance, iterator):
     self.tree.get_model()[iterator][3] = gui_utils.get_currency_format_from_float(balance)
Example #14
0
def start_price_markup(column, cell, model, iterator, column_id):
    pos = model.get_value(iterator, 0)
    markup = "%s\n<small>%s</small>" % (gui_utils.get_currency_format_from_float(model.get_value(iterator, column_id)), gui_utils.get_date_string(pos.date))
    cell.set_property('markup', markup)
Example #15
0
 def get_info(self):
     return [('# dividends', self.portfolio.get_dividends_count()),
             ('Sum', gui_utils.get_currency_format_from_float(self.portfolio.get_dividends_sum())),
             ('Last dividend', gui_utils.get_date_string(self.portfolio.date_of_last_dividend))]