diff --git a/compiler/cpp/src/generate/t_py_generator.cc b/compiler/cpp/src/generate/t_py_generator.cc
index 4cdcd9f..26d2b8e 100644
--- a/compiler/cpp/src/generate/t_py_generator.cc
+++ b/compiler/cpp/src/generate/t_py_generator.cc
@@ -284,6 +284,7 @@
   std::ofstream f_service_;
 
   std::string package_dir_;
+  std::string module_;
 
 };
 
@@ -298,6 +299,7 @@
   // Make output directory
   string module = get_real_py_module(program_, gen_twisted_);
   package_dir_ = get_out_dir();
+  module_ = module;
   while (true) {
     // TODO: Do better error checking here.
     MKDIR(package_dir_.c_str());
@@ -1404,6 +1406,13 @@
  */
 void t_py_generator::generate_service_remote(t_service* tservice) {
   vector<t_function*> functions = tservice->get_functions();
+  //Get all function from parents  
+  t_service* parent = tservice->get_extends();
+  while(parent != NULL) {
+    vector<t_function*> p_functions = parent->get_functions();
+    functions.insert(functions.end(), p_functions.begin(), p_functions.end());
+    parent = parent->get_extends();
+  }
   vector<t_function*>::iterator f_iter;
 
   string f_remote_name = package_dir_+"/"+service_name_+"-remote";
@@ -1423,8 +1432,8 @@
     endl;
 
   f_remote <<
-    "import " << service_name_ << endl <<
-    "from ttypes import *" << endl <<
+    "from " << module_ << " import " << service_name_ << endl <<
+    "from " << module_ << ".ttypes import *" << endl <<
     endl;
 
   f_remote <<
