maketorrent.py

bittorrent source by python. please enjoy

        else:
            announce = self.dht_nodes.GetValue()
        return announce


    def make(self, widget):
        file_name = self.get_file()
        piece_size_exponent = self.get_piece_size_exponent()
        announce = self.get_announce()
        title = self.title.GetValue()
        comment = self.comment_text.GetValue()

        if self.config['use_tracker']:
            self.add_tracker(announce)
        errored = False
        if not errored:
            d = ProgressDialog(self, [file_name,], announce,
                               piece_size_exponent, title, comment,
                               self.config)
            d.main()


    def check_buttons(self, *widgets):
        file_name = self.get_file()
        tracker = self.announce_entry.GetValue()
        if file_name not in (None, '') and os.path.exists(file_name):
            if self.config['use_tracker']:
                if len(tracker) >= len('http://x.cc'):
                    self.makebutton.Enable(True)
                else:
                    self.makebutton.Enable(False)
            else:
                self.makebutton.Enable(True)
        else:
            self.makebutton.Enable(False)


    def save_config(self):
        def error_callback(error, string): print string
        configfile.save_global_config(self.config, 'maketorrent', error_callback, ui_options)


    def add_tracker(self, tracker_name):
        try:
            self.tracker_list.pop(self.tracker_list.index(tracker_name))
        except ValueError:
            pass
        self.tracker_list[0:0] = [tracker_name,]

        self.config['tracker_list'] = ','.join(self.tracker_list)

        if not self.announce_entry.IsEmpty():
            self.announce_entry.Clear()
        for t in self.tracker_list:
            self.announce_entry.Append(t)



class NodeList(Grid):
    def __init__(self, parent, nodelist):
        Grid.__init__(self, parent, style=wx.WANTS_CHARS)

        self.CreateGrid( 0, 2, wx.grid.Grid.SelectRows)
        self.SetColLabelValue(0, _("Host"))
        self.SetColLabelValue(1, _("Port"))

        self.SetColRenderer(1, wx.grid.GridCellNumberRenderer())
        self.SetColEditor(1, wx.grid.GridCellNumberEditor(0, 65535))

        self.SetColLabelSize(self.GetTextExtent("l")[1]+4)
        self.SetRowLabelSize(1)
        self.SetSize((1000,1000))

        self.storing = False
        self.Bind(wx.grid.EVT_GRID_CMD_CELL_CHANGE, self.store_value)

        self.append_node(('router.bittorrent.com', '65536'))

        for i, e in enumerate(nodelist.split(',')):
            host, port = e.split(':')
            self.append_node((host,port))

        self.append_node(('',''))

    def append_node(self, (host, port)):
        self.InsertRows(self.GetNumberRows(), 1)
        self.SetCellValue(self.GetNumberRows()-1, 0, host)
        self.SetCellValue(self.GetNumberRows()-1, 1, port)
        self.AutoSizeColumn(0)
        self.SetColSize(1, self.GetTextExtent('65536')[0] * 2)
        ###self.AutoSize()

    def store_value(self, event):
        if self.storing:
            return
        self.storing = True
        table = self.GetTable()
        row = event.GetRow()
        col = event.GetCol()
        value = table.GetValue(row, col)
        if col == 0:
            self.store_host_value(row, value)
        elif col == 1:
            self.store_port_value(row, value)
        self.storing = False

    def store_host_value(self, row, value):
        parts = value.split('.')
        if value != '':
            for p in parts:
                if not p.isalnum():
                    return
                try:
                    value = value.encode('idna')
                except UnicodeError:
                    return
        self.check_row(row)

    def store_port_value(self, row, value):
        if value != '':
            try:
                v = int(value)
                if v > 65535:
                    value = 65535
                if v < 0:
                    value = 0
            except ValueError:
                return # return on non-integer values
        self.check_row(row)

    def check_row(self, row):
        # called after editing to see whether we should add a new
        # blank row, or remove the now blank currently edited row.
        table = self.GetTable()
        host_value = table.GetValue(row, 0)
        port_value = table.GetValue(row, 1)
        if (host_value and
            port_value and
            int(row) == self.GetNumberRows()-1):
            self.append_node(('',''))
        elif (host_value == '' and
              (not port_value or int(port_value) == 0) and
              int(row) != self.GetNumberRows()-1):
            self.DeleteRows(row, 1)

    def get_nodes(self):
        retlist = []
        id = -1
        table = self.GetTable()
        for row in xrange(self.GetNumberRows()):
            host = table.GetValue(row, 0)
            port = table.GetValue(row, 1)
            if host != '' and port != '' and port != 0:
                retlist.append((host,port))
        return retlist

    def GetValue(self):
        nodelist = self.get_nodes()
        return ','.join(['%s:%s'%node for node in nodelist])



def deunicode(s):
    try:
        s = s.decode('utf8', 'replace').encode('utf8')
    except:
        pass
    return s



class ProgressDialog(BTDialog):

    def __init__(self, parent, file_list, announce, piece_length, title,
                 comment, config):
        BTDialog.__init__(self, parent=parent, size=(400,-1))
        self.SetTitle(_("Building torrents..."))
        self.file_list = file_list
        self.announce = deunicode(announce)
        self.piece_length = piece_length
        self.title = deunicode(title)
        self.comment = deunicode(comment)
        self.config = config

        self.flag = Event() # ???

        self.vbox = VSizer()
        self.label = wx.StaticText(self, label=_("Checking file sizes..."))
        #self.label.set_line_wrap(True)

        self.vbox.AddFirst(self.label, flag=wx.ALIGN_LEFT)

        self.progressbar = wx.Gauge(self, range = 1000, size=(400, 25), style = wx.GA_SMOOTH)
        self.vbox.Add(self.progressbar, flag=wx.GROW)

        self.vbox.Add(wx.StaticLine(self, style=wx.LI_HORIZONTAL), flag=wx.GROW)

        self.action_area = wx.BoxSizer(wx.HORIZONTAL)

        self.cancelbutton = wx.Button(self, label=_("&Abort"))
        self.cancelbutton.Bind(wx.EVT_BUTTON, self.cancel)
        self.action_area.Add(self.cancelbutton,
                             flag=wx.LEFT|wx.RIGHT|wx.BOTTOM, border=SPACING)

        self.done_button = wx.Button(self, label=_("&Ok"))
        self.done_button.Bind(wx.EVT_BUTTON, self.cancel)
        self.action_area.Add(self.done_button,
                             flag=wx.LEFT|wx.RIGHT|wx.BOTTOM, border=SPACING)

        self.action_area.Show(self.done_button, False)

        self.seed_button = wx.Button(self, label=_("&Start seeding"))
        self.seed_button.Bind(wx.EVT_BUTTON, self.seed)
        self.action_area.Add(self.seed_button,
                             flag=wx.RIGHT|wx.BOTTOM, border=SPACING)

        self.action_area.Show(self.seed_button, False)

        self.Bind(wx.EVT_CLOSE, self.cancel)

        self.vbox.Add(self.action_area, flag=wx.ALIGN_RIGHT,
                      border=0)

        self.SetSizerAndFit(self.vbox)
        self.Show()


    def main(self):
        self.complete()


    def seed(self, widget=None):
        for f in self.file_list:
            btspawn('bittorrent', f+EXTENSION, '--publish', f)
        self.cancel()


    def cancel(self, widget=None):
        self.flag.set()
        self.Destroy()


    def set_progress_value(self, value):
        self.progressbar.SetValue(value * 1000)
        self._update_gui()


    def set_file(self, filename):
        self.label.SetLabel(_("building: ") + filename + EXTENSION)
        self.vbox.Layout()
        self.Fit()
        self._update_gui()


    def _update_gui(self):
        wx.GetApp().Yield(True)


    def complete(self):
        try:
            make_meta_files(self.announce.encode('utf8'),
                            self.file_list,
                            flag=self.flag,
                            progressfunc=self.set_progress_value,
                            filefunc=self.set_file,
                            piece_len_pow2=self.piece_length,
                            title=self.title,
                            comment=self.comment,
                            use_tracker=self.config['use_tracker'],
                            data_dir=self.config['data_dir'],
                            )
            if not self.flag.isSet():
                self.SetTitle(_("Done."))
                self.label.SetLabel(_("Done building torrents."))
                self.set_progress_value(1)
                self.action_area.Show(self.cancelbutton, False)
                self.action_area.Show(self.seed_button, True)
                self.action_area.Show(self.done_button, True)
                self.vbox.Layout()
        except (OSError, IOError), e:
            self.SetTitle(_("Error!"))
            self.label.SetLabel(_("Error building torrents: ") + unicode(e.args[0]))




def run(argv=[]):
    config, args = configfile.parse_configuration_and_args(defaults,
                                    'maketorrent', argv, 0, None)
    # BUG: hack to make verbose mode be the default
    config['verbose'] = not config['verbose']
    MainLoop(config)



class MainLoop(BTApp):

    def __init__(self, config):
        self.config = config
        self.main_window = None
        BTApp.__init__(self, 0)
        self.MainLoop()


    def OnInit(self):
        BTApp.OnInit(self)
        self.main_window = MainWindow(self.config)
        return True




if __name__ == '__main__':
    run(argv=sys.argv[1:])