Huge refactor, too many changes to really address individually

speedtest_cli.py

@@ -15,7 +15,7 @@
 #    License for the specific language governing permissions and limitations
 #    under the License.
 
-__version__ = '0.2.5'
+__version__ = '1.0.0'
 
 # Some global variables we use
 source = None
@@ -73,8 +73,10 @@ except ImportError:
 
 try:
     from argparse import ArgumentParser as ArgParser
+    PARSER_TYPE_INT = int
 except ImportError:
     from optparse import OptionParser as ArgParser
+    PARSER_TYPE_INT = 'int'
 
 try:
     import builtins
@@ -160,7 +162,25 @@ def distance(origin, destination):
     return d
 
 
-class FileGetter(threading.Thread):
+def get_attributes_by_tag_name(dom, tagName):
+    """Retrieve an attribute from an XML document and return it in a
+    consistent format
+
+    Only used with xml.dom.minidom, which is likely only to be used
+    with python versions older than 2.5
+    """
+    elem = dom.getElementsByTagName(tagName)[0]
+    return dict(list(elem.attributes.items()))
+
+
+def print_dots(current, total):
+    sys.stdout.write('.')
+    if current + 1 == total:
+        sys.stdout.write('\n')
+    sys.stdout.flush()
+
+
+class Downloader(threading.Thread):
     """Thread class for retrieving a URL"""
 
     def __init__(self, url, start):
@@ -174,54 +194,18 @@ class FileGetter(threading.Thread):
         try:
             if (time.time() - self.starttime) <= 10:
                 f = urlopen(self.url)
-                while 1 and not shutdown_event.isSet():
+                while (1 and not shutdown_event.isSet() and
+                        (time.time() - self.starttime) <= 10):
                     self.result.append(len(f.read(10240)))
                     if self.result[-1] == 0:
                         break
                 f.close()
-        except IOError:
+        except:
             pass
 
 
-def download_speed(files, quiet=False):
+class Uploader(threading.Thread):
-    """Function to launch FileGetter threads and calculate download speeds"""
+    """Thread class for uploading to a URL"""
-
-    start = time.time()
-
-    def producer(q, files):
-        for file in files:
-            thread = FileGetter(file, start)
-            thread.start()
-            q.put(thread, True)
-            if not quiet and not shutdown_event.isSet():
-                sys.stdout.write('.')
-                sys.stdout.flush()
-
-    finished = []
-
-    def consumer(q, total_files):
-        while len(finished) < total_files:
-            thread = q.get(True)
-            while thread.isAlive():
-                thread.join(timeout=0.1)
-            finished.append(sum(thread.result))
-            del thread
-
-    q = Queue(6)
-    prod_thread = threading.Thread(target=producer, args=(q, files))
-    cons_thread = threading.Thread(target=consumer, args=(q, len(files)))
-    start = time.time()
-    prod_thread.start()
-    cons_thread.start()
-    while prod_thread.isAlive():
-        prod_thread.join(timeout=0.1)
-    while cons_thread.isAlive():
-        cons_thread.join(timeout=0.1)
-    return (sum(finished) / (time.time() - start))
-
-
-class FilePutter(threading.Thread):
-    """Thread class for putting a URL"""
 
     def __init__(self, url, start, size):
         self.url = url
@@ -243,64 +227,218 @@ class FilePutter(threading.Thread):
                 self.result = len(self.data)
             else:
                 self.result = 0
-        except IOError:
+        except:
             self.result = 0
 
 
-def upload_speed(url, sizes, quiet=False):
+class SpeedtestException(Exception):
-    """Function to launch FilePutter threads and calculate upload speeds"""
+    """Base exception for this module"""
-
+    pass
-    start = time.time()
-
-    def producer(q, sizes):
-        for size in sizes:
-            thread = FilePutter(url, start, size)
-            thread.start()
-            q.put(thread, True)
-            if not quiet and not shutdown_event.isSet():
-                sys.stdout.write('.')
-                sys.stdout.flush()
-
-    finished = []
-
-    def consumer(q, total_sizes):
-        while len(finished) < total_sizes:
-            thread = q.get(True)
-            while thread.isAlive():
-                thread.join(timeout=0.1)
-            finished.append(thread.result)
-            del thread
-
-    q = Queue(6)
-    prod_thread = threading.Thread(target=producer, args=(q, sizes))
-    cons_thread = threading.Thread(target=consumer, args=(q, len(sizes)))
-    start = time.time()
-    prod_thread.start()
-    cons_thread.start()
-    while prod_thread.isAlive():
-        prod_thread.join(timeout=0.1)
-    while cons_thread.isAlive():
-        cons_thread.join(timeout=0.1)
-    return (sum(finished) / (time.time() - start))
 
 
-def get_attributes_by_tag_name(dom, tagName):
+class ConfigRetrievalError(SpeedtestException):
-    """Retrieve an attribute from an XML document and return it in a
+    """Could not retrieve config.php"""
-    consistent format
+    pass
 
-    Only used with xml.dom.minidom, which is likely only to be used
+
-    with python versions older than 2.5
+class ServersRetrievalError(SpeedtestException):
+    """Could not retrieve speedtest-servers.php"""
+    pass
+
+
+class InvalidServerIDType(SpeedtestException):
+    """Server ID used for filtering was not an integer"""
+    pass
+
+
+class NoMatchedServers(SpeedtestException):
+    """No servers matched when filtering"""
+    pass
+
+
+class SpeedtestMiniConnectFailure(SpeedtestException):
+    """Could not connect to the provided speedtest mini server"""
+    pass
+
+
+class InvalidSpeedtestMiniServer(SpeedtestException):
+    """Server provided as a speedtest mini server does not actually appear
+    to be a speedtest mini server
     """
-    elem = dom.getElementsByTagName(tagName)[0]
+    pass
-    return dict(list(elem.attributes.items()))
 
 
-def get_config():
+class ShareResultsConnectFailure(SpeedtestException):
+    """Could not connect to speedtest.net API to POST results"""
+    pass
+
+
+class ShareResultsSubmitFailure(SpeedtestException):
+    """Unable to successfully POST results to speedtest.net API after
+    connection
+    """
+    pass
+
+
+class SpeedtestResults(object):
+    """Class for holding the results of a speedtest, including:
+
+    Download speed
+    Upload speed
+    Ping/Latency to test server
+    Data about server that the test was run against
+
+    Additionally this class can return a result data as a dictionary or CSV,
+    as well as submit a POST of the result data to the speedtest.net API
+    to get a share results image link.
+    """
+
+    def __init__(self, download=0, upload=0, ping=0, server=dict()):
+        self._download = download
+        self._upload = upload
+        self._ping = ping
+        self._server = server
+        self._share = None
+
+    @property
+    def download(self):
+        """Get upload speed result"""
+        return self._download
+
+    @download.setter
+    def download(self, value):
+        """Setter for download speed value"""
+        self._download = value
+
+    @property
+    def upload(self):
+        """Get upload speed result"""
+        return self._upload
+
+    @upload.setter
+    def upload(self, value):
+        """Setter for upload speed value"""
+        self._upload = value
+
+    @property
+    def ping(self):
+        """Get ping/latency value"""
+        return self._ping
+
+    @ping.setter
+    def ping(self, value):
+        """Setter for ping/latency value"""
+        self._ping = value
+
+    @property
+    def server(self):
+        """Get data for server used in the test"""
+        return self._server
+
+    @server.setter
+    def server(self, value):
+        """Setter for server data"""
+        self._server = value
+
+    def dict(self):
+        """Return dictionary of result data"""
+
+        return dict(download=self.download,
+                    upload=self.upload,
+                    ping=self.ping,
+                    server=self.server['id'])
+
+    def csv(self):
+        """Return data in CSV format in the order of:
+        Speedtest.net Server ID, Latency/Ping, Download Speed, Upload Speed
+
+        """
+
+        return '%(server)s,%(ping)s,%(download)s,%(upload)s' % self.dict()
+
+    def share(self):
+        """POST data to the speedtest.net API to obtain a share results
+        link
+        """
+
+        if self._share:
+            return self._share
+
+        download = int(round((self.download / 1000) * 8, 0))
+        ping = int(round(self.ping, 0))
+        upload = int(round((self.upload / 1000) * 8, 0))
+
+        # Build the request to send results back to speedtest.net
+        # We use a list instead of a dict because the API expects parameters
+        # in a certain order
+        api_data = [
+            'download=%s' % download,
+            'ping=%s' % ping,
+            'upload=%s' % upload,
+            'promo=',
+            'startmode=%s' % 'pingselect',
+            'recommendedserverid=%s' % self.server['id'],
+            'accuracy=%s' % 1,
+            'serverid=%s' % self.server['id'],
+            'hash=%s' % md5(('%s-%s-%s-%s' %
+                             (ping, upload, download, '297aae72'))
+                            .encode()).hexdigest()]
+
+        req = Request('http://www.speedtest.net/api/api.php',
+                      data='&'.join(api_data).encode())
+        req.add_header('Referer', 'http://c.speedtest.net/flash/speedtest.swf')
+        try:
+            f = urlopen(req)
+        except (URLError, HTTPError):
+            raise ShareResultsConnectFailure
+
+        response = f.read()
+        code = f.code
+        f.close()
+
+        if int(code) != 200:
+            raise ShareResultsSubmitFailure('Could not submit results to '
+                                            'speedtest.net')
+
+        qsargs = parse_qs(response.decode())
+        resultid = qsargs.get('resultid')
+        if not resultid or len(resultid) != 1:
+            raise ShareResultsSubmitFailure('Could not submit results to '
+                                            'speedtest.net')
+
+        self._share = 'http://www.speedtest.net/result/%s.png' % resultid[0]
+
+        return self._share
+
+
+class Speedtest(object):
+    """Class for performing standard speedtest.net testing operations"""
+
+    def __init__(self, config=dict()):
+        self.config = dict()
+        self.get_config()
+        self.config.update(config)
+
+        self.servers = dict()
+        self.closest = list()
+        self.best = dict()
+
+        self._results = SpeedtestResults()
+
+    def results(self):
+        """Return a SpeedtestResults object"""
+        return self._results
+
+    def get_config(self):
         """Download the speedtest.net configuration and return only the data
         we are interested in
         """
 
+        try:
             uh = urlopen('http://www.speedtest.net/speedtest-config.php')
+        except (URLError, HTTPError):
+            raise ConfigRetrievalError
+
         configxml = []
         while 1:
             configxml.append(uh.read(10240))
@@ -308,32 +446,74 @@ def get_config():
                 break
         if int(uh.code) != 200:
             return None
+
         uh.close()
+
         try:
             root = ET.fromstring(''.encode().join(configxml))
-        config = {
+            server_config = root.find('server-config').attrib
-            'client': root.find('client').attrib,
+            download = root.find('download').attrib
-            'times': root.find('times').attrib,
+            upload = root.find('upload').attrib
-            'download': root.find('download').attrib,
+            times = root.find('times').attrib
-            'upload': root.find('upload').attrib}
+            client = root.find('client').attrib
+
         except AttributeError:
             root = DOM.parseString(''.join(configxml))
-        config = {
+            server_config = get_attributes_by_tag_name(root, 'server-config')
-            'client': get_attributes_by_tag_name(root, 'client'),
+            download = get_attributes_by_tag_name(root, 'download')
-            'times': get_attributes_by_tag_name(root, 'times'),
+            upload = get_attributes_by_tag_name(root, 'upload')
-            'download': get_attributes_by_tag_name(root, 'download'),
+            times = get_attributes_by_tag_name(root, 'times')
-            'upload': get_attributes_by_tag_name(root, 'upload')}
+            client = get_attributes_by_tag_name(root, 'client')
+
+        ignore_servers = map(int, server_config['ignoreids'].split(','))
+
+        sizes = dict(upload=[], download=[])
+        for desc, size in times.items():
+            if desc.startswith('ul'):
+                sizes['upload'].append(int(size))
+            elif desc.startswith('dl'):
+                sizes['download'].append(int(size) / 10000)
+
+        sizes['upload'].sort()
+        sizes['download'].sort()
+
+        counts = dict(upload=int(upload['threadsperurl']),
+                      download=int(download['threadsperurl']))
+
+        threads = dict(upload=int(upload['threads']),
+                       download=int(server_config['threadcount']))
+
+        self.config.update({
+            'client': client,
+            'ignore_servers': ignore_servers,
+            'sizes': sizes,
+            'counts': counts,
+            'threads': threads
+        })
+
+        self.lat_lon = (float(client['lat']), float(client['lon']))
+
         del root
         del configxml
-    return config
+        return self.config
 
-
+    def get_servers(self, servers=[]):
-def closest_servers(client, all=False):
+        """Retrieve a the list of speedtest.net servers, optionally filtered
-    """Determine the 5 closest speedtest.net servers based on geographic
+        to servers matching those specified in the ``servers`` argument
-    distance
         """
 
+        for i, s in enumerate(servers):
+            try:
+                servers[i] = int(s)
+            except ValueError:
+                raise InvalidServerIDType('%s is an invalid server type, must '
+                                          'be int' % s)
+
+        try:
             uh = urlopen('http://www.speedtest.net/speedtest-servers.php')
+        except (URLError, HTTPError):
+            raise ServersRetrievalError
+
         serversxml = []
         while 1:
             serversxml.append(uh.read(10240))
@@ -341,45 +521,101 @@ def closest_servers(client, all=False):
                 break
         if int(uh.code) != 200:
             return None
+
         uh.close()
+
         try:
             root = ET.fromstring(''.encode().join(serversxml))
             elements = root.getiterator('server')
         except AttributeError:
             root = DOM.parseString(''.join(serversxml))
             elements = root.getElementsByTagName('server')
-    servers = {}
+
         for server in elements:
             try:
                 attrib = server.attrib
             except AttributeError:
                 attrib = dict(list(server.attributes.items()))
-        d = distance([float(client['lat']), float(client['lon'])],
+
-                     [float(attrib.get('lat')), float(attrib.get('lon'))])
+            if servers and int(attrib.get('id')) not in servers:
+                continue
+
+            if int(attrib.get('id')) in self.config['ignore_servers']:
+                continue
+
+            d = distance(self.lat_lon,
+                         (float(attrib.get('lat')), float(attrib.get('lon'))))
             attrib['d'] = d
-        if d not in servers:
+
-            servers[d] = [attrib]
+            try:
-        else:
+                self.servers[d].append(attrib)
-            servers[d].append(attrib)
+            except KeyError:
+                self.servers[d] = [attrib]
+
+        if servers and not self.servers:
+            raise NoMatchedServers
+
         del root
         del serversxml
         del elements
 
-    closest = []
+        return self.servers
-    for d in sorted(servers.keys()):
+
-        for s in servers[d]:
+    def set_mini_server(self, server):
-            closest.append(s)
+        """Instead of querying for a list of servers, set a link to a
-            if len(closest) == 5 and not all:
+        speedtest mini server
+        """
+
+        name, ext = os.path.splitext(server)
+        if ext:
+            url = os.path.dirname(server)
+        else:
+            url = server
+
+        urlparts = urlparse(url)
+
+        try:
+            f = urlopen(server)
+        except (URLError, HTTPError):
+            raise SpeedtestMiniConnectFailure('Failed to connect to %s' %
+                                              server)
+        else:
+            text = f.read()
+            f.close()
+
+        extension = re.findall('upload_extension: "([^"]+)"', text.decode())
+        if not urlparts or not extension:
+            raise InvalidSpeedtestMiniServer('Invalid Speedtest Mini Server: '
+                                             '%s' % server)
+
+        self.servers = [{
+            'sponsor': 'Speedtest Mini',
+            'name': urlparts[1],
+            'd': 0,
+            'url': '%s/speedtest/upload.%s' % (url.rstrip('/'), extension[0]),
+            'latency': 0,
+            'id': 0
+        }]
+
+        return self.servers
+
+    def get_closest(self, limit=5):
+        """Limit servers to the closest speedtest.net servers based on
+        geographic distance
+        """
+
+        for d in sorted(self.servers.keys()):
+            for s in self.servers[d]:
+                self.closest.append(s)
+                if len(self.closest) == limit:
                     break
             else:
                 continue
             break
 
-    del servers
+        return self.closest
-    return closest
 
-
+    def get_best_server(self, servers):
-def get_best_server(servers):
         """Perform a speedtest.net "ping" to determine which speedtest.net
         server has the lowest latency
         """
@@ -388,7 +624,7 @@ def get_best_server(servers):
         for server in servers:
             cum = []
             url = os.path.dirname(server['url'])
-        for i in range(0, 3):
+            for _ in range(0, 3):
                 try:
                     uh = urlopen('%s/latency.txt' % url)
                 except (HTTPError, URLError):
@@ -409,8 +645,103 @@ def get_best_server(servers):
         best = results[fastest]
         best['latency'] = fastest
 
+        self._results.ping, self._results.server = fastest, best
+
+        self.best.update(best)
         return best
 
+    def download(self, callback=None):
+        """Test download speed against speedtest.net"""
+
+        urls = []
+        for size in self.config['sizes']['download']:
+            for _ in range(0, self.config['counts']['download']):
+                urls.append('%s/random%sx%s.jpg' %
+                            (os.path.dirname(self.best['url']), size, size))
+
+        url_count = len(urls)
+
+        start = time.time()
+
+        def producer(q, urls, url_count):
+            for i, url in enumerate(urls):
+                thread = Downloader(url, start)
+                thread.start()
+                q.put(thread, True)
+                if not shutdown_event.isSet() and callback:
+                    callback(i, url_count)
+
+        finished = []
+
+        def consumer(q, url_count):
+            while len(finished) < url_count:
+                thread = q.get(True)
+                while thread.isAlive():
+                    thread.join(timeout=0.1)
+                finished.append(sum(thread.result))
+                del thread
+
+        q = Queue(self.config['threads']['download'])
+        prod_thread = threading.Thread(target=producer,
+                                       args=(q, urls, url_count))
+        cons_thread = threading.Thread(target=consumer, args=(q, url_count))
+        start = time.time()
+        prod_thread.start()
+        cons_thread.start()
+        while prod_thread.isAlive():
+            prod_thread.join(timeout=0.1)
+        while cons_thread.isAlive():
+            cons_thread.join(timeout=0.1)
+
+        self._results.download = (sum(finished) / (time.time() - start))
+        return self._results.download
+
+    def upload(self, callback=None):
+        """Test upload speed against speedtest.net"""
+
+        sizes = []
+
+        for size in self.config['sizes']['upload']:
+            for _ in range(0, self.config['counts']['upload']):
+                sizes.append(size)
+
+        size_count = len(sizes)
+
+        start = time.time()
+
+        def producer(q, sizes, size_count):
+            for i, size in enumerate(sizes):
+                thread = Uploader(self.best['url'], start, size)
+                thread.start()
+                q.put(thread, True)
+                if not shutdown_event.isSet() and callback:
+                    callback(i, size_count)
+
+        finished = []
+
+        def consumer(q, size_count):
+            while len(finished) < size_count:
+                thread = q.get(True)
+                while thread.isAlive():
+                    thread.join(timeout=0.1)
+                finished.append(thread.result)
+                del thread
+
+        q = Queue(6)
+        prod_thread = threading.Thread(target=producer,
+                                       args=(q, sizes, size_count))
+        cons_thread = threading.Thread(target=consumer, args=(q, size_count))
+        start = time.time()
+        prod_thread.start()
+        cons_thread.start()
+        while prod_thread.isAlive():
+            prod_thread.join(timeout=0.1)
+        while cons_thread.isAlive():
+            cons_thread.join(timeout=0.1)
+
+        self._results.upload = (sum(finished) / (time.time() - start))
+        return self._results.upload
+
 
 def ctrl_c(signum, frame):
     """Catch Ctrl-C key sequence and set a shutdown_event for our threaded
@@ -456,7 +787,8 @@ def parse_args():
     parser.add_argument('--list', action='store_true',
                         help='Display a list of speedtest.net servers '
                              'sorted by distance')
-    parser.add_argument('--server', help='Specify a server ID to test against')
+    parser.add_argument('--server', help='Specify a server ID to test against',
+                        type=PARSER_TYPE_INT)
     parser.add_argument('--mini', help='URL of the Speedtest Mini server')
     parser.add_argument('--source', help='Source IP address to bind to')
     parser.add_argument('--version', action='store_true',
@@ -470,7 +802,7 @@ def parse_args():
     return args
 
 
-def speedtest():
+def shell():
     """Run the full speedtest.net test"""
 
     global shutdown_event, source
@@ -489,22 +821,29 @@ def speedtest():
         source = args.source
         socket.socket = bound_socket
 
-    if not args.simple:
+    # Don't set a callback if we are running in simple mode
+    if args.simple:
+        callback = None
+    else:
+        callback = print_dots
+
     print_('Retrieving speedtest.net configuration...')
     try:
-        config = get_config()
+        speedtest = Speedtest()
-    except URLError:
+    except ConfigRetrievalError:
         print_('Cannot retrieve speedtest configuration')
+
+    if args.list:
+        try:
+            speedtest.get_servers()
+        except ServersRetrievalError:
+            print_('Cannot retrieve speedtest server list')
             sys.exit(1)
 
-    if not args.simple:
-        print_('Retrieving speedtest.net server list...')
-    if args.list or args.server:
-        servers = closest_servers(config['client'], True)
-        if args.list:
         server_list = []
+        for _, servers in sorted(speedtest.servers.items()):
             for server in servers:
-                line = ('%(id)4s) %(sponsor)s (%(name)s, %(country)s) '
+                line = ('%(id)5s) %(sponsor)s (%(name)s, %(country)s) '
                         '[%(d)0.2f km]' % server)
                 server_list.append(line)
         # Python 2.7 and newer seem to be ok with the resultant encoding
@@ -518,150 +857,70 @@ def speedtest():
         except IOError:
             pass
         sys.exit(0)
-    else:
+
-        servers = closest_servers(config['client'])
+    # Set a filter of servers to retrieve
+    servers = []
+    if args.server:
+        servers.append(args.server)
 
     if not args.simple:
-        print_('Testing from %(isp)s (%(ip)s)...' % config['client'])
+        print_('Testing from %(isp)s (%(ip)s)...' % speedtest.config['client'])
+    if not args.mini:
+        print_('Retrieving speedtest.net server list...')
+        try:
+            speedtest.get_servers(servers)
+        except NoMatchedServers:
+            print_('No matched servers: %s' % args.server)
+            sys.exit(1)
+        except ServersRetrievalError:
+            print_('Cannot retrieve speedtest server list')
+            sys.exit(1)
+        except InvalidServerIDType:
+            print_('%s is an invalid server type, must be int' % args.server)
+            sys.exit(1)
 
-    if args.server:
-        try:
-            best = get_best_server(filter(lambda x: x['id'] == args.server,
-                                          servers))
-        except IndexError:
-            print_('Invalid server ID')
-            sys.exit(1)
-    elif args.mini:
-        name, ext = os.path.splitext(args.mini)
-        if ext:
-            url = os.path.dirname(args.mini)
-        else:
-            url = args.mini
-        urlparts = urlparse(url)
-        try:
-            f = urlopen(args.mini)
-        except:
-            print_('Invalid Speedtest Mini URL')
-            sys.exit(1)
-        else:
-            text = f.read()
-            f.close()
-        extension = re.findall('upload_extension: "([^"]+)"', text.decode())
-        if not urlparts or not extension:
-            print_('Please provide the full URL of your Speedtest Mini server')
-            sys.exit(1)
-        servers = [{
-            'sponsor': 'Speedtest Mini',
-            'name': urlparts[1],
-            'd': 0,
-            'url': '%s/speedtest/upload.%s' % (url.rstrip('/'), extension[0]),
-            'latency': 0,
-            'id': 0
-        }]
-        try:
-            best = get_best_server(servers)
-        except:
-            best = servers[0]
-    else:
         if not args.simple:
             print_('Selecting best server based on ping...')
-        best = get_best_server(servers)
+        speedtest.get_best_server(speedtest.get_closest())
+    elif args.mini:
+        speedtest.get_best_server(speedtest.set_mini_server(args.mini))
 
-    if not args.simple:
+    results = speedtest.results()
+
+    if args.simple:
+        print_('Ping: %(latency)s ms' % results.server)
+    else:
         # Python 2.7 and newer seem to be ok with the resultant encoding
         # from parsing the XML, but older versions have some issues.
         # This block should detect whether we need to encode or not
         try:
             unicode()
             print_(('Hosted by %(sponsor)s (%(name)s) [%(d)0.2f km]: '
-                   '%(latency)s ms' % best).encode('utf-8', 'ignore'))
+                    '%(latency)s ms' %
+                    results.server).encode('utf-8', 'ignore'))
         except NameError:
             print_('Hosted by %(sponsor)s (%(name)s) [%(d)0.2f km]: '
-                   '%(latency)s ms' % best)
+                   '%(latency)s ms' % results.server)
-    else:
-        print_('Ping: %(latency)s ms' % best)
 
-    sizes = [350, 500, 750, 1000, 1500, 2000, 2500, 3000, 3500, 4000]
-    urls = []
-    for size in sizes:
-        for i in range(0, 4):
-            urls.append('%s/random%sx%s.jpg' %
-                        (os.path.dirname(best['url']), size, size))
-    if not args.simple:
-        print_('Testing download speed', end='')
-    dlspeed = download_speed(urls, args.simple)
-    if not args.simple:
-        print_()
-    print_('Download: %0.2f M%s/s' %
-           ((dlspeed / 1000 / 1000) * args.units[1], args.units[0]))
-
-    sizesizes = [int(.25 * 1000 * 1000), int(.5 * 1000 * 1000)]
-    sizes = []
-    for size in sizesizes:
-        for i in range(0, 25):
-            sizes.append(size)
     if not args.simple:
         print_('Testing upload speed', end='')
-    ulspeed = upload_speed(best['url'], sizes, args.simple)
+    speedtest.download(callback=callback)
+    print_('Download: %0.2f M%s/s' %
+           ((results.download / 1000 / 1000) * args.units[1], args.units[0]))
+
     if not args.simple:
-        print_()
+        print_('Testing download speed', end='')
+    speedtest.upload(callback=callback)
     print_('Upload: %0.2f M%s/s' %
-           ((ulspeed / 1000 / 1000) * args.units[1], args.units[0]))
+           ((results.upload / 1000 / 1000) * args.units[1], args.units[0]))
-
-    if args.share and args.mini:
-        print_('Cannot generate a speedtest.net share results image while '
-               'testing against a Speedtest Mini server')
-    elif args.share:
-        dlspeedk = int(round((dlspeed / 1000) * 8, 0))
-        ping = int(round(best['latency'], 0))
-        ulspeedk = int(round((ulspeed / 1000) * 8, 0))
-
-        # Build the request to send results back to speedtest.net
-        # We use a list instead of a dict because the API expects parameters
-        # in a certain order
-        api_data = [
-            'download=%s' % dlspeedk,
-            'ping=%s' % ping,
-            'upload=%s' % ulspeedk,
-            'promo=',
-            'startmode=%s' % 'pingselect',
-            'recommendedserverid=%s' % best['id'],
-            'accuracy=%s' % 1,
-            'serverid=%s' % best['id'],
-            'hash=%s' % md5(('%s-%s-%s-%s' %
-                             (ping, ulspeedk, dlspeedk, '297aae72'))
-                            .encode()).hexdigest()]
-
-        req = Request('http://www.speedtest.net/api/api.php',
-                      data='&'.join(api_data).encode())
-        req.add_header('Referer', 'http://c.speedtest.net/flash/speedtest.swf')
-        f = urlopen(req)
-        response = f.read()
-        code = f.code
-        f.close()
-
-        if int(code) != 200:
-            print_('Could not submit results to speedtest.net')
-            sys.exit(1)
-
-        qsargs = parse_qs(response.decode())
-        resultid = qsargs.get('resultid')
-        if not resultid or len(resultid) != 1:
-            print_('Could not submit results to speedtest.net')
-            sys.exit(1)
-
-        print_('Share results: http://www.speedtest.net/result/%s.png' %
-               resultid[0])
 
 
 def main():
     try:
-        speedtest()
+        shell()
     except KeyboardInterrupt:
         print_('\nCancelling...')
 
 
 if __name__ == '__main__':
     main()
-
-# vim:ts=4:sw=4:expandtab