Changeset beb4f8


Ignore:
Timestamp:
02/23/2017 12:30:10 AM (8 years ago)
Author:
Calum Lind <calumlind+deluge@gmail.com>
Branches:
2.0.x, develop, master
Children:
52a85c
Parents:
3b1eeb0
git-author:
Calum Lind <calumlind+deluge@gmail.com> (02/22/2017 12:53:20 PM)
git-committer:
Calum Lind <calumlind+deluge@gmail.com> (02/23/2017 12:30:10 AM)
Message:

[Common] Rename decode_string to decode_bytes

  • Switch to using Python 3 naming convention where str now refers to unicode and bytes are encoded strings.
  • Cleanup docs and code
  • Also rename convert_to_utf8 to utf8_encode_structure to clarify functionality.
Location:
deluge
Files:
14 edited

Legend:

Unmodified
Added
Removed

  • deluge/common.py

    r3b1eeb0 rbeb4f8  
    778778    else:
    779779        try:
    780             return ipaddress.IPv6Address(decode_string(ip))
     780            return ipaddress.IPv6Address(decode_bytes(ip))
    781781        except ipaddress.AddressValueError:
    782782            pass
    … …  
    785785
    786786
    787 def decode_string(s, encoding='utf8'):
    788     """
    789     Decodes a string and return unicode. If it cannot decode using
    790     `:param:encoding` then it will try latin1, and if that fails,
    791     try to detect the string encoding. If that fails, decode with
    792     ignore.
    793 
    794     :param s: string to decode
    795     :type s: string
    796     :param encoding: the encoding to use in the decoding
    797     :type encoding: string
    798     :returns: s converted to unicode
    799     :rtype: unicode
    800 
    801     """
    802     if not s:
     787def decode_bytes(byte_str, encoding='utf8'):
     788    """Decodes a byte string and return unicode.
     789
     790    If it cannot decode using `encoding` then it will try latin1,
     791    and if that fails, try to detect the string encoding. If that fails,
     792    decode with ignore.
     793
     794    Args:
     795        byte_str (bytes): The byte string to decode.
     796        encoding (str): The encoding to try first when decoding.
     797
     798    Returns:
     799        str: A unicode string.
     800
     801    """
     802    if not byte_str:
    803803        return ''
    804     elif isinstance(s, unicode):
    805         return s
     804    elif isinstance(byte_str, unicode):
     805        return byte_str
    806806
    807807    encodings = [lambda: ('utf8', 'strict'),
    808808                 lambda: ('iso-8859-1', 'strict'),
    809                  lambda: (chardet.detect(s)['encoding'], 'strict'),
     809                 lambda: (chardet.detect(byte_str)['encoding'], 'strict'),
    810810                 lambda: (encoding, 'ignore')]
    811811
    … …  
    815815    for l in encodings:
    816816        try:
    817             return s.decode(*l())
     817            return byte_str.decode(*l())
    818818        except UnicodeDecodeError:
    819819            pass
    … …  
    834834    """
    835835    if isinstance(s, str):
    836         s = decode_string(s, encoding).encode('utf8')
     836        s = decode_bytes(s, encoding).encode('utf8')
    837837    elif isinstance(s, unicode):
    838838        s = s.encode('utf8')
    … …  
    840840
    841841
    842 def convert_to_utf8(data):
     842def utf8_encode_structure(data):
    843843    """Recursively convert all unicode keys and values in a data structure to utf8.
    844844
    … …  
    852852
    853853    """
    854 
    855854    if isinstance(data, unicode):
    856855        return data.encode('utf8')
    857856    elif isinstance(data, (list, tuple)):
    858         return type(data)(map(convert_to_utf8, data))
     857        return type(data)(map(utf8_encode_structure, data))
    859858    elif isinstance(data, dict):
    860         return dict(map(convert_to_utf8, data.items()))
     859        return dict(map(utf8_encode_structure, data.items()))
    861860    else:
    862861        return data

  • deluge/config.py

    r3b1eeb0 rbeb4f8  
    4848import shutil
    4949
    50 from deluge.common import decode_string, get_default_config_dir, utf8_encoded
     50from deluge.common import decode_bytes, get_default_config_dir, utf8_encoded
    5151
    5252log = logging.getLogger(__name__)
    … …  
    246246        """
    247247        if isinstance(self.__config[key], basestring):
    248             return decode_string(self.__config[key])
     248            return decode_bytes(self.__config[key])
    249249        else:
    250250            return self.__config[key]

  • deluge/core/alertmanager.py

    r3b1eeb0 rbeb4f8  
    2424import deluge.component as component
    2525from deluge._libtorrent import lt
    26 from deluge.common import decode_string
     26from deluge.common import decode_bytes
    2727
    2828log = logging.getLogger(__name__)
    … …  
    113113            # Display the alert message
    114114            if log.isEnabledFor(logging.DEBUG):
    115                 log.debug('%s: %s', alert_type, decode_string(alert.message()))
     115                log.debug('%s: %s', alert_type, decode_bytes(alert.message()))
    116116            # Call any handlers for this alert type
    117117            if alert_type in self.handlers:

  • deluge/core/torrent.py

    r3b1eeb0 rbeb4f8  
    2727import deluge.component as component
    2828from deluge._libtorrent import lt
    29 from deluge.common import decode_string, utf8_encoded
     29from deluge.common import decode_bytes, utf8_encoded
    3030from deluge.configmanager import ConfigManager, get_config_dir
    3131from deluge.core.authmanager import AUTH_LEVEL_ADMIN
    … …  
    613613            # auto-manage status will be reverted upon resuming.
    614614            self.handle.auto_managed(False)
    615             self.set_status_message(decode_string(status_error))
     615            self.set_status_message(decode_bytes(status_error))
    616616        elif status.moving_storage:
    617617            self.state = 'Moving'
    … …  
    762762                continue
    763763
    764             client = decode_string(peer.client)
     764            client = decode_bytes(peer.client)
    765765
    766766            try:
    … …  
    869869            handle_name = self.handle.name()
    870870            if handle_name:
    871                 name = decode_string(handle_name)
     871                name = decode_bytes(handle_name)
    872872            else:
    873873                name = self.torrent_id
    … …  
    10141014            'tracker_status': lambda: self.tracker_status,
    10151015            'upload_payload_rate': lambda: self.status.upload_payload_rate,
    1016             'comment': lambda: decode_string(self.torrent_info.comment()) if self.has_metadata else '',
     1016            'comment': lambda: decode_bytes(self.torrent_info.comment()) if self.has_metadata else '',
    10171017            'num_files': lambda: self.torrent_info.num_files() if self.has_metadata else 0,
    10181018            'num_pieces': lambda: self.torrent_info.num_pieces() if self.has_metadata else 0,
    … …  
    11151115
    11161116        """
    1117         dest = decode_string(dest)
     1117        dest = decode_bytes(dest)
    11181118
    11191119        if not os.path.exists(dest):
    … …  
    12541254        for index, filename in filenames:
    12551255            # Make sure filename is a unicode object
    1256             filename = sanitize_filepath(decode_string(filename))
     1256            filename = sanitize_filepath(decode_bytes(filename))
    12571257            # libtorrent needs unicode object if wstrings are enabled, utf8 bytestring otherwise
    12581258            try:

  • deluge/core/torrentmanager.py

    r3b1eeb0 rbeb4f8  
    2525import deluge.component as component
    2626from deluge._libtorrent import lt
    27 from deluge.common import decode_string, get_magnet_info, utf8_encoded
     27from deluge.common import decode_bytes, get_magnet_info, utf8_encoded
    2828from deluge.configmanager import ConfigManager, get_config_dir
    2929from deluge.core.authmanager import AUTH_LEVEL_ADMIN
    … …  
    359359        if options['mapped_files'] and torrent_info:
    360360            for index, fname in options['mapped_files'].items():
    361                 fname = sanitize_filepath(decode_string(fname))
     361                fname = sanitize_filepath(decode_bytes(fname))
    362362                if log.isEnabledFor(logging.DEBUG):
    363363                    log.debug('renaming file index %s to %s', index, fname)
    … …  
    10461046            return
    10471047        # Set the tracker status for the torrent
    1048         torrent.set_tracker_status('Warning: %s' % decode_string(alert.message()))
     1048        torrent.set_tracker_status('Warning: %s' % decode_bytes(alert.message()))
    10491049
    10501050    def on_alert_tracker_error(self, alert):
    … …  
    10551055            return
    10561056
    1057         error_message = decode_string(alert.error_message())
     1057        error_message = decode_bytes(alert.error_message())
    10581058        if not error_message:
    10591059            error_message = alert.error.message()
    1060         log.debug('Tracker Error Alert: %s [%s]', decode_string(alert.message()), error_message)
     1060        log.debug('Tracker Error Alert: %s [%s]', decode_bytes(alert.message()), error_message)
    10611061        torrent.set_tracker_status('Error: ' + error_message)
    10621062
    … …  
    10861086            return
    10871087
    1088         log.warning('on_alert_storage_moved_failed: %s', decode_string(alert.message()))
     1088        log.warning('on_alert_storage_moved_failed: %s', decode_bytes(alert.message()))
    10891089        # Set an Error message and pause the torrent
    1090         alert_msg = decode_string(alert.message()).split(':', 1)[1].strip()
     1090        alert_msg = decode_bytes(alert.message()).split(':', 1)[1].strip()
    10911091        torrent.force_error_state('Failed to move download folder: %s' % alert_msg)
    10921092
    … …  
    11461146
    11471147        if torrent_id in self.waiting_on_resume_data:
    1148             self.waiting_on_resume_data[torrent_id].errback(Exception(decode_string(alert.message())))
     1148            self.waiting_on_resume_data[torrent_id].errback(Exception(decode_bytes(alert.message())))
    11491149
    11501150    def on_alert_fastresume_rejected(self, alert):
    … …  
    11561156            return
    11571157
    1158         alert_msg = decode_string(alert.message())
     1158        alert_msg = decode_bytes(alert.message())
    11591159        log.error('on_alert_fastresume_rejected: %s', alert_msg)
    11601160        if alert.error.value() == 134:
    … …  
    11801180            return
    11811181
    1182         new_name = decode_string(alert.new_name)
     1182        new_name = decode_bytes(alert.new_name)
    11831183        log.debug('index: %s name: %s', alert.index, new_name)
    11841184
    … …  
    12521252        """
    12531253
    1254         external_ip = decode_string(alert.message()).split(' ')[-1]
     1254        external_ip = decode_bytes(alert.message()).split(' ')[-1]
    12551255        log.info('on_alert_external_ip: %s', external_ip)
    12561256        component.get('EventManager').emit(ExternalIPEvent(external_ip))
    … …  
    12581258    def on_alert_performance(self, alert):
    12591259        """Alert handler for libtorrent performance_alert"""
    1260         log.warning('on_alert_performance: %s, %s', decode_string(alert.message()), alert.warning_code)
     1260        log.warning('on_alert_performance: %s, %s', decode_bytes(alert.message()), alert.warning_code)
    12611261        if alert.warning_code == lt.performance_warning_t.send_buffer_watermark_too_low:
    12621262            max_send_buffer_watermark = 3 * 1024 * 1024  # 3MiB

  • deluge/httpdownloader.py

    r3b1eeb0 rbeb4f8  
    2020from twisted.web.error import PageRedirect
    2121
    22 from deluge.common import convert_to_utf8, get_version
     22from deluge.common import get_version, utf8_encode_structure
    2323
    2424log = logging.getLogger(__name__)
    … …  
    176176    url = url.encode('utf8')
    177177    filename = filename.encode('utf8')
    178     headers = convert_to_utf8(headers) if headers else headers
     178    headers = utf8_encode_structure(headers) if headers else headers
    179179    factory = HTTPDownloader(url, filename, callback, headers, force_filename, allow_compression)
    180180

  • deluge/maketorrent.py

    r3b1eeb0 rbeb4f8  
    1515
    1616from deluge.bencode import bencode
    17 from deluge.common import convert_to_utf8, get_path_size
     17from deluge.common import get_path_size, utf8_encode_structure
    1818
    1919
    … …  
    195195        # Write out the torrent file
    196196        with open(torrent_path, 'wb') as _file:
    197             _file.write(bencode(convert_to_utf8(torrent)))
     197            _file.write(bencode(utf8_encode_structure(torrent)))
    198198
    199199    def get_data_path(self):

  • deluge/tests/test_torrent.py

    r3b1eeb0 rbeb4f8  
    1919import deluge.tests.common as common
    2020from deluge._libtorrent import lt
    21 from deluge.common import convert_to_utf8
     21from deluge.common import utf8_encode_structure
    2222from deluge.core.core import Core
    2323from deluge.core.rpcserver import RPCServer
    … …  
    181181        with open(filename) as _file:
    182182            filedump = _file.read()
    183         resume_data = convert_to_utf8(resume_data)
     183        resume_data = utf8_encode_structure(resume_data)
    184184        torrent_id = yield self.core.torrentmanager.add(state=torrent_state, filedump=filedump,
    185185                                                        resume_data=lt.bencode(resume_data))

  • deluge/tests/test_ui_entry.py

    r3b1eeb0 rbeb4f8  
    2525import deluge.ui.console.main
    2626import deluge.ui.web.server
    27 from deluge.common import convert_to_utf8
     27from deluge.common import utf8_encode_structure
    2828from deluge.ui import ui_entry
    2929from deluge.ui.web.server import DelugeWeb
    … …  
    169169        self.var['cmd_name'] = 'deluge gtk'
    170170        self.var['start_cmd'] = ui_entry.start_ui
    171         self.var['sys_arg_cmd'] = convert_to_utf8(['./deluge', 'gtk'])
     171        self.var['sys_arg_cmd'] = utf8_encode_structure(['./deluge', 'gtk'])
    172172
    173173    def set_up(self):

  • deluge/tests/test_webserver.py

    r3b1eeb0 rbeb4f8  
    1919from twisted.web.http_headers import Headers
    2020
    21 from deluge.common import convert_to_utf8
     21from deluge.common import utf8_encode_structure
    2222
    2323from . import common
    … …  
    4747        url = 'http://127.0.0.1:%s/json' % self.webserver_listen_port
    4848
    49         d = yield agent.request(b'POST', url.encode('utf-8'), Headers(convert_to_utf8(headers)),
     49        d = yield agent.request(b'POST', url.encode('utf-8'), Headers(utf8_encode_structure(headers)),
    5050                                FileBodyProducer(StringIO(input_file.encode('utf-8'))))
    5151        try:

  • deluge/ui/common.py

    r3b1eeb0 rbeb4f8  
    2121import deluge.configmanager
    2222from deluge import bencode
    23 from deluge.common import decode_string
     23from deluge.common import decode_bytes
    2424
    2525log = logging.getLogger(__name__)
    … …  
    167167        # using the encoding found.
    168168        if 'name.utf-8' in self.__m_metadata['info']:
    169             self.__m_name = decode_string(self.__m_metadata['info']['name.utf-8'])
     169            self.__m_name = decode_bytes(self.__m_metadata['info']['name.utf-8'])
    170170        else:
    171             self.__m_name = decode_string(self.__m_metadata['info']['name'], self.encoding)
     171            self.__m_name = decode_bytes(self.__m_metadata['info']['name'], self.encoding)
    172172
    173173        # Get list of files from torrent info
    … …  
    181181            for index, f in enumerate(self.__m_metadata['info']['files']):
    182182                if 'path.utf-8' in f:
    183                     path = decode_string(os.path.join(prefix, *f['path.utf-8']))
     183                    path = decode_bytes(os.path.join(prefix, *f['path.utf-8']))
    184184                    del f['path.utf-8']
    185185                else:
    186                     path = os.path.join(prefix, decode_string(os.path.join(*f['path']), self.encoding))
     186                    path = os.path.join(prefix, decode_bytes(os.path.join(*f['path']), self.encoding))
    187187                f['path'] = path
    188188                f['index'] = index

  • deluge/ui/console/modes/addtorrents.py

    r3b1eeb0 rbeb4f8  
    182182
    183183        for row in self.raw_rows:
    184             filename = deluge.common.decode_string(row[0])
     184            filename = deluge.common.decode_bytes(row[0])
    185185            size = row[1]
    186186            time = row[2]

  • deluge/ui/gtkui/ipcinterface.py

    r3b1eeb0 rbeb4f8  
    2424
    2525import deluge.component as component
    26 from deluge.common import decode_string, is_magnet, is_url, windows_check
     26from deluge.common import decode_bytes, is_magnet, is_url, windows_check
    2727from deluge.configmanager import ConfigManager, get_config_dir
    2828from deluge.ui.client import client
    … …  
    207207            if urlparse(arg).scheme == 'file':
    208208                arg = url2pathname(urlparse(arg).path)
    209             path = os.path.abspath(decode_string(arg))
     209            path = os.path.abspath(decode_bytes(arg))
    210210
    211211            if not os.path.exists(path):

  • deluge/ui/gtkui/preferences.py

    r3b1eeb0 rbeb4f8  
    911911
    912912        if response == gtk.RESPONSE_OK:
    913             filepath = deluge.common.decode_string(chooser.get_filename())
     913            filepath = deluge.common.decode_bytes(chooser.get_filename())
    914914        else:
    915915            chooser.destroy()
Note: See TracChangeset for help on using the changeset viewer.