Totally refactored source files location

Now it *should* be easier to turn Telethon
into a pip package

telethon/utils/__init__.py

@@ -0,0 +1,2 @@
+from .binary_writer import BinaryWriter
+from .binary_reader import BinaryReader

telethon/utils/binary_reader.py

@@ -0,0 +1,160 @@
+from datetime import datetime
+from io import BytesIO, BufferedReader
+from telethon.tl.all_tlobjects import tlobjects
+from struct import unpack
+from telethon.errors import *
+import inspect
+import os
+
+
+class BinaryReader:
+    """
+    Small utility class to read binary data.
+    Also creates a "Memory Stream" if necessary
+    """
+    def __init__(self, data=None, stream=None):
+        if data:
+            self.stream = BytesIO(data)
+        elif stream:
+            self.stream = stream
+        else:
+            raise InvalidParameterError("Either bytes or a stream must be provided")
+
+        self.reader = BufferedReader(self.stream)
+
+    # region Reading
+
+    # "All numbers are written as little endian." |> Source: https://core.telegram.org/mtproto
+    def read_byte(self):
+        """Reads a single byte value"""
+        return self.read(1)[0]
+
+    def read_int(self, signed=True):
+        """Reads an integer (4 bytes) value"""
+        return int.from_bytes(self.read(4), byteorder='little', signed=signed)
+
+    def read_long(self, signed=True):
+        """Reads a long integer (8 bytes) value"""
+        return int.from_bytes(self.read(8), byteorder='little', signed=signed)
+
+    def read_float(self):
+        """Reads a real floating point (4 bytes) value"""
+        return unpack('<f', self.read(4))[0]
+
+    def read_double(self):
+        """Reads a real floating point (8 bytes) value"""
+        return unpack('<d', self.read(8))[0]
+
+    def read_large_int(self, bits, signed=True):
+        """Reads a n-bits long integer value"""
+        return int.from_bytes(self.read(bits // 8), byteorder='little', signed=signed)
+
+    def read(self, length):
+        """Read the given amount of bytes"""
+        result = self.reader.read(length)
+        if len(result) != length:
+            raise BufferError('Trying to read outside the data bounds (no more data left to read)')
+        
+        return result
+
+    def get_bytes(self):
+        """Gets the byte array representing the current buffer as a whole"""
+        return self.stream.getvalue()
+
+    # endregion
+
+    # region Telegram custom reading
+
+    def tgread_bytes(self):
+        """Reads a Telegram-encoded byte array, without the need of specifying its length"""
+        first_byte = self.read_byte()
+        if first_byte == 254:
+            length = self.read_byte() | (self.read_byte() << 8) | (self.read_byte() << 16)
+            padding = length % 4
+        else:
+            length = first_byte
+            padding = (length + 1) % 4
+
+        data = self.read(length)
+        if padding > 0:
+            padding = 4 - padding
+            self.read(padding)
+
+        return data
+
+    def tgread_string(self):
+        """Reads a Telegram-encoded string"""
+        return str(self.tgread_bytes(), encoding='utf-8')
+
+    def tgread_bool(self):
+        """Reads a Telegram boolean value"""
+        value = self.read_int(signed=False)
+        if value == 0x997275b5:  # boolTrue
+            return True
+        elif value == 0xbc799737:  # boolFalse
+            return False
+        else:
+            raise ValueError('Invalid boolean code {}'.format(hex(value)))
+
+    def tgread_date(self):
+        """Reads and converts Unix time (used by Telegram) into a Python datetime object"""
+        value = self.read_int()
+        return None if value == 0 else datetime.fromtimestamp(value)
+
+    def tgread_object(self):
+        """Reads a Telegram object"""
+        constructor_id = self.read_int(signed=False)
+        clazz = tlobjects.get(constructor_id, None)
+        if clazz is None:
+            # The class was None, but there's still a
+            # chance of it being a manually parsed value like bool!
+            value = constructor_id
+            if value == 0x997275b5:  # boolTrue
+                return True
+            elif value == 0xbc799737:  # boolFalse
+                return False
+
+            # If there was still no luck, give up
+            raise TypeNotFoundError(constructor_id)
+
+        # Now we need to determine the number of parameters of the class, so we can
+        # instantiate it with all of them set to None, and still, no need to write
+        # the default =None in all the classes, thus forcing the user to provide a real value
+        sig = inspect.signature(clazz.__init__)
+        params = [None] * (len(sig.parameters) - 1)  # Subtract 1 (self)
+        result = clazz(*params)  # https://docs.python.org/3/tutorial/controlflow.html#unpacking-argument-lists
+
+        # Finally, read the object and return the result
+        result.on_response(self)
+        return result
+
+    # endregion
+
+    def close(self):
+        self.reader.close()
+
+    # region Position related
+
+    def tell_position(self):
+        """Tells the current position on the stream"""
+        return self.reader.tell()
+
+    def set_position(self, position):
+        """Sets the current position on the stream"""
+        self.reader.seek(position)
+
+    def seek(self, offset):
+        """Seeks the stream position given an offset from the current position. May be negative"""
+        self.reader.seek(offset, os.SEEK_CUR)
+
+    # endregion
+
+    # region with block
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self.close()
+
+    # endregion

telethon/utils/binary_writer.py

@@ -0,0 +1,124 @@
+from io import BytesIO, BufferedWriter
+from struct import pack
+
+
+class BinaryWriter:
+    """
+    Small utility class to write binary data.
+    Also creates a "Memory Stream" if necessary
+    """
+
+    def __init__(self, stream=None):
+        if not stream:
+            stream = BytesIO()
+
+        self.stream = stream
+        self.writer = BufferedWriter(self.stream)
+        self.written_count = 0
+
+    # region Writing
+
+    # "All numbers are written as little endian." |> Source: https://core.telegram.org/mtproto
+    def write_byte(self, value):
+        """Writes a single byte value"""
+        self.writer.write(pack('B', value))
+        self.written_count += 1
+
+    def write_int(self, value, signed=True):
+        """Writes an integer value (4 bytes), which can or cannot be signed"""
+        self.writer.write(int.to_bytes(value, length=4, byteorder='little', signed=signed))
+        self.written_count += 4
+
+    def write_long(self, value, signed=True):
+        """Writes a long integer value (8 bytes), which can or cannot be signed"""
+        self.writer.write(int.to_bytes(value, length=8, byteorder='little', signed=signed))
+        self.written_count += 8
+
+    def write_float(self, value):
+        """Writes a floating point value (4 bytes)"""
+        self.writer.write(pack('<f', value))
+        self.written_count += 4
+
+    def write_double(self, value):
+        """Writes a floating point value (8 bytes)"""
+        self.writer.write(pack('<d', value))
+        self.written_count += 8
+
+    def write_large_int(self, value, bits, signed=True):
+        """Writes a n-bits long integer value"""
+        self.writer.write(int.to_bytes(value, length=bits // 8, byteorder='little', signed=signed))
+        self.written_count += bits // 8
+
+    def write(self, data):
+        """Writes the given bytes array"""
+        self.writer.write(data)
+        self.written_count += len(data)
+
+    # endregion
+
+    # region Telegram custom writing
+
+    def tgwrite_bytes(self, data):
+        """Write bytes by using Telegram guidelines"""
+        if len(data) < 254:
+            padding = (len(data) + 1) % 4
+            if padding != 0:
+                padding = 4 - padding
+
+            self.write(bytes([len(data)]))
+            self.write(data)
+
+        else:
+            padding = len(data) % 4
+            if padding != 0:
+                padding = 4 - padding
+
+            self.write(bytes([254]))
+            self.write(bytes([len(data) % 256]))
+            self.write(bytes([(len(data) >> 8) % 256]))
+            self.write(bytes([(len(data) >> 16) % 256]))
+            self.write(data)
+
+        self.write(bytes(padding))
+
+    def tgwrite_string(self, string):
+        """Write a string by using Telegram guidelines"""
+        self.tgwrite_bytes(string.encode('utf-8'))
+
+    def tgwrite_bool(self, boolean):
+        """Write a boolean value by using Telegram guidelines"""
+        #                     boolTrue                boolFalse
+        self.write_int(0x997275b5 if boolean else 0xbc799737, signed=False)
+
+    def tgwrite_date(self, datetime):
+        """Converts a Python datetime object into Unix time (used by Telegram) and writes it"""
+        value = 0 if datetime is None else int(datetime.timestamp())
+        self.write_int(value)
+
+    # endregion
+
+    def flush(self):
+        """Flush the current stream to "update" changes"""
+        self.writer.flush()
+
+    def close(self):
+        """Close the current stream"""
+        self.writer.close()
+
+    def get_bytes(self, flush=True):
+        """Get the current bytes array content from the buffer, optionally flushing first"""
+        if flush:
+            self.writer.flush()
+        return self.stream.getvalue()
+
+    def get_written_bytes_count(self):
+        """Gets the count of bytes written in the buffer.
+           This may NOT be equal to the stream length if one was provided when initializing the writer"""
+        return self.written_count
+
+    # with block
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self.close()