From 24a1b9b36b9590dd4882da7585dea82c35eec661 Mon Sep 17 00:00:00 2001
From: Anton Grigoryev <mail@griganton.ru>
Date: Thu, 12 Mar 2015 02:51:24 +0300
Subject: [PATCH] Method_send implemented

I want to call methods like a functions in Python.
Then I can go further.
---
 mtproto.py | 45 ++++++++++++++++++++++++++++++++++-----------
 testing.py | 11 +++++------
 2 files changed, 39 insertions(+), 17 deletions(-)

diff --git a/mtproto.py b/mtproto.py
index 468339b5..c9facee2 100644
--- a/mtproto.py
+++ b/mtproto.py
@@ -39,35 +39,58 @@ class TlConstructor:
                 param['subtype'] = None
             self.params.append(param)
 
+class TlMethod:
+    def __init__(self, json_dict):
+        self.id = int(json_dict['id'])
+        self.type = json_dict['type']
+        self.method = json_dict['method']
+        self.params = json_dict['params']
+
+
 
 class TL:
     def __init__(self):
         with open("TL_schema.JSON", 'r') as f:
            TL_dict = json.load(f)
 
+        # Read constructors
+
         self.constructors = TL_dict['constructors']
         self.constructor_id = {}
         self.constructor_type = {}
-
-        # Read constructors
-
         for elem in self.constructors:
             z = TlConstructor(elem)
             self.constructor_id[z.id] = z
             self.constructor_type[z.type] = z
 
+        self.methods = TL_dict['methods']
+        self.method_id = {}
+        self.method_name = {}
+        for elem in self.methods:
+            z = TlMethod(elem)
+            self.method_id[z.id] = z
+            self.method_name[z.method] = z
 
-    def deserialize(self, byte_string, type_=None, subtype=None):
+    def method_call(self, method, **kwargs):
+        z = io.BytesIO()
+        tl_method = self.method_name[method]
+        z.write(struct.pack('<i', tl_method.id))
+        for param in tl_method.params:
+            self.serialize(bytes_io=z, value=kwargs[param['name']], type_=param['type'])
+        return z.getvalue()
 
-        if isinstance(byte_string, io.BytesIO):
-            bytes_io = byte_string
-        elif isinstance(byte_string, bytes):
-            bytes_io = io.BytesIO(byte_string)
-        else:
-            raise TypeError("Bad input type, use bytes string or BytesIO object")
+    def serialize(self, bytes_io, type_, value):
+        if  type_ == "int":
+            assert isinstance(value, int)
+            bytes_io.write(struct.pack('<i', value))
+        if  type_ == "int128":
+            assert isinstance(value, bytes)
+            bytes_io.write(struct.pack('<16s', value))
+
+    def deserialize(self, bytes_io, type_=None, subtype=None):
+        assert isinstance(bytes_io, io.BytesIO)
 
         # Built-in bare types
-
         if type_ == 'int':
             x = struct.unpack('<i', bytes_io.read(4))[0]
         elif type_ == '#':
diff --git a/testing.py b/testing.py
index ef8088a8..b87adbb1 100644
--- a/testing.py
+++ b/testing.py
@@ -10,14 +10,13 @@ config.read('credentials')
 ip = config['App data']['ip_address']
 port = config['App data'].getint('port')
 
+TL=mtproto.TL()
 
 Session = mtproto.Session(ip, port)
-nonce = os.urandom(16)
-tosend = b'\x78\x97\x46\x60' + nonce
-Session.send_message(tosend)
-z = Session.recv_message()
-TL=mtproto.TL()
-x = TL.deserialize(io.BytesIO(z))
+a = TL.method_call('req_pq', nonce=os.urandom(16))
+Session.send_message(a)
+b = Session.recv_message()
+x = TL.deserialize(io.BytesIO(b))
 
 PQ = int.from_bytes(x['pq'], 'big')
 [p, q] = prime.primefactors(PQ)