more coverage

docs/index.rst

@@ -36,7 +36,7 @@ Release v\ |version|. (:ref:`Installation <install>`)
     >>> YouTube('http://youtube.com/watch?v=9bZkp7q19f0').streams.first().download()
     >>> yt = YouTube('http://youtube.com/watch?v=9bZkp7q19f0')
     >>> yt.streams
-    ... .filter(progressive=True, subtype='mp4')
+    ... .filter(progressive=True, file_extension='mp4')
     ... .order_by('resolution')
     ... .desc()
     ... .first()

pytube/cipher.py

@@ -51,7 +51,7 @@ def get_transform_plan(js):
     :param str js:
         The contents of the base.js asset file.
 
-    Sample Output:
+    **Sample Output**:
 
     .. code-block:: python
 
@@ -85,7 +85,7 @@ def get_transform_object(js, var):
         The obfuscated variable name that stores an object with all functions
         that descrambles the signature.
 
-    Sample Output:
+    **Sample Output**:
 
     .. code-block:: python
 
@@ -138,7 +138,7 @@ def reverse(arr, b):
     This method takes an unused ``b`` variable as their transform functions
     universally sent two arguments.
 
-    Example usage:
+    **Example usage**:
     ~~~~~~~~~~~~~~
     >>> reverse([1, 2, 3, 4])
     [4, 3, 2, 1]
@@ -155,7 +155,7 @@ def splice(arr, b):
 
        function(a, b) { a.splice(0, b) }.
 
-    Example usage:
+    **Example usage**:
     ~~~~~~~~~~~~~~
     >>> splice([1, 2, 3, 4], 2)
     [1, 2]
@@ -172,7 +172,7 @@ def swap(arr, b):
 
        function(a, b) { var c=a[0];a[0]=a[b%a.length];a[b]=c }.
 
-    Example usage:
+    **Example usage**:
     ~~~~~~~~~~~~~~
     >>> swap([1, 2, 3, 4], 2)
     [3, 2, 1, 4]
@@ -209,7 +209,7 @@ def map_functions(js_func):
 def parse_function(js_func):
     """Parse the Javascript transform function.
 
-    Break a JavaScript transform function down into a two element tuple
+    Break a JavaScript transform function down into a two element ``tuple``
     containing the function name and some integer-based argument.
 
     Sample input:
@@ -228,21 +228,22 @@ def parse_function(js_func):
         The JavaScript version of the transform function.
 
     """
-    pattern = r'\w+\.(\w+)\(\w,(\d+)\)'
     logger.debug('parsing transform function')
-    return regex_search(pattern, js_func, groups=True)
+    return regex_search(r'\w+\.(\w+)\(\w,(\d+)\)', js_func, groups=True)
 
 
 def get_signature(js, ciphered_signature):
     """Decipher the signature.
 
-    Taking the ciphered signature, applies the transform functions and
-    returns the decrypted version.
+    Taking the ciphered signature, applies the transform functions.
 
     :param str js:
         The contents of the base.js asset file.
     :param str ciphered_signature:
         The ciphered signature sent in the ``player_config``.
+    :rtype: str
+    :returns:
+       Decrypted signature required to download the media content.
 
     """
     tplan = get_transform_plan(js)

pytube/cli.py

@@ -139,7 +139,7 @@ def on_progress(stream, file_handle, bytes_remaining):
     :param file_handle:
         The file handle where the media is being written to.
     :type file_handle:
-        :class:`_io.BufferedWriter`
+        :py:class:`io.BufferedWriter`
     :param int bytes_remaining:
         How many bytes have been downloaded.
 

pytube/extract.py

@@ -75,12 +75,17 @@ def js_url(watch_html):
 def mime_type_codec(mime_type_codec):
     """Parse the type data.
 
-    Breaks up the data in the ``type`` key of the manifest, which contains mime
-    type and codecs serialized together (e.g.: 'audio/webm; codecs="opus"'),
-    and splits them into separate elements. (e.g.: 'audio/webm', ['opus'])
+    Breaks up the data in the ``type`` key of the manifest, which contains the
+    mime type and codecs serialized together, and splits them into separate
+    elements.
 
     :param str mime_type_codec:
-        String containing mime type and codecs.
+        String containing mime type and codecs, for example:
+        'audio/webm; codecs="opus"'
+    :rtype: tuple
+    :returns:
+        The mime type and a list of codecs, for example:
+        ('audio/webm', ['opus'])
 
     """
     pattern = r'(\w+\/\w+)\;\scodecs=\"([a-zA-Z-0-9.,\s]*)\"'
@@ -97,7 +102,9 @@ def get_ytplayer_config(watch_html):
 
     :param str watch_html:
         The html contents of the watch page.
-
+    :rtype: str
+    :returns:
+        Substring of the html containing the serialized manifest data.
     """
     pattern = r';ytplayer\.config\s*=\s*({.*?});'
     yt_player_config = regex_search(pattern, watch_html, group=1)

pytube/query.py

@@ -21,43 +21,82 @@ class StreamQuery:
     ):
         """Apply the given filtering criterion.
 
-        :param int fps:
-            (optional) The frames per second (30 or 60)
-        :param str resolution:
+        :param fps:
+            (optional) The frames per second.
+        :type fps:
+            int or None
+
+        :param resolution:
             (optional) Alias to ``res``.
-        :param str res:
-            (optional) The video resolution (e.g.: 480p, 720p, 1080p)
-        :param str mime_type:
+        :type res:
+            str or None
+
+        :param res:
+            (optional) The video resolution.
+        :type resolution:
+            str or None
+
+        :param mime_type:
             (optional) Two-part identifier for file formats and format contents
-            composed of a "type", a "subtype" (e.g.: video/mp4).
-        :param str type:
-            (optional) Type part of the ``mime_type`` (e.g.: "audio", "video").
-        :param str subtype:
-            (optional) Sub-type part of the ``mime_type`` (e.g.: "mp4", "mov").
-        :param str file_extension:
+            composed of a "type", a "subtype".
+        :type mime_type:
+            str or None
+
+        :param type:
+            (optional) Type part of the ``mime_type`` (e.g.: audio, video).
+        :type type:
+            str or None
+
+        :param subtype:
+            (optional) Sub-type part of the ``mime_type`` (e.g.: mp4, mov).
+        :type subtype:
+            str or None
+
+        :param file_extension:
             (optional) Alias to ``sub_type``.
-        :param str abr:
+        :type file_extension:
+            str or None
+
+        :param abr:
             (optional) Average bitrate (ABR) refers to the average amount of
-            data transferred per unit of time (e.g.: 64kbps, 192kbps)
-        :param str bitrate:
+            data transferred per unit of time (e.g.: 64kbps, 192kbps).
+        :type abr:
+            str or None
+
+        :param bitrate:
             (optional) Alias to ``abr``.
-        :param str video_codec:
-            (optional) Digital video compression format (e.g.: vp9, mp4v.20.3).
-        :param str audio_codec:
-            (optional) Digital audio compression format (e.g.: vorbis, mp4).
+        :type bitrate:
+            str or None
+
+        :param video_codec:
+            (optional) Video compression format.
+        :type video_codec:
+            str or None
+
+        :param audio_codec:
+            (optional) Audio compression format.
+        :type audio_codec:
+            str or None
+
         :param bool progressive:
             Excludes adaptive streams (one file contains both audio and video
             tracks).
+
         :param bool adaptive:
             Excludes progressive streams (audio and video are on separate
             tracks).
+
         :param bool only_audio:
             Excludes streams with video tracks.
+
         :param bool only_video:
             Excludes streams with audio tracks.
-        :param list custom_filter_functions:
+
+        :param custom_filter_functions:
             (optional) Interface for defining complex filters without
             subclassing.
+        :type custom_filter_functions:
+            list or None
 
         """
         filters = []
@@ -135,7 +174,7 @@ class StreamQuery:
         return self
 
     def get_by_itag(self, itag):
-        """Get a :class:`Stream <Stream>` for an itag, or None if not found.
+        """Get a :class:`Stream <Stream>` for an itag, or ``None`` if not found.
 
         :param str itag:
             YouTube format identifier code.
@@ -149,7 +188,7 @@ class StreamQuery:
     def first(self):
         """Get the first element in the results.
 
-        Return the first result of this query or None if the result doesn't
+        Return the first result of this query or ``None`` if the result doesn't
         contain any streams.
 
         """
@@ -161,7 +200,7 @@ class StreamQuery:
     def last(self):
         """Get the last element in the results.
 
-        Return the last result of this query or None if the result doesn't
+        Return the last result of this query or ``None`` if the result doesn't
         contain any streams.
 
         """

pytube/streams.py

@@ -183,7 +183,7 @@ class Stream(object):
         :param file_handle:
             The file handle where the media is being written to.
         :type file_handle:
-            :class:`~_io.BufferedWriter`
+            :py:class:`io.BufferedWriter`
         :param int bytes_remaining:
             The delta between the total file size in bytes and amount already
             downloaded.
@@ -206,10 +206,11 @@ class Stream(object):
 
     def on_complete(self, file_handle):
         """On download complete handler function.
+
         :param file_handle:
             The file handle where the media is being written to.
         :type file_handle:
-            :class:`~_io.BufferedWriter`
+            :py:class:`io.BufferedWriter`
 
         """
         logger.debug('download finished')

tests/requirements.txt

@@ -5,6 +5,7 @@ mock==1.3.0
 pre-commit==0.15.0
 pytest==3.1.3
 pytest-cov==2.4.0
+pytest-mock==1.6.3
 pytest-sugar==0.9.0
 sphinx==1.6.4
 sphinx-rtd-theme==0.2.4

tests/test_streams.py

@@ -0,0 +1,40 @@
+# -*- coding: utf-8 -*-
+import random
+
+import mock
+
+from pytube import request
+
+
+def test_filesize(gangnam_style, mocker):
+    mocker.patch.object(request, 'get')
+    request.get.return_value = {'Content-Length': '6796391'}
+    assert gangnam_style.streams.first().filesize == 6796391
+
+
+def test_default_filename(gangnam_style):
+    expected = 'PSY - GANGNAM STYLE(강남스타일) MV.mp4'
+    stream = gangnam_style.streams.first()
+    assert stream.default_filename == expected
+
+
+def test_download(gangnam_style, mocker):
+    mocker.patch.object(request, 'get')
+    request.get.side_effect = [
+        {'Content-Length': '16384'},
+        {'Content-Length': '16384'},
+        iter([str(random.getrandbits(8 * 1024))]),
+    ]
+    with mock.patch('pytube.streams.open', mock.mock_open(), create=True):
+        stream = gangnam_style.streams.first()
+        stream.download()
+
+
+def test_progressive_streams_return_includes_audio_track(gangnam_style):
+    stream = gangnam_style.streams.filter(progressive=True).first()
+    assert stream.includes_audio_track
+
+
+def test_progressive_streams_return_includes_video_track(gangnam_style):
+    stream = gangnam_style.streams.filter(progressive=True).first()
+    assert stream.includes_video_track