From 027f35983babe7ab0c8b93da0dad0b15ee178217 Mon Sep 17 00:00:00 2001 From: pluja Date: Fri, 30 Oct 2020 16:37:12 +0100 Subject: [PATCH] Remove useless youtube_data and small fix --- youtube/video.py | 10 ++-- youtube_data/README.md | 2 - youtube_data/proto.py | 130 ----------------------------------------- 3 files changed, 4 insertions(+), 138 deletions(-) delete mode 100644 youtube_data/README.md delete mode 100644 youtube_data/proto.py diff --git a/youtube/video.py b/youtube/video.py index 6a07e57..7a3ae83 100644 --- a/youtube/video.py +++ b/youtube/video.py @@ -33,20 +33,18 @@ def get_info(url): video['duration'] = info['duration'] video['view_count'] = info['view_count'] - if(info['like_count'] == None): + if(info['like_count'] is None): video['like_count'] = 0 else: video['like_count'] = int(info['like_count']) - if(info['dislike_count'] == None): + if(info['dislike_count'] is None): video['dislike_count'] = 0 else: video['dislike_count'] = int(info['dislike_count']) - try: - video['total_likes'] = info['dislike_count'] + info['like_count'] - except: - video['total_likes'] = "" + video['total_likes'] = info['dislike_count'] + info['like_count'] + video['average_rating'] = str(info['average_rating'])[0:4] video['formats'] = get_video_formats(info['formats']) video['audio_formats'] = get_video_formats(info['formats'], audio=True) diff --git a/youtube_data/README.md b/youtube_data/README.md deleted file mode 100644 index b5941d4..0000000 --- a/youtube_data/README.md +++ /dev/null @@ -1,2 +0,0 @@ -### Youtube_data -This is the module for extracting data from Youtube. It uses a scrapping method through the Youtube JSON headers. It aims to replace the Youtube-API and also my `youtube_search-fork` that I am using right now. diff --git a/youtube_data/proto.py b/youtube_data/proto.py deleted file mode 100644 index 3c74083..0000000 --- a/youtube_data/proto.py +++ /dev/null @@ -1,130 +0,0 @@ -from math import ceil -import base64 -import io - -# FROM https://github.com/user234683/youtube-local/blob/master/youtube/proto.py - -def byte(n): - return bytes((n,)) - - -def varint_encode(offset): - '''In this encoding system, for each 8-bit byte, the first bit is 1 if there are more bytes, and 0 is this is the last one. - The next 7 bits are data. These 7-bit sections represent the data in Little endian order. For example, suppose the data is - aaaaaaabbbbbbbccccccc (each of these sections is 7 bits). It will be encoded as: - 1ccccccc 1bbbbbbb 0aaaaaaa - - This encoding is used in youtube parameters to encode offsets and to encode the length for length-prefixed data. - See https://developers.google.com/protocol-buffers/docs/encoding#varints for more info.''' - needed_bytes = ceil(offset.bit_length()/7) or 1 # (0).bit_length() returns 0, but we need 1 in that case. - encoded_bytes = bytearray(needed_bytes) - for i in range(0, needed_bytes - 1): - encoded_bytes[i] = (offset & 127) | 128 # 7 least significant bits - offset = offset >> 7 - encoded_bytes[-1] = offset & 127 # leave first bit as zero for last byte - - return bytes(encoded_bytes) - - -def varint_decode(encoded): - decoded = 0 - for i, byte in enumerate(encoded): - decoded |= (byte & 127) << 7*i - - if not (byte & 128): - break - return decoded - - -def string(field_number, data): - data = as_bytes(data) - return _proto_field(2, field_number, varint_encode(len(data)) + data) -nested = string - -def uint(field_number, value): - return _proto_field(0, field_number, varint_encode(value)) - - - - -def _proto_field(wire_type, field_number, data): - ''' See https://developers.google.com/protocol-buffers/docs/encoding#structure ''' - return varint_encode( (field_number << 3) | wire_type) + data - - - -def percent_b64encode(data): - return base64.urlsafe_b64encode(data).replace(b'=', b'%3D') - - -def unpadded_b64encode(data): - return base64.urlsafe_b64encode(data).replace(b'=', b'') - -def as_bytes(value): - if isinstance(value, str): - return value.encode('utf-8') - return value - - -def read_varint(data): - result = 0 - i = 0 - while True: - try: - byte = data.read(1)[0] - except IndexError: - if i == 0: - raise EOFError() - raise Exception('Unterminated varint starting at ' + str(data.tell() - i)) - result |= (byte & 127) << 7*i - if not byte & 128: - break - - i += 1 - return result - - -def read_group(data, end_sequence): - start = data.tell() - index = data.original.find(end_sequence, start) - if index == -1: - raise Exception('Unterminated group') - data.seek(index + len(end_sequence)) - return data.original[start:index] - -def read_protobuf(data): - data_original = data - data = io.BytesIO(data) - data.original = data_original - while True: - try: - tag = read_varint(data) - except EOFError: - break - wire_type = tag & 7 - field_number = tag >> 3 - - if wire_type == 0: - value = read_varint(data) - elif wire_type == 1: - value = data.read(8) - elif wire_type == 2: - length = read_varint(data) - value = data.read(length) - elif wire_type == 3: - end_bytes = encode_varint((field_number << 3) | 4) - value = read_group(data, end_bytes) - elif wire_type == 5: - value = data.read(4) - else: - raise Exception("Unknown wire type: " + str(wire_type) + ", Tag: " + bytes_to_hex(succinct_encode(tag)) + ", at position " + str(data.tell())) - yield (wire_type, field_number, value) - -def parse(data): - return {field_number: value for _, field_number, value in read_protobuf(data)} - -def b64_to_bytes(data): - if isinstance(data, bytes): - data = data.decode('ascii') - data = data.replace("%3D", "=") - return base64.urlsafe_b64decode(data + "="*((4 - len(data)%4)%4) )