Split Python Types into their own c module like they should be.

python-tg.c

@@ -77,6 +77,8 @@
 #include "python-types.h"
 
 
+extern PyTypeObject tgl_PeerType;
+
 
 //#include "interface.h"
 //#include "auto/constants.h"

python-types.c

+
+#include <Python.h>
+#include <tgl/tgl.h>
+#include <tgl/tools.h>
+#include <tgl/updates.h>
+#include <tgl/tgl-structures.h>
+#include <stdlib.h>
+#include "structmember.h"
+
+// Python Imports
+#include "datetime.h"
+
+#include "python-types.h"
+
+extern struct tgl_state *TLS;
+
+// modeled after tgls_free_peer 
+static void
+tgl_Peer_dealloc(tgl_Peer* self)
+{
+  switch(self->peer.id.type) {
+    case TGL_PEER_USER:
+      if (self->peer.user.first_name) tfree_str(self->peer.user.first_name);
+      if (self->peer.user.last_name) tfree_str(self->peer.user.last_name);
+      if (self->peer.user.print_name) tfree_str(self->peer.user.print_name);
+      if (self->peer.user.phone) tfree_str(self->peer.user.phone);
+      if (self->peer.user.real_first_name) tfree_str(self->peer.user.real_first_name);
+      if (self->peer.user.real_last_name) tfree_str(self->peer.user.real_last_name);
+      if (self->peer.user.status.ev) { tgl_remove_status_expire (TLS, &self->peer.user); }
+      tgls_free_photo (TLS, self->peer.user.photo);
+      break;
+    case TGL_PEER_CHAT:
+      if (self->peer.chat.title) tfree_str(self->peer.chat.title);
+      if (self->peer.chat.print_title) tfree_str(self->peer.chat.print_title);
+      if (self->peer.chat.user_list) 
+        tfree(self->peer.chat.user_list, self->peer.chat.user_list_size * sizeof(struct tgl_chat_user));
+      tgls_free_photo (TLS, self->peer.chat.photo);
+      break;
+    case TGL_PEER_ENCR_CHAT:
+      if (self->peer.encr_chat.print_name) tfree_str(self->peer.encr_chat.print_name);
+      if (self->peer.encr_chat.g_key) tfree (self->peer.encr_chat.g_key, 256);
+      break;
+    default:
+     PyErr_SetString(PyExc_TypeError, "peer.type not supported!");
+  }
+ 
+  Py_TYPE(self)->tp_free((PyObject*)self);
+}
+
+static PyObject *
+tgl_Peer_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
+{
+  tgl_Peer *self;
+
+  self = (tgl_Peer *)type->tp_alloc(type, 0);
+  if (self != NULL) {
+    self->peer.id.type = 0;
+    self->peer.id.id = 0;
+  }
+
+  return (PyObject *)self;
+}
+
+static int
+tgl_Peer_init(tgl_Peer *self, PyObject *args, PyObject *kwds)
+{
+  static char *kwlist[] = {"type", "id", NULL};
+
+  if(!PyArg_ParseTupleAndKeywords(args, kwds, "|ii", kwlist, 
+                                  &self->peer.id.type,
+                                  &self->peer.id.id))
+    return -1;
+
+  return 0;
+}
+
+static PyObject *
+tgl_Peer_getname (tgl_Peer *self, void *closure)
+{
+  PyObject *ret;
+
+  switch(self->peer.id.type) {
+    case TGL_PEER_USER:
+      ret = PyUnicode_FromString(self->peer.user.print_name);
+      break;
+    case TGL_PEER_CHAT:
+      ret = PyUnicode_FromString(self->peer.chat.print_title);
+      break;
+    case TGL_PEER_ENCR_CHAT:
+      ret = PyUnicode_FromString(self->peer.encr_chat.print_name);
+      break;
+    default:
+     PyErr_SetString(PyExc_TypeError, "peer.type not supported!");
+     Py_RETURN_NONE;
+  }
+
+  Py_XINCREF(ret);
+  return ret;
+}
+
+
+static PyObject *
+tgl_Peer_getuser_id (tgl_Peer *self, void *closure)
+{
+  PyObject *ret;
+
+  switch(self->peer.id.type) {
+    case TGL_PEER_USER:
+      ret = PyLong_FromLong(self->peer.id.id);
+      break;
+    case TGL_PEER_CHAT:
+      PyErr_SetString(PyExc_TypeError, "peer.type == TGL_PEER_CHAT has no user_id");
+      Py_RETURN_NONE;
+ 
+      break;
+    case TGL_PEER_ENCR_CHAT:
+      ret = PyLong_FromLong(self->peer.encr_chat.user_id);
+      break;
+    default:
+     PyErr_SetString(PyExc_TypeError, "peer.type not supported!");
+     Py_RETURN_NONE;
+  }
+
+  Py_XINCREF(ret);
+  return ret;
+}
+
+static PyObject *
+tgl_Peer_getuser_list (tgl_Peer *self, void *closure)
+{
+  PyObject *ret, *peer;
+  int i;
+  struct tgl_chat_user *user_list;
+  struct tgl_user *user;
+
+  switch(self->peer.id.type) {
+    case TGL_PEER_CHAT:
+      ret = PyList_New(0);
+        for(i = 0; i < self->peer.chat.user_list_size; i++) {
+        // TODO: Sort tgl_user objects, maybe offline mode is enoug?
+        user_list = self->peer.chat.user_list + i;
+        PyList_Append(ret, PyLong_FromLong(user_list->user_id));
+      }
+      break;
+    case TGL_PEER_ENCR_CHAT:
+    case TGL_PEER_USER:
+      PyErr_SetString(PyExc_TypeError, "Only peer.type == TGL_PEER_CHAT has user_list");
+      Py_RETURN_NONE;
+      break;
+    default:
+     PyErr_SetString(PyExc_TypeError, "peer.type not supported!");
+     Py_RETURN_NONE;
+  }
+
+  Py_XINCREF(ret);
+  return ret;
+}
+
+static PyObject *
+tgl_Peer_getuser_status(tgl_Peer *self, void *closure)
+{
+  PyObject *ret;
+
+  switch(self->peer.id.type) {
+    case TGL_PEER_USER:
+      ret = PyDict_New();
+      PyDict_SetItemString(ret, "online", self->peer.user.status.online? Py_True : Py_False);
+      PyDict_SetItemString(ret, "when", PyDateTime_FromTimestamp(Py_BuildValue("(O)",
+                                        PyLong_FromLong(self->peer.user.status.when))));
+
+      break;
+    case TGL_PEER_CHAT:
+    case TGL_PEER_ENCR_CHAT:
+      PyErr_SetString(PyExc_TypeError, "Only peer.type == TGL_PEER_USER has user_status");
+      Py_RETURN_NONE;
+      break;
+    default:
+     PyErr_SetString(PyExc_TypeError, "peer.type not supported!");
+     Py_RETURN_NONE;
+  }
+
+  Py_XINCREF(ret);
+  return ret;
+}
+
+static PyObject *
+tgl_Peer_getphone (tgl_Peer *self, void *closure)
+{
+  PyObject *ret;
+
+  switch(self->peer.id.type) {
+    case TGL_PEER_USER:
+      ret = PyUnicode_FromString(self->peer.user.phone);
+      break;
+    case TGL_PEER_CHAT:
+    case TGL_PEER_ENCR_CHAT:
+      PyErr_SetString(PyExc_TypeError, "Only peer.type == TGL_PEER_USER has phone");
+      Py_RETURN_NONE;
+      break;
+    default:
+     PyErr_SetString(PyExc_TypeError, "peer.type not supported!");
+     Py_RETURN_NONE;
+  }
+
+  Py_XINCREF(ret);
+  return ret;
+}
+
+static PyObject *
+tgl_Peer_getusername (tgl_Peer *self, void *closure)
+{
+  PyObject *ret;
+
+  switch(self->peer.id.type) {
+    case TGL_PEER_USER:
+      ret = PyUnicode_FromString(self->peer.user.username);
+      break;
+    case TGL_PEER_CHAT:
+    case TGL_PEER_ENCR_CHAT:
+      PyErr_SetString(PyExc_TypeError, "Only peer.type == TGL_PEER_USER has username");
+      Py_RETURN_NONE;
+      break;
+    default:
+     PyErr_SetString(PyExc_TypeError, "peer.type not supported!");
+     Py_RETURN_NONE;
+  }
+
+  Py_XINCREF(ret);
+  return ret;
+}
+
+static PyGetSetDef tgl_Peer_getseters[] = {
+  {"name", (getter)tgl_Peer_getname, NULL, "", NULL},
+  {"user_id", (getter)tgl_Peer_getuser_id, NULL, "", NULL},
+  {"user_list", (getter)tgl_Peer_getuser_list, NULL, "", NULL},
+  {"user_status", (getter)tgl_Peer_getuser_status, NULL, "", NULL},
+  {"phone", (getter)tgl_Peer_getphone, NULL, "", NULL},
+  {"username", (getter)tgl_Peer_getusername, NULL, "", NULL},
+  {NULL}  /* Sentinel */
+};
+
+static PyMemberDef tgl_Peer_members[] = {
+  {"type", T_INT, offsetof(tgl_Peer, peer.id.type), 0, "Peer Type"},
+  {"id", T_INT, offsetof(tgl_Peer, peer.id.id),     0, "Peer ID"  },
+  {NULL}  /* Sentinel */
+};
+
+static PyObject *
+tgl_Peer_type_name(tgl_Peer* self)
+{
+  PyObject *name;
+
+  switch(self->peer.id.type) {
+    case TGL_PEER_USER:
+      name = PyUnicode_FromString("user");
+      break;
+    case TGL_PEER_CHAT:
+      name = PyUnicode_FromString("chat");
+      break;
+    case TGL_PEER_ENCR_CHAT:
+      name = PyUnicode_FromString("encr_chat");
+      break;
+    default:
+      name = PyUnicode_FromString("unknown");
+    }
+  return name;
+}
+
+static PyMethodDef tgl_Peer_methods[] = {
+  {"type_name", (PyCFunction)tgl_Peer_type_name, METH_NOARGS,
+    "Return the string representation of the peer type."
+  },
+  {NULL}  /* Sentinel */
+};
+
+
+PyTypeObject tgl_PeerType = {
+    PyVarObject_HEAD_INIT(NULL, 0)
+    "tgl.Peer",                   /* tp_name */
+    sizeof(tgl_Peer),             /* tp_basicsize */
+    0,                            /* tp_itemsize */
+    (destructor)tgl_Peer_dealloc, /* tp_dealloc */
+    0,                            /* tp_print */
+    0,                            /* tp_getattr */
+    0,                            /* tp_setattr */
+    0,                            /* tp_reserved */
+    0,                            /* tp_repr */
+    0,                            /* tp_as_number */
+    0,                            /* tp_as_sequence */
+    0,                            /* tp_as_mapping */
+    0,                            /* tp_hash  */
+    0,                            /* tp_call */
+    0,                            /* tp_str */
+    0,                            /* tp_getattro */
+    0,                            /* tp_setattro */
+    0,                            /* tp_as_buffer */
+    Py_TPFLAGS_DEFAULT,           /* tp_flags */
+    "tgl Peer",                   /* tp_doc */
+    0,                            /* tp_traverse */
+    0,                            /* tp_clear */
+    0,                            /* tp_richcompare */
+    0,                            /* tp_weaklistoffset */
+    0,                            /* tp_iter */
+    0,                            /* tp_iternext */
+    tgl_Peer_methods,             /* tp_methods */
+    tgl_Peer_members,             /* tp_members */
+    tgl_Peer_getseters,           /* tp_getset */
+    0,                            /* tp_base */
+    0,                            /* tp_dict */
+    0,                            /* tp_descr_get */
+    0,                            /* tp_descr_set */
+    0,                            /* tp_dictoffset */
+    (initproc)tgl_Peer_init,      /* tp_init */
+    0,                            /* tp_alloc */
+    tgl_Peer_new,                 /* tp_new */
+};
+
+
+PyObject *
+tgl_Peer_FromTglPeer(tgl_peer_t *peer) {
+  tgl_Peer *self = (tgl_Peer *) tgl_Peer_new((PyTypeObject *)&tgl_PeerType, Py_None, Py_None);
+
+  memcpy(&self->peer, peer, sizeof(tgl_peer_t));
+
+  switch(self->peer.id.type) {
+  case TGL_PEER_USER:
+    // print_name
+    if(peer->user.print_name) {
+      self->peer.user.print_name = (char*)malloc(strlen(peer->user.print_name));
+      memcpy(self->peer.user.print_name, peer->user.print_name, strlen(peer->user.print_name));
+    }
+    // phone
+    if(peer->user.phone) {
+      self->peer.user.phone = (char*)malloc(strlen(peer->user.phone));
+      memcpy(self->peer.user.phone, peer->user.phone, strlen(peer->user.phone));
+    }
+    // username
+    if(peer->user.username) {
+      self->peer.user.username = (char*)malloc(strlen(peer->user.username));
+      memcpy(self->peer.user.username, peer->user.username, strlen(peer->user.username));
+    }
+    break;
+  case TGL_PEER_CHAT:
+    // print_title
+    if(peer->chat.print_title) {
+      self->peer.chat.print_title = (char*)malloc(strlen(peer->chat.print_title));
+      memcpy(self->peer.chat.print_title, peer->chat.print_title, strlen(peer->chat.print_title));
+    }
+    // user_list
+    if(peer->chat.user_list_size > 0) {
+      self->peer.chat.user_list = (struct tgl_chat_user*)malloc(self->peer.chat.user_list_size * 
+                                                                sizeof(struct tgl_chat_user));
+      memcpy(self->peer.chat.user_list, peer->chat.user_list, 
+             peer->chat.user_list_size * sizeof(struct tgl_chat_user));
+    }
+    break;
+  case TGL_PEER_ENCR_CHAT:
+    // print_name
+    if(peer->encr_chat.print_name) {
+      self->peer.encr_chat.print_name = (char*)malloc(strlen(peer->encr_chat.print_name));
+      memcpy(self->peer.encr_chat.print_name, peer->encr_chat.print_name, strlen(peer->encr_chat.print_name));
+    }
+    // g_key
+    if(peer->encr_chat.g_key) {
+      self->peer.encr_chat.g_key = (unsigned char*)malloc(256);
+      memcpy(self->peer.encr_chat.g_key, peer->encr_chat.g_key, 256);
+    }
+    break;
+  default:
+    assert(0);
+  }
+
+  return (PyObject *) self;
+}

python-types.h

@@ -3,380 +3,12 @@
 
 #include <Python.h>
 #include <tgl/tgl.h>
-#include <tgl/tools.h>
-#include <tgl/updates.h>
-#include <tgl/tgl-structures.h>
-#include <stdlib.h>
-#include <Python.h>
-#include "structmember.h"
 
 typedef struct {
   PyObject_HEAD
   tgl_peer_t peer;
 } tgl_Peer;
 
-extern struct tgl_state *TLS;
-
-// modeled after tgls_free_peer 
-static void
-tgl_Peer_dealloc(tgl_Peer* self)
-{
-  switch(self->peer.id.type) {
-    case TGL_PEER_USER:
-      if (self->peer.user.first_name) tfree_str(self->peer.user.first_name);
-      if (self->peer.user.last_name) tfree_str(self->peer.user.last_name);
-      if (self->peer.user.print_name) tfree_str(self->peer.user.print_name);
-      if (self->peer.user.phone) tfree_str(self->peer.user.phone);
-      if (self->peer.user.real_first_name) tfree_str(self->peer.user.real_first_name);
-      if (self->peer.user.real_last_name) tfree_str(self->peer.user.real_last_name);
-      if (self->peer.user.status.ev) { tgl_remove_status_expire (TLS, &self->peer.user); }
-      tgls_free_photo (TLS, self->peer.user.photo);
-      break;
-    case TGL_PEER_CHAT:
-      if (self->peer.chat.title) tfree_str(self->peer.chat.title);
-      if (self->peer.chat.print_title) tfree_str(self->peer.chat.print_title);
-      if (self->peer.chat.user_list) 
-        tfree(self->peer.chat.user_list, self->peer.chat.user_list_size * sizeof(struct tgl_chat_user));
-      tgls_free_photo (TLS, self->peer.chat.photo);
-      break;
-    case TGL_PEER_ENCR_CHAT:
-      if (self->peer.encr_chat.print_name) tfree_str(self->peer.encr_chat.print_name);
-      if (self->peer.encr_chat.g_key) tfree (self->peer.encr_chat.g_key, 256);
-      break;
-    default:
-     PyErr_SetString(PyExc_TypeError, "peer.type not supported!");
-  }
- 
-  Py_TYPE(self)->tp_free((PyObject*)self);
-}
-
-static PyObject *
-tgl_Peer_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
-{
-  tgl_Peer *self;
-
-  self = (tgl_Peer *)type->tp_alloc(type, 0);
-  if (self != NULL) {
-    self->peer.id.type = 0;
-    self->peer.id.id = 0;
-  }
-
-  return (PyObject *)self;
-}
-
-
-
-static int
-tgl_Peer_init(tgl_Peer *self, PyObject *args, PyObject *kwds)
-{
-  static char *kwlist[] = {"type", "id", NULL};
-
-  if(!PyArg_ParseTupleAndKeywords(args, kwds, "|ii", kwlist, 
-                                  &self->peer.id.type,
-                                  &self->peer.id.id))
-    return -1;
-
-  return 0;
-}
-
-static PyObject *
-tgl_Peer_getname (tgl_Peer *self, void *closure)
-{
-  PyObject *ret;
-
-  switch(self->peer.id.type) {
-    case TGL_PEER_USER:
-      ret = PyUnicode_FromString(self->peer.user.print_name);
-      break;
-    case TGL_PEER_CHAT:
-      ret = PyUnicode_FromString(self->peer.chat.print_title);
-      break;
-    case TGL_PEER_ENCR_CHAT:
-      ret = PyUnicode_FromString(self->peer.encr_chat.print_name);
-      break;
-    default:
-     PyErr_SetString(PyExc_TypeError, "peer.type not supported!");
-     Py_RETURN_NONE;
-  }
-
-
-  Py_XINCREF(ret);
-  return ret;
-}
-
-
-static PyObject *
-tgl_Peer_getuser_id (tgl_Peer *self, void *closure)
-{
-  PyObject *ret;
-
-  switch(self->peer.id.type) {
-    case TGL_PEER_USER:
-      ret = PyLong_FromLong(self->peer.id.id);
-      break;
-    case TGL_PEER_CHAT:
-      PyErr_SetString(PyExc_TypeError, "peer.type == TGL_PEER_CHAT has no user_id");
-      Py_RETURN_NONE;
- 
-      break;
-    case TGL_PEER_ENCR_CHAT:
-      ret = PyLong_FromLong(self->peer.encr_chat.user_id);
-      break;
-    default:
-     PyErr_SetString(PyExc_TypeError, "peer.type not supported!");
-     Py_RETURN_NONE;
-  }
-
-  Py_XINCREF(ret);
-  return ret;
-}
-
-static PyObject *
-tgl_Peer_getuser_list (tgl_Peer *self, void *closure)
-{
-  PyObject *ret, *peer;
-  int i;
-  struct tgl_chat_user *user_list;
-  struct tgl_user *user;
-
-  switch(self->peer.id.type) {
-    case TGL_PEER_CHAT:
-      ret = PyList_New(0);
-        for(i = 0; i < self->peer.chat.user_list_size; i++) {
-        // TODO: Sort tgl_user objects, maybe offline mode is enoug?
-        user_list = self->peer.chat.user_list + i;
-        PyList_Append(ret, PyLong_FromLong(user_list->user_id));
-      }
-      break;
-    case TGL_PEER_ENCR_CHAT:
-    case TGL_PEER_USER:
-      PyErr_SetString(PyExc_TypeError, "Only peer.type == TGL_PEER_CHAT has user_list");
-      Py_RETURN_NONE;
-      break;
-    default:
-     PyErr_SetString(PyExc_TypeError, "peer.type not supported!");
-     Py_RETURN_NONE;
-  }
-
-  Py_XINCREF(ret);
-  return ret;
-}
-
-static PyObject *
-tgl_Peer_getuser_status(tgl_Peer *self, void *closure)
-{
-  PyObject *ret;
-
-  switch(self->peer.id.type) {
-    case TGL_PEER_USER:
-      ret = PyDict_New();
-      PyDict_SetItemString(ret, "online", self->peer.user.status.online? Py_True : Py_False);
-      PyDict_SetItemString(ret, "when", PyDateTime_FromTimestamp(Py_BuildValue("(O)",
-                                        PyLong_FromLong(self->peer.user.status.when))));
-
-      break;
-    case TGL_PEER_CHAT:
-    case TGL_PEER_ENCR_CHAT:
-      PyErr_SetString(PyExc_TypeError, "Only peer.type == TGL_PEER_USER has user_status");
-      Py_RETURN_NONE;
-      break;
-    default:
-     PyErr_SetString(PyExc_TypeError, "peer.type not supported!");
-     Py_RETURN_NONE;
-  }
-
-  Py_XINCREF(ret);
-  return ret;
-}
-
-static PyObject *
-tgl_Peer_getphone (tgl_Peer *self, void *closure)
-{
-  PyObject *ret;
-
-  switch(self->peer.id.type) {
-    case TGL_PEER_USER:
-      ret = PyUnicode_FromString(self->peer.user.phone);
-      break;
-    case TGL_PEER_CHAT:
-    case TGL_PEER_ENCR_CHAT:
-      PyErr_SetString(PyExc_TypeError, "Only peer.type == TGL_PEER_USER has phone");
-      Py_RETURN_NONE;
-      break;
-    default:
-     PyErr_SetString(PyExc_TypeError, "peer.type not supported!");
-     Py_RETURN_NONE;
-  }
-
-  Py_XINCREF(ret);
-  return ret;
-}
-
-static PyObject *
-tgl_Peer_getusername (tgl_Peer *self, void *closure)
-{
-  PyObject *ret;
-
-  switch(self->peer.id.type) {
-    case TGL_PEER_USER:
-      ret = PyUnicode_FromString(self->peer.user.username);
-      break;
-    case TGL_PEER_CHAT:
-    case TGL_PEER_ENCR_CHAT:
-      PyErr_SetString(PyExc_TypeError, "Only peer.type == TGL_PEER_USER has username");
-      Py_RETURN_NONE;
-      break;
-    default:
-     PyErr_SetString(PyExc_TypeError, "peer.type not supported!");
-     Py_RETURN_NONE;
-  }
-
-  Py_XINCREF(ret);
-  return ret;
-}
-
-static PyGetSetDef tgl_Peer_getseters[] = {
-  {"name", (getter)tgl_Peer_getname, NULL, "", NULL},
-  {"user_id", (getter)tgl_Peer_getuser_id, NULL, "", NULL},
-  {"user_list", (getter)tgl_Peer_getuser_list, NULL, "", NULL},
-  {"user_status", (getter)tgl_Peer_getuser_status, NULL, "", NULL},
-  {"phone", (getter)tgl_Peer_getphone, NULL, "", NULL},
-  {"username", (getter)tgl_Peer_getusername, NULL, "", NULL},
-  {NULL}  /* Sentinel */
-};
-
-static PyMemberDef tgl_Peer_members[] = {
-  {"type", T_INT, offsetof(tgl_Peer, peer.id.type), 0, "Peer Type"},
-  {"id", T_INT, offsetof(tgl_Peer, peer.id.id),     0, "Peer ID"  },
-  {NULL}  /* Sentinel */
-};
-
-static PyObject *
-tgl_Peer_type_name(tgl_Peer* self)
-{
-  PyObject *name;
-
-  switch(self->peer.id.type) {
-    case TGL_PEER_USER:
-      name = PyUnicode_FromString("user");
-      break;
-    case TGL_PEER_CHAT:
-      name = PyUnicode_FromString("chat");
-      break;
-    case TGL_PEER_ENCR_CHAT:
-      name = PyUnicode_FromString("encr_chat");
-      break;
-    default:
-      name = PyUnicode_FromString("unknown");
-    }
-  return name;
-}
-
-static PyMethodDef tgl_Peer_methods[] = {
-  {"type_name", (PyCFunction)tgl_Peer_type_name, METH_NOARGS,
-    "Return the string representation of the peer type."
-  },
-  {NULL}  /* Sentinel */
-};
-
-
-static PyTypeObject tgl_PeerType = {
-    PyVarObject_HEAD_INIT(NULL, 0)
-    "tgl.Peer",                   /* tp_name */
-    sizeof(tgl_Peer),             /* tp_basicsize */
-    0,                            /* tp_itemsize */
-    (destructor)tgl_Peer_dealloc, /* tp_dealloc */
-    0,                            /* tp_print */
-    0,                            /* tp_getattr */
-    0,                            /* tp_setattr */
-    0,                            /* tp_reserved */
-    0,                            /* tp_repr */
-    0,                            /* tp_as_number */
-    0,                            /* tp_as_sequence */
-    0,                            /* tp_as_mapping */
-    0,                            /* tp_hash  */
-    0,                            /* tp_call */
-    0,                            /* tp_str */
-    0,                            /* tp_getattro */
-    0,                            /* tp_setattro */
-    0,                            /* tp_as_buffer */
-    Py_TPFLAGS_DEFAULT,           /* tp_flags */
-    "tgl Peer",                   /* tp_doc */
-    0,                            /* tp_traverse */
-    0,                            /* tp_clear */
-    0,                            /* tp_richcompare */
-    0,                            /* tp_weaklistoffset */
-    0,                            /* tp_iter */
-    0,                            /* tp_iternext */
-    tgl_Peer_methods,             /* tp_methods */
-    tgl_Peer_members,             /* tp_members */
-    tgl_Peer_getseters,           /* tp_getset */
-    0,                            /* tp_base */
-    0,                            /* tp_dict */
-    0,                            /* tp_descr_get */
-    0,                            /* tp_descr_set */
-    0,                            /* tp_dictoffset */
-    (initproc)tgl_Peer_init,      /* tp_init */
-    0,                            /* tp_alloc */
-    tgl_Peer_new,                 /* tp_new */
-};
-
-
-static PyObject *
-tgl_Peer_FromTglPeer(tgl_peer_t *peer) {
-  tgl_Peer *self = (tgl_Peer *) tgl_Peer_new((PyTypeObject *)&tgl_PeerType, Py_None, Py_None);
-
-  memcpy(&self->peer, peer, sizeof(tgl_peer_t));
-
-  switch(self->peer.id.type) {
-  case TGL_PEER_USER:
-    // print_name
-    if(peer->user.print_name) {
-      self->peer.user.print_name = (char*)malloc(strlen(peer->user.print_name));
-      memcpy(self->peer.user.print_name, peer->user.print_name, strlen(peer->user.print_name));
-    }
-    // phone
-    if(peer->user.phone) {
-      self->peer.user.phone = (char*)malloc(strlen(peer->user.phone));
-      memcpy(self->peer.user.phone, peer->user.phone, strlen(peer->user.phone));
-    }
-    // username
-    if(peer->user.username) {
-      self->peer.user.username = (char*)malloc(strlen(peer->user.username));
-      memcpy(self->peer.user.username, peer->user.username, strlen(peer->user.username));
-    }
-    break;
-  case TGL_PEER_CHAT:
-    // print_title
-    if(peer->chat.print_title) {
-      self->peer.chat.print_title = (char*)malloc(strlen(peer->chat.print_title));
-      memcpy(self->peer.chat.print_title, peer->chat.print_title, strlen(peer->chat.print_title));
-    }
-    // user_list
-    if(peer->chat.user_list_size > 0) {
-      self->peer.chat.user_list = (struct tgl_chat_user*)malloc(self->peer.chat.user_list_size * 
-                                                                sizeof(struct tgl_chat_user));
-      memcpy(self->peer.chat.user_list, peer->chat.user_list, 
-             peer->chat.user_list_size * sizeof(struct tgl_chat_user));
-    }
-    break;
-  case TGL_PEER_ENCR_CHAT:
-    // print_name
-    if(peer->encr_chat.print_name) {
-      self->peer.encr_chat.print_name = (char*)malloc(strlen(peer->encr_chat.print_name));
-      memcpy(self->peer.encr_chat.print_name, peer->encr_chat.print_name, strlen(peer->encr_chat.print_name));
-    }
-    // g_key
-    if(peer->encr_chat.g_key) {
-      self->peer.encr_chat.g_key = (unsigned char*)malloc(256);
-      memcpy(self->peer.encr_chat.g_key, peer->encr_chat.g_key, 256);
-    }
-    break;
-  default:
-    assert(0);
-  }
-
-  return (PyObject *) self;
-}
+PyObject * tgl_Peer_FromTglPeer(tgl_peer_t *peer);
 
 #endif