2 * Licensed to the Apache Software Foundation (ASF) under one
3 * or more contributor license agreements. See the NOTICE file
4 * distributed with this work for additional information
5 * regarding copyright ownership. The ASF licenses this file
6 * to you under the Apache License, Version 2.0 (the
7 * "License"); you may not use this file except in compliance
8 * with the License. You may obtain a copy of the License at
10 * http://www.apache.org/licenses/LICENSE-2.0
12 * Unless required by applicable law or agreed to in writing,
13 * software distributed under the License is distributed on an
14 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
15 * KIND, either express or implied. See the License for the
16 * specific language governing permissions and limitations
29 #include <sys/types.h>
32 #include "thrift/platform.h"
33 #include "thrift/version.h"
34 #include "thrift/generate/t_generator.h"
38 using std::ostringstream
;
40 using std::stringstream
;
43 static const string endl
= "\n"; // avoid ostream << std::endl flushes
46 * Python code generator.
49 class t_py_generator
: public t_generator
{
51 t_py_generator(t_program
* program
,
52 const std::map
<std::string
, std::string
>& parsed_options
,
53 const std::string
& option_string
)
54 : t_generator (program
) {
55 std::map
<std::string
, std::string
>::const_iterator iter
;
58 gen_utf8strings_
= true;
62 gen_zope_interface_
= false;
66 gen_dynbaseclass_
= "";
67 gen_dynbaseclass_exc_
= "";
68 gen_dynbaseclass_frozen_
= "";
71 for( iter
= parsed_options
.begin(); iter
!= parsed_options
.end(); ++iter
) {
72 if( iter
->first
.compare("new_style") == 0) {
73 pwarning(0, "new_style is enabled by default, so the option will be removed in the near future.\n");
74 } else if( iter
->first
.compare("old_style") == 0) {
75 gen_newstyle_
= false;
76 pwarning(0, "old_style is deprecated and may be removed in the future.\n");
77 } else if( iter
->first
.compare("utf8strings") == 0) {
78 pwarning(0, "utf8strings is enabled by default, so the option will be removed in the near future.\n");
79 } else if( iter
->first
.compare("no_utf8strings") == 0) {
80 gen_utf8strings_
= false;
81 } else if( iter
->first
.compare("slots") == 0) {
83 } else if( iter
->first
.compare("package_prefix") == 0) {
84 package_prefix_
= iter
->second
;
85 } else if( iter
->first
.compare("dynamic") == 0) {
87 gen_newstyle_
= false; // dynamic is newstyle
88 if( gen_dynbaseclass_
.empty()) {
89 gen_dynbaseclass_
= "TBase";
91 if( gen_dynbaseclass_frozen_
.empty()) {
92 gen_dynbaseclass_frozen_
= "TFrozenBase";
94 if( gen_dynbaseclass_exc_
.empty()) {
95 gen_dynbaseclass_exc_
= "TExceptionBase";
97 if( import_dynbase_
.empty()) {
98 import_dynbase_
= "from thrift.protocol.TBase import TBase, TFrozenBase, TExceptionBase, TTransport\n";
100 } else if( iter
->first
.compare("dynbase") == 0) {
102 gen_dynbaseclass_
= (iter
->second
);
103 } else if( iter
->first
.compare("dynfrozen") == 0) {
104 gen_dynbaseclass_frozen_
= (iter
->second
);
105 } else if( iter
->first
.compare("dynexc") == 0) {
106 gen_dynbaseclass_exc_
= (iter
->second
);
107 } else if( iter
->first
.compare("dynimport") == 0) {
109 import_dynbase_
= (iter
->second
);
110 } else if( iter
->first
.compare("zope.interface") == 0) {
111 gen_zope_interface_
= true;
112 } else if( iter
->first
.compare("twisted") == 0) {
114 gen_zope_interface_
= true;
115 } else if( iter
->first
.compare("tornado") == 0) {
117 } else if( iter
->first
.compare("coding") == 0) {
118 coding_
= iter
->second
;
120 throw "unknown option py:" + iter
->first
;
124 if (gen_twisted_
&& gen_tornado_
) {
125 throw "at most one of 'twisted' and 'tornado' are allowed";
128 copy_options_
= option_string
;
131 out_dir_base_
= "gen-py.twisted";
132 } else if (gen_tornado_
) {
133 out_dir_base_
= "gen-py.tornado";
135 out_dir_base_
= "gen-py";
139 std::string
indent_str() const override
{
144 * Init and close methods
147 void init_generator() override
;
148 void close_generator() override
;
151 * Program-level generation functions
154 void generate_typedef(t_typedef
* ttypedef
) override
;
155 void generate_enum(t_enum
* tenum
) override
;
156 void generate_const(t_const
* tconst
) override
;
157 void generate_struct(t_struct
* tstruct
) override
;
158 void generate_forward_declaration(t_struct
* tstruct
) override
;
159 void generate_xception(t_struct
* txception
) override
;
160 void generate_service(t_service
* tservice
) override
;
162 std::string
render_const_value(t_type
* type
, t_const_value
* value
);
165 * Struct generation code
168 void generate_py_struct(t_struct
* tstruct
, bool is_exception
);
169 void generate_py_thrift_spec(std::ostream
& out
, t_struct
* tstruct
, bool is_exception
);
170 void generate_py_struct_definition(std::ostream
& out
,
172 bool is_xception
= false);
173 void generate_py_struct_reader(std::ostream
& out
, t_struct
* tstruct
);
174 void generate_py_struct_writer(std::ostream
& out
, t_struct
* tstruct
);
175 void generate_py_struct_required_validator(std::ostream
& out
, t_struct
* tstruct
);
176 void generate_py_function_helpers(t_function
* tfunction
);
179 * Service-level generation functions
182 void generate_service_helpers(t_service
* tservice
);
183 void generate_service_interface(t_service
* tservice
);
184 void generate_service_client(t_service
* tservice
);
185 void generate_service_remote(t_service
* tservice
);
186 void generate_service_server(t_service
* tservice
);
187 void generate_process_function(t_service
* tservice
, t_function
* tfunction
);
190 * Serialization constructs
193 void generate_deserialize_field(std::ostream
& out
,
195 std::string prefix
= "");
197 void generate_deserialize_struct(std::ostream
& out
, t_struct
* tstruct
, std::string prefix
= "");
199 void generate_deserialize_container(std::ostream
& out
, t_type
* ttype
, std::string prefix
= "");
201 void generate_deserialize_set_element(std::ostream
& out
, t_set
* tset
, std::string prefix
= "");
203 void generate_deserialize_map_element(std::ostream
& out
, t_map
* tmap
, std::string prefix
= "");
205 void generate_deserialize_list_element(std::ostream
& out
,
207 std::string prefix
= "");
209 void generate_serialize_field(std::ostream
& out
, t_field
* tfield
, std::string prefix
= "");
211 void generate_serialize_struct(std::ostream
& out
, t_struct
* tstruct
, std::string prefix
= "");
213 void generate_serialize_container(std::ostream
& out
, t_type
* ttype
, std::string prefix
= "");
215 void generate_serialize_map_element(std::ostream
& out
,
220 void generate_serialize_set_element(std::ostream
& out
, t_set
* tmap
, std::string iter
);
222 void generate_serialize_list_element(std::ostream
& out
, t_list
* tlist
, std::string iter
);
224 void generate_python_docstring(std::ostream
& out
, t_struct
* tstruct
);
226 void generate_python_docstring(std::ostream
& out
, t_function
* tfunction
);
228 void generate_python_docstring(std::ostream
& out
,
231 const char* subheader
);
233 void generate_python_docstring(std::ostream
& out
, t_doc
* tdoc
);
236 * Helper rendering functions
239 std::string
py_autogen_comment();
240 std::string
py_imports();
241 std::string
render_includes();
242 std::string
declare_argument(t_field
* tfield
);
243 std::string
render_field_default_value(t_field
* tfield
);
244 std::string
type_name(t_type
* ttype
);
245 std::string
function_signature(t_function
* tfunction
, bool interface
= false);
246 std::string
argument_list(t_struct
* tstruct
,
247 std::vector
<std::string
>* pre
= NULL
,
248 std::vector
<std::string
>* post
= NULL
);
249 std::string
type_to_enum(t_type
* ttype
);
250 std::string
type_to_spec_args(t_type
* ttype
);
252 static bool is_valid_namespace(const std::string
& sub_namespace
) {
253 return sub_namespace
== "twisted";
256 static std::string
get_real_py_module(const t_program
* program
, bool gen_twisted
, std::string package_dir
="") {
258 std::string twisted_module
= program
->get_namespace("py.twisted");
259 if (!twisted_module
.empty()) {
260 return twisted_module
;
264 std::string real_module
= program
->get_namespace("py");
265 if (real_module
.empty()) {
266 return program
->get_name();
268 return package_dir
+ real_module
;
271 static bool is_immutable(t_type
* ttype
) {
272 return ttype
->annotations_
.find("python.immutable") != ttype
->annotations_
.end();
278 * True if we should generate new-style classes.
283 * True if we should generate dynamic style classes.
288 std::string gen_dynbaseclass_
;
289 std::string gen_dynbaseclass_frozen_
;
290 std::string gen_dynbaseclass_exc_
;
292 std::string import_dynbase_
;
296 std::string copy_options_
;
299 * True if we should generate code for use with zope.interface.
301 bool gen_zope_interface_
;
304 * True if we should generate Twisted-friendly RPC services.
309 * True if we should generate code for use with Tornado
314 * True if strings should be encoded using utf-8.
316 bool gen_utf8strings_
;
319 * specify generated file encoding
320 * eg. # -*- coding: utf-8 -*-
324 string package_prefix_
;
330 ofstream_with_content_based_conditional_update f_types_
;
331 ofstream_with_content_based_conditional_update f_consts_
;
332 ofstream_with_content_based_conditional_update f_service_
;
334 std::string package_dir_
;
338 std::set
<std::string
> lang_keywords() const override
{
339 std::string keywords
[] = { "False", "None", "True", "and", "as", "assert", "break", "class",
340 "continue", "def", "del", "elif", "else", "except", "exec", "finally", "for", "from",
341 "global", "if", "import", "in", "is", "lambda", "nonlocal", "not", "or", "pass", "print",
342 "raise", "return", "try", "while", "with", "yield" };
343 return std::set
<std::string
>(keywords
, keywords
+ sizeof(keywords
)/sizeof(keywords
[0]) );
348 * Prepares for file generation by opening up the necessary file output
351 * @param tprogram The program to generate
353 void t_py_generator::init_generator() {
354 // Make output directory
355 string module
= get_real_py_module(program_
, gen_twisted_
);
356 package_dir_
= get_out_dir();
359 // TODO: Do better error checking here.
360 MKDIR(package_dir_
.c_str());
361 std::ofstream
init_py((package_dir_
+ "/__init__.py").c_str(), std::ios_base::app
);
363 if (module
.empty()) {
366 string::size_type pos
= module
.find('.');
367 if (pos
== string::npos
) {
369 package_dir_
+= module
;
373 package_dir_
+= module
.substr(0, pos
);
374 module
.erase(0, pos
+ 1);
379 string f_types_name
= package_dir_
+ "/" + "ttypes.py";
380 f_types_
.open(f_types_name
.c_str());
382 string f_consts_name
= package_dir_
+ "/" + "constants.py";
383 f_consts_
.open(f_consts_name
.c_str());
385 string f_init_name
= package_dir_
+ "/__init__.py";
386 ofstream_with_content_based_conditional_update f_init
;
387 f_init
.open(f_init_name
.c_str());
388 f_init
<< "__all__ = ['ttypes', 'constants'";
389 vector
<t_service
*> services
= program_
->get_services();
390 vector
<t_service
*>::iterator sv_iter
;
391 for (sv_iter
= services
.begin(); sv_iter
!= services
.end(); ++sv_iter
) {
392 f_init
<< ", '" << (*sv_iter
)->get_name() << "'";
394 f_init
<< "]" << endl
;
398 f_types_
<< py_autogen_comment() << endl
399 << py_imports() << endl
400 << render_includes() << endl
401 << "from thrift.transport import TTransport" << endl
404 f_types_
<< "all_structs = []" << endl
;
407 py_autogen_comment() << endl
<<
408 py_imports() << endl
<<
409 "from .ttypes import *" << endl
;
413 * Renders all the imports necessary for including another Thrift program
415 string
t_py_generator::render_includes() {
416 const vector
<t_program
*>& includes
= program_
->get_includes();
418 for (auto include
: includes
) {
419 result
+= "import " + get_real_py_module(include
, gen_twisted_
, package_prefix_
) + ".ttypes\n";
427 string
t_py_generator::py_autogen_comment() {
429 if (!coding_
.empty()) {
430 coding
= "# -*- coding: " + coding_
+ " -*-\n";
432 return coding
+ std::string("#\n") + "# Autogenerated by Thrift Compiler (" + THRIFT_VERSION
+ ")\n"
433 + "#\n" + "# DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING\n" + "#\n"
434 + "# options string: " + copy_options_
+ "\n" + "#\n";
438 * Prints standard thrift imports
440 string
t_py_generator::py_imports() {
442 ss
<< "from thrift.Thrift import TType, TMessageType, TFrozenDict, TException, "
443 "TApplicationException"
445 << "from thrift.protocol.TProtocol import TProtocolException"
447 << "from thrift.TRecursive import fix_spec"
450 if (gen_utf8strings_
) {
451 ss
<< endl
<< "import sys";
457 * Closes the type files
459 void t_py_generator::close_generator() {
461 // Fix thrift_spec definitions for recursive structs.
462 f_types_
<< "fix_spec(all_structs)" << endl
;
463 f_types_
<< "del all_structs" << endl
;
471 * Generates a typedef. This is not done in Python, types are all implicit.
473 * @param ttypedef The type definition
475 void t_py_generator::generate_typedef(t_typedef
* ttypedef
) {
480 * Generates code for an enumerated type. Done using a class to scope
483 * @param tenum The enumeration
485 void t_py_generator::generate_enum(t_enum
* tenum
) {
486 std::ostringstream to_string_mapping
, from_string_mapping
;
488 f_types_
<< endl
<< endl
<< "class " << tenum
->get_name() << (gen_newstyle_
? "(object)" : "")
489 << (gen_dynamic_
? "(" + gen_dynbaseclass_
+ ")" : "") << ":" << endl
;
491 generate_python_docstring(f_types_
, tenum
);
493 to_string_mapping
<< indent() << "_VALUES_TO_NAMES = {" << endl
;
494 from_string_mapping
<< indent() << "_NAMES_TO_VALUES = {" << endl
;
496 vector
<t_enum_value
*> constants
= tenum
->get_constants();
497 vector
<t_enum_value
*>::iterator c_iter
;
498 for (c_iter
= constants
.begin(); c_iter
!= constants
.end(); ++c_iter
) {
499 int value
= (*c_iter
)->get_value();
500 indent(f_types_
) << (*c_iter
)->get_name() << " = " << value
<< endl
;
502 // Dictionaries to/from string names of enums
503 to_string_mapping
<< indent() << indent() << value
<< ": \""
504 << escape_string((*c_iter
)->get_name()) << "\"," << endl
;
505 from_string_mapping
<< indent() << indent() << '"' << escape_string((*c_iter
)->get_name())
506 << "\": " << value
<< ',' << endl
;
508 to_string_mapping
<< indent() << "}" << endl
;
509 from_string_mapping
<< indent() << "}" << endl
;
513 f_types_
<< to_string_mapping
.str() << endl
<< from_string_mapping
.str();
517 * Generate a constant value
519 void t_py_generator::generate_const(t_const
* tconst
) {
520 t_type
* type
= tconst
->get_type();
521 string name
= tconst
->get_name();
522 t_const_value
* value
= tconst
->get_value();
524 indent(f_consts_
) << name
<< " = " << render_const_value(type
, value
);
529 * Prints the value of a constant with the given type. Note that type checking
530 * is NOT performed in this function as it is always run beforehand using the
531 * validate_types method in main.cc
533 string
t_py_generator::render_const_value(t_type
* type
, t_const_value
* value
) {
534 type
= get_true_type(type
);
535 std::ostringstream out
;
537 if (type
->is_base_type()) {
538 t_base_type::t_base tbase
= ((t_base_type
*)type
)->get_base();
540 case t_base_type::TYPE_STRING
:
541 if (((t_base_type
*)type
)->is_binary()) {
544 out
<< '"' << get_escaped_string(value
) << '"';
546 case t_base_type::TYPE_BOOL
:
547 out
<< (value
->get_integer() > 0 ? "True" : "False");
549 case t_base_type::TYPE_I8
:
550 case t_base_type::TYPE_I16
:
551 case t_base_type::TYPE_I32
:
552 case t_base_type::TYPE_I64
:
553 out
<< value
->get_integer();
555 case t_base_type::TYPE_DOUBLE
:
556 if (value
->get_type() == t_const_value::CV_INTEGER
) {
557 out
<< "float(" << value
->get_integer() << ")";
559 out
<< emit_double_as_string(value
->get_double());
563 throw "compiler error: no const of base type " + t_base_type::t_base_name(tbase
);
565 } else if (type
->is_enum()) {
566 out
<< value
->get_integer();
567 } else if (type
->is_struct() || type
->is_xception()) {
568 out
<< type_name(type
) << "(**{" << endl
;
570 const vector
<t_field
*>& fields
= ((t_struct
*)type
)->get_members();
571 vector
<t_field
*>::const_iterator f_iter
;
572 const map
<t_const_value
*, t_const_value
*, t_const_value::value_compare
>& val
= value
->get_map();
573 map
<t_const_value
*, t_const_value
*, t_const_value::value_compare
>::const_iterator v_iter
;
574 for (v_iter
= val
.begin(); v_iter
!= val
.end(); ++v_iter
) {
575 t_type
* field_type
= NULL
;
576 for (f_iter
= fields
.begin(); f_iter
!= fields
.end(); ++f_iter
) {
577 if ((*f_iter
)->get_name() == v_iter
->first
->get_string()) {
578 field_type
= (*f_iter
)->get_type();
581 if (field_type
== NULL
) {
582 throw "type error: " + type
->get_name() + " has no field " + v_iter
->first
->get_string();
584 indent(out
) << render_const_value(g_type_string
, v_iter
->first
) << ": "
585 << render_const_value(field_type
, v_iter
->second
) << "," << endl
;
589 } else if (type
->is_map()) {
590 t_type
* ktype
= ((t_map
*)type
)->get_key_type();
591 t_type
* vtype
= ((t_map
*)type
)->get_val_type();
592 if (is_immutable(type
)) {
593 out
<< "TFrozenDict(";
597 const map
<t_const_value
*, t_const_value
*, t_const_value::value_compare
>& val
= value
->get_map();
598 map
<t_const_value
*, t_const_value
*, t_const_value::value_compare
>::const_iterator v_iter
;
599 for (v_iter
= val
.begin(); v_iter
!= val
.end(); ++v_iter
) {
600 indent(out
) << render_const_value(ktype
, v_iter
->first
) << ": "
601 << render_const_value(vtype
, v_iter
->second
) << "," << endl
;
605 if (is_immutable(type
)) {
608 } else if (type
->is_list() || type
->is_set()) {
610 if (type
->is_list()) {
611 etype
= ((t_list
*)type
)->get_elem_type();
613 etype
= ((t_set
*)type
)->get_elem_type();
615 if (type
->is_set()) {
616 if (is_immutable(type
)) {
621 if (is_immutable(type
) || type
->is_set()) {
627 const vector
<t_const_value
*>& val
= value
->get_list();
628 vector
<t_const_value
*>::const_iterator v_iter
;
629 for (v_iter
= val
.begin(); v_iter
!= val
.end(); ++v_iter
) {
630 indent(out
) << render_const_value(etype
, *v_iter
) << "," << endl
;
633 if (is_immutable(type
) || type
->is_set()) {
638 if (type
->is_set()) {
642 throw "CANNOT GENERATE CONSTANT FOR TYPE: " + type
->get_name();
649 * Generates the "forward declarations" for python structs.
650 * These are actually full class definitions so that calls to generate_struct
651 * can add the thrift_spec field. This is needed so that all thrift_spec
652 * definitions are grouped at the end of the file to enable co-recursive structs.
654 void t_py_generator::generate_forward_declaration(t_struct
* tstruct
) {
655 generate_py_struct(tstruct
, tstruct
->is_xception());
659 * Generates a python struct
661 void t_py_generator::generate_struct(t_struct
* tstruct
) {
662 generate_py_thrift_spec(f_types_
, tstruct
, false);
666 * Generates a struct definition for a thrift exception. Basically the same
667 * as a struct but extends the Exception class.
669 * @param txception The struct definition
671 void t_py_generator::generate_xception(t_struct
* txception
) {
672 generate_py_thrift_spec(f_types_
, txception
, true);
676 * Generates a python struct
678 void t_py_generator::generate_py_struct(t_struct
* tstruct
, bool is_exception
) {
679 generate_py_struct_definition(f_types_
, tstruct
, is_exception
);
684 * Generate the thrift_spec for a struct
686 * all_structs.append(Recursive)
687 * Recursive.thrift_spec = (
689 * (1, TType.LIST, 'Children', (TType.STRUCT, (Recursive, None), False), None, ), # 1
692 void t_py_generator::generate_py_thrift_spec(ostream
& out
,
694 bool /*is_exception*/) {
695 const vector
<t_field
*>& sorted_members
= tstruct
->get_sorted_members();
696 vector
<t_field
*>::const_iterator m_iter
;
698 // Add struct definition to list so thrift_spec can be fixed for recursive structures.
699 indent(out
) << "all_structs.append(" << tstruct
->get_name() << ")" << endl
;
701 if (sorted_members
.empty() || (sorted_members
[0]->get_key() >= 0)) {
702 indent(out
) << tstruct
->get_name() << ".thrift_spec = (" << endl
;
705 int sorted_keys_pos
= 0;
706 for (m_iter
= sorted_members
.begin(); m_iter
!= sorted_members
.end(); ++m_iter
) {
708 for (; sorted_keys_pos
!= (*m_iter
)->get_key(); sorted_keys_pos
++) {
709 indent(out
) << "None, # " << sorted_keys_pos
<< endl
;
712 indent(out
) << "(" << (*m_iter
)->get_key() << ", " << type_to_enum((*m_iter
)->get_type())
714 << "'" << (*m_iter
)->get_name() << "'"
715 << ", " << type_to_spec_args((*m_iter
)->get_type()) << ", "
716 << render_field_default_value(*m_iter
) << ", "
718 << " # " << sorted_keys_pos
<< endl
;
724 indent(out
) << ")" << endl
;
726 indent(out
) << tstruct
->get_name() << ".thrift_spec = ()" << endl
;
731 * Generates a struct definition for a thrift data type.
733 * @param tstruct The struct definition
735 void t_py_generator::generate_py_struct_definition(ostream
& out
,
738 const vector
<t_field
*>& members
= tstruct
->get_members();
739 const vector
<t_field
*>& sorted_members
= tstruct
->get_sorted_members();
740 vector
<t_field
*>::const_iterator m_iter
;
742 out
<< endl
<< endl
<< "class " << tstruct
->get_name();
745 out
<< "(" << gen_dynbaseclass_exc_
<< ")";
747 out
<< "(TException)";
749 } else if (gen_dynamic_
) {
750 if (is_immutable(tstruct
)) {
751 out
<< "(" << gen_dynbaseclass_frozen_
<< ")";
753 out
<< "(" << gen_dynbaseclass_
<< ")";
755 } else if (gen_newstyle_
) {
760 generate_python_docstring(out
, tstruct
);
765 Here we generate the structure specification for the fastbinary codec.
766 These specifications have the following structure:
767 thrift_spec -> tuple of item_spec
768 item_spec -> None | (tag, type_enum, name, spec_args, default)
770 type_enum -> TType.I32 | TType.STRING | TType.STRUCT | ...
771 name -> string_literal
772 default -> None # Handled by __init__
773 spec_args -> None # For simple types
774 | (type_enum, spec_args) # Value type for list/set
775 | (type_enum, spec_args, type_enum, spec_args)
776 # Key and value for map
777 | (class_name, spec_args_ptr) # For struct/exception
778 class_name -> identifier # Basically a pointer to the class
779 spec_args_ptr -> expression # just class_name.spec_args
781 TODO(dreiss): Consider making this work for structs with negative tags.
785 indent(out
) << "__slots__ = (" << endl
;
787 for (m_iter
= sorted_members
.begin(); m_iter
!= sorted_members
.end(); ++m_iter
) {
788 indent(out
) << "'" << (*m_iter
)->get_name() << "'," << endl
;
791 indent(out
) << ")" << endl
<< endl
;
794 // TODO(dreiss): Look into generating an empty tuple instead of None
795 // for structures with no members.
796 // TODO(dreiss): Test encoding of structs where some inner structs
797 // don't have thrift_spec.
799 if (members
.size() > 0) {
801 out
<< indent() << "def __init__(self,";
803 for (m_iter
= members
.begin(); m_iter
!= members
.end(); ++m_iter
) {
804 out
<< " " << declare_argument(*m_iter
) << ",";
810 for (m_iter
= members
.begin(); m_iter
!= members
.end(); ++m_iter
) {
812 t_type
* type
= (*m_iter
)->get_type();
813 if (!type
->is_base_type() && !type
->is_enum() && (*m_iter
)->get_value() != NULL
) {
814 indent(out
) << "if " << (*m_iter
)->get_name() << " is "
815 << "self.thrift_spec[" << (*m_iter
)->get_key() << "][4]:" << endl
;
817 indent(out
) << (*m_iter
)->get_name() << " = " << render_field_default_value(*m_iter
)
822 if (is_immutable(tstruct
)) {
823 if (gen_newstyle_
|| gen_dynamic_
) {
824 indent(out
) << "super(" << tstruct
->get_name() << ", self).__setattr__('"
825 << (*m_iter
)->get_name() << "', " << (*m_iter
)->get_name() << ")" << endl
;
827 indent(out
) << "self.__dict__['" << (*m_iter
)->get_name()
828 << "'] = " << (*m_iter
)->get_name() << endl
;
831 indent(out
) << "self." << (*m_iter
)->get_name() << " = " << (*m_iter
)->get_name() << endl
;
838 if (is_immutable(tstruct
)) {
840 out
<< indent() << "def __setattr__(self, *args):" << endl
841 << indent() << indent_str() << "raise TypeError(\"can't modify immutable instance\")" << endl
843 out
<< indent() << "def __delattr__(self, *args):" << endl
844 << indent() << indent_str() << "raise TypeError(\"can't modify immutable instance\")" << endl
847 // Hash all of the members in order, and also hash in the class
848 // to avoid collisions for stuff like single-field structures.
849 out
<< indent() << "def __hash__(self):" << endl
850 << indent() << indent_str() << "return hash(self.__class__) ^ hash((";
852 for (m_iter
= members
.begin(); m_iter
!= members
.end(); ++m_iter
) {
853 out
<< "self." << (*m_iter
)->get_name() << ", ";
861 generate_py_struct_reader(out
, tstruct
);
862 generate_py_struct_writer(out
, tstruct
);
865 // For exceptions only, generate a __str__ method. This is
866 // because when raised exceptions are printed to the console, __repr__
867 // isn't used. See python bug #5882
870 out
<< indent() << "def __str__(self):" << endl
871 << indent() << indent_str() << "return repr(self)" << endl
;
876 // Printing utilities so that on the command line thrift
877 // structs look pretty like dictionaries
878 indent(out
) << "def __repr__(self):" << endl
;
880 out
<< indent() << "L = ['%s=%r' % (key, value)" << endl
881 << indent() << " for key, value in self.__dict__.items()]" << endl
882 << indent() << "return '%s(%s)' % (self.__class__.__name__, ', '.join(L))" << endl
886 // Equality and inequality methods that compare by value
887 out
<< indent() << "def __eq__(self, other):" << endl
;
889 out
<< indent() << "return isinstance(other, self.__class__) and "
890 "self.__dict__ == other.__dict__" << endl
;
894 out
<< indent() << "def __ne__(self, other):" << endl
;
897 out
<< indent() << "return not (self == other)" << endl
;
899 } else if (!gen_dynamic_
) {
901 // no base class available to implement __eq__ and __repr__ and __ne__ for us
902 // so we must provide one that uses __slots__
903 indent(out
) << "def __repr__(self):" << endl
;
905 out
<< indent() << "L = ['%s=%r' % (key, getattr(self, key))" << endl
906 << indent() << " for key in self.__slots__]" << endl
907 << indent() << "return '%s(%s)' % (self.__class__.__name__, ', '.join(L))" << endl
911 // Equality method that compares each attribute by value and type, walking __slots__
912 out
<< indent() << "def __eq__(self, other):" << endl
;
914 out
<< indent() << "if not isinstance(other, self.__class__):" << endl
915 << indent() << indent_str() << "return False" << endl
916 << indent() << "for attr in self.__slots__:" << endl
917 << indent() << indent_str() << "my_val = getattr(self, attr)" << endl
918 << indent() << indent_str() << "other_val = getattr(other, attr)" << endl
919 << indent() << indent_str() << "if my_val != other_val:" << endl
920 << indent() << indent_str() << indent_str() << "return False" << endl
921 << indent() << "return True" << endl
925 out
<< indent() << "def __ne__(self, other):" << endl
926 << indent() << indent_str() << "return not (self == other)" << endl
;
932 * Generates the read method for a struct
934 void t_py_generator::generate_py_struct_reader(ostream
& out
, t_struct
* tstruct
) {
935 const vector
<t_field
*>& fields
= tstruct
->get_members();
936 vector
<t_field
*>::const_iterator f_iter
;
938 if (is_immutable(tstruct
)) {
939 out
<< indent() << "@classmethod" << endl
<< indent() << "def read(cls, iprot):" << endl
;
941 indent(out
) << "def read(self, iprot):" << endl
;
945 const char* id
= is_immutable(tstruct
) ? "cls" : "self";
947 indent(out
) << "if iprot._fast_decode is not None "
948 "and isinstance(iprot.trans, TTransport.CReadableTransport) "
950 << id
<< ".thrift_spec is not None:" << endl
;
953 if (is_immutable(tstruct
)) {
954 indent(out
) << "return iprot._fast_decode(None, iprot, [cls, cls.thrift_spec])" << endl
;
956 indent(out
) << "iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])" << endl
;
957 indent(out
) << "return" << endl
;
961 indent(out
) << "iprot.readStructBegin()" << endl
;
963 if (is_immutable(tstruct
)) {
964 for (f_iter
= fields
.begin(); f_iter
!= fields
.end(); ++f_iter
) {
965 t_field
* tfield
= *f_iter
;
966 std::ostringstream result
;
967 result
<< tfield
->get_name() << " = ";
968 if (tfield
->get_value() != NULL
) {
969 result
<< render_field_default_value(tfield
);
973 indent(out
) << result
.str() << endl
;
977 // Loop over reading in fields
978 indent(out
) << "while True:" << endl
;
981 // Read beginning field marker
982 indent(out
) << "(fname, ftype, fid) = iprot.readFieldBegin()" << endl
;
984 // Check for field STOP marker and break
985 indent(out
) << "if ftype == TType.STOP:" << endl
;
987 indent(out
) << "break" << endl
;
990 // Switch statement on the field we are reading
993 // Generate deserialization code for known cases
994 for (f_iter
= fields
.begin(); f_iter
!= fields
.end(); ++f_iter
) {
997 out
<< indent() << "if ";
999 out
<< indent() << "elif ";
1001 out
<< "fid == " << (*f_iter
)->get_key() << ":" << endl
;
1003 indent(out
) << "if ftype == " << type_to_enum((*f_iter
)->get_type()) << ":" << endl
;
1005 if (is_immutable(tstruct
)) {
1006 generate_deserialize_field(out
, *f_iter
);
1008 generate_deserialize_field(out
, *f_iter
, "self.");
1011 out
<< indent() << "else:" << endl
<< indent() << indent_str() << "iprot.skip(ftype)" << endl
;
1015 // In the default case we skip the field
1016 out
<< indent() << "else:" << endl
<< indent() << indent_str() << "iprot.skip(ftype)" << endl
;
1018 // Read field end marker
1019 indent(out
) << "iprot.readFieldEnd()" << endl
;
1023 indent(out
) << "iprot.readStructEnd()" << endl
;
1025 if (is_immutable(tstruct
)) {
1026 indent(out
) << "return cls(" << endl
;
1028 for (f_iter
= fields
.begin(); f_iter
!= fields
.end(); ++f_iter
) {
1029 indent(out
) << (*f_iter
)->get_name() << "=" << (*f_iter
)->get_name() << "," << endl
;
1032 indent(out
) << ")" << endl
;
1039 void t_py_generator::generate_py_struct_writer(ostream
& out
, t_struct
* tstruct
) {
1040 string name
= tstruct
->get_name();
1041 const vector
<t_field
*>& fields
= tstruct
->get_sorted_members();
1042 vector
<t_field
*>::const_iterator f_iter
;
1044 indent(out
) << "def write(self, oprot):" << endl
;
1047 indent(out
) << "if oprot._fast_encode is not None and self.thrift_spec is not None:" << endl
;
1051 << "oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))"
1053 indent(out
) << "return" << endl
;
1056 indent(out
) << "oprot.writeStructBegin('" << name
<< "')" << endl
;
1058 for (f_iter
= fields
.begin(); f_iter
!= fields
.end(); ++f_iter
) {
1059 // Write field header
1060 indent(out
) << "if self." << (*f_iter
)->get_name() << " is not None:" << endl
;
1062 indent(out
) << "oprot.writeFieldBegin("
1063 << "'" << (*f_iter
)->get_name() << "', " << type_to_enum((*f_iter
)->get_type())
1064 << ", " << (*f_iter
)->get_key() << ")" << endl
;
1066 // Write field contents
1067 generate_serialize_field(out
, *f_iter
, "self.");
1069 // Write field closer
1070 indent(out
) << "oprot.writeFieldEnd()" << endl
;
1075 // Write the struct map
1076 out
<< indent() << "oprot.writeFieldStop()" << endl
<< indent() << "oprot.writeStructEnd()"
1082 generate_py_struct_required_validator(out
, tstruct
);
1085 void t_py_generator::generate_py_struct_required_validator(ostream
& out
, t_struct
* tstruct
) {
1086 indent(out
) << "def validate(self):" << endl
;
1089 const vector
<t_field
*>& fields
= tstruct
->get_members();
1091 if (fields
.size() > 0) {
1092 vector
<t_field
*>::const_iterator f_iter
;
1094 for (f_iter
= fields
.begin(); f_iter
!= fields
.end(); ++f_iter
) {
1095 t_field
* field
= (*f_iter
);
1096 if (field
->get_req() == t_field::T_REQUIRED
) {
1097 indent(out
) << "if self." << field
->get_name() << " is None:" << endl
;
1098 indent(out
) << indent_str() << "raise TProtocolException(message='Required field "
1099 << field
->get_name() << " is unset!')" << endl
;
1104 indent(out
) << "return" << endl
;
1109 * Generates a thrift service.
1111 * @param tservice The service definition
1113 void t_py_generator::generate_service(t_service
* tservice
) {
1114 string f_service_name
= package_dir_
+ "/" + service_name_
+ ".py";
1115 f_service_
.open(f_service_name
.c_str());
1117 f_service_
<< py_autogen_comment() << endl
<< py_imports() << endl
;
1119 if (tservice
->get_extends() != NULL
) {
1120 f_service_
<< "import "
1121 << get_real_py_module(tservice
->get_extends()->get_program(), gen_twisted_
, package_prefix_
) << "."
1122 << tservice
->get_extends()->get_name() << endl
;
1125 f_service_
<< "import logging" << endl
1126 << "from .ttypes import *" << endl
1127 << "from thrift.Thrift import TProcessor" << endl
1128 << "from thrift.transport import TTransport" << endl
1130 if (gen_zope_interface_
) {
1131 f_service_
<< "from zope.interface import Interface, implementer" << endl
;
1135 f_service_
<< "from twisted.internet import defer" << endl
1136 << "from thrift.transport import TTwisted" << endl
;
1137 } else if (gen_tornado_
) {
1138 f_service_
<< "from tornado import gen" << endl
;
1139 f_service_
<< "from tornado import concurrent" << endl
;
1142 f_service_
<< "all_structs = []" << endl
;
1144 // Generate the three main parts of the service
1145 generate_service_interface(tservice
);
1146 generate_service_client(tservice
);
1147 generate_service_server(tservice
);
1148 generate_service_helpers(tservice
);
1149 generate_service_remote(tservice
);
1151 // Close service file
1152 f_service_
<< "fix_spec(all_structs)" << endl
1153 << "del all_structs" << endl
<< endl
;
1158 * Generates helper functions for a service.
1160 * @param tservice The service to generate a header definition for
1162 void t_py_generator::generate_service_helpers(t_service
* tservice
) {
1163 vector
<t_function
*> functions
= tservice
->get_functions();
1164 vector
<t_function
*>::iterator f_iter
;
1166 f_service_
<< endl
<< "# HELPER FUNCTIONS AND STRUCTURES" << endl
;
1168 for (f_iter
= functions
.begin(); f_iter
!= functions
.end(); ++f_iter
) {
1169 t_struct
* ts
= (*f_iter
)->get_arglist();
1170 generate_py_struct_definition(f_service_
, ts
, false);
1171 generate_py_thrift_spec(f_service_
, ts
, false);
1172 generate_py_function_helpers(*f_iter
);
1177 * Generates a struct and helpers for a function.
1179 * @param tfunction The function
1181 void t_py_generator::generate_py_function_helpers(t_function
* tfunction
) {
1182 if (!tfunction
->is_oneway()) {
1183 t_struct
result(program_
, tfunction
->get_name() + "_result");
1184 t_field
success(tfunction
->get_returntype(), "success", 0);
1185 if (!tfunction
->get_returntype()->is_void()) {
1186 result
.append(&success
);
1189 t_struct
* xs
= tfunction
->get_xceptions();
1190 const vector
<t_field
*>& fields
= xs
->get_members();
1191 vector
<t_field
*>::const_iterator f_iter
;
1192 for (f_iter
= fields
.begin(); f_iter
!= fields
.end(); ++f_iter
) {
1193 result
.append(*f_iter
);
1195 generate_py_struct_definition(f_service_
, &result
, false);
1196 generate_py_thrift_spec(f_service_
, &result
, false);
1201 * Generates a service interface definition.
1203 * @param tservice The service to generate a header definition for
1205 void t_py_generator::generate_service_interface(t_service
* tservice
) {
1206 string extends
= "";
1207 string extends_if
= "";
1208 if (tservice
->get_extends() != NULL
) {
1209 extends
= type_name(tservice
->get_extends());
1210 extends_if
= "(" + extends
+ ".Iface)";
1212 if (gen_zope_interface_
) {
1213 extends_if
= "(Interface)";
1214 } else if (gen_newstyle_
|| gen_dynamic_
|| gen_tornado_
) {
1215 extends_if
= "(object)";
1219 f_service_
<< endl
<< endl
<< "class Iface" << extends_if
<< ":" << endl
;
1221 generate_python_docstring(f_service_
, tservice
);
1222 vector
<t_function
*> functions
= tservice
->get_functions();
1223 if (functions
.empty()) {
1224 f_service_
<< indent() << "pass" << endl
;
1226 vector
<t_function
*>::iterator f_iter
;
1228 for (f_iter
= functions
.begin(); f_iter
!= functions
.end(); ++f_iter
) {
1234 f_service_
<< indent() << "def " << function_signature(*f_iter
, true) << ":" << endl
;
1236 generate_python_docstring(f_service_
, (*f_iter
));
1237 f_service_
<< indent() << "pass" << endl
;
1246 * Generates a service client definition.
1248 * @param tservice The service to generate a server for.
1250 void t_py_generator::generate_service_client(t_service
* tservice
) {
1251 string extends
= "";
1252 string extends_client
= "";
1253 if (tservice
->get_extends() != NULL
) {
1254 extends
= type_name(tservice
->get_extends());
1255 if (gen_zope_interface_
) {
1256 extends_client
= "(" + extends
+ ".Client)";
1258 extends_client
= extends
+ ".Client, ";
1261 if (gen_zope_interface_
&& (gen_newstyle_
|| gen_dynamic_
)) {
1262 extends_client
= "(object)";
1266 f_service_
<< endl
<< endl
;
1268 if (gen_zope_interface_
) {
1269 f_service_
<< "@implementer(Iface)" << endl
1270 << "class Client" << extends_client
<< ":" << endl
1273 f_service_
<< "class Client(" << extends_client
<< "Iface):" << endl
;
1276 generate_python_docstring(f_service_
, tservice
);
1278 // Constructor function
1280 f_service_
<< indent() << "def __init__(self, transport, oprot_factory):" << endl
;
1281 } else if (gen_tornado_
) {
1282 f_service_
<< indent()
1283 << "def __init__(self, transport, iprot_factory, oprot_factory=None):" << endl
;
1285 f_service_
<< indent() << "def __init__(self, iprot, oprot=None):" << endl
;
1288 if (extends
.empty()) {
1290 f_service_
<< indent() << "self._transport = transport" << endl
1291 << indent() << "self._oprot_factory = oprot_factory" << endl
1292 << indent() << "self._seqid = 0" << endl
1293 << indent() << "self._reqs = {}" << endl
;
1294 } else if (gen_tornado_
) {
1295 f_service_
<< indent() << "self._transport = transport" << endl
1296 << indent() << "self._iprot_factory = iprot_factory" << endl
1297 << indent() << "self._oprot_factory = (oprot_factory if oprot_factory is not None"
1299 << indent() << " else iprot_factory)" << endl
1300 << indent() << "self._seqid = 0" << endl
1301 << indent() << "self._reqs = {}" << endl
1302 << indent() << "self._transport.io_loop.spawn_callback(self._start_receiving)"
1305 f_service_
<< indent() << "self._iprot = self._oprot = iprot" << endl
1306 << indent() << "if oprot is not None:" << endl
1307 << indent() << indent_str() << "self._oprot = oprot" << endl
1308 << indent() << "self._seqid = 0" << endl
;
1312 f_service_
<< indent() << extends
1313 << ".Client.__init__(self, transport, oprot_factory)" << endl
;
1314 } else if (gen_tornado_
) {
1315 f_service_
<< indent() << extends
1316 << ".Client.__init__(self, transport, iprot_factory, oprot_factory)" << endl
;
1318 f_service_
<< indent() << extends
<< ".Client.__init__(self, iprot, oprot)" << endl
;
1323 if (gen_tornado_
&& extends
.empty()) {
1324 f_service_
<< endl
<<
1325 indent() << "@gen.engine" << endl
<<
1326 indent() << "def _start_receiving(self):" << endl
;
1328 indent(f_service_
) << "while True:" << endl
;
1330 f_service_
<< indent() << "try:" << endl
1331 << indent() << indent_str() << "frame = yield self._transport.readFrame()" << endl
1332 << indent() << "except TTransport.TTransportException as e:" << endl
1333 << indent() << indent_str() << "for future in self._reqs.values():" << endl
1334 << indent() << indent_str() << indent_str() << "future.set_exception(e)" << endl
1335 << indent() << indent_str() << "self._reqs = {}" << endl
1336 << indent() << indent_str() << "return" << endl
1337 << indent() << "tr = TTransport.TMemoryBuffer(frame)" << endl
1338 << indent() << "iprot = self._iprot_factory.getProtocol(tr)" << endl
1339 << indent() << "(fname, mtype, rseqid) = iprot.readMessageBegin()" << endl
1340 << indent() << "method = getattr(self, 'recv_' + fname)" << endl
1341 << indent() << "future = self._reqs.pop(rseqid, None)" << endl
1342 << indent() << "if not future:" << endl
1343 << indent() << indent_str() << "# future has already been discarded" << endl
1344 << indent() << indent_str() << "continue" << endl
1345 << indent() << "try:" << endl
1346 << indent() << indent_str() << "result = method(iprot, mtype, rseqid)" << endl
1347 << indent() << "except Exception as e:" << endl
1348 << indent() << indent_str() << "future.set_exception(e)" << endl
1349 << indent() << "else:" << endl
1350 << indent() << indent_str() << "future.set_result(result)" << endl
;
1355 // Generate client method implementations
1356 vector
<t_function
*> functions
= tservice
->get_functions();
1357 vector
<t_function
*>::const_iterator f_iter
;
1358 for (f_iter
= functions
.begin(); f_iter
!= functions
.end(); ++f_iter
) {
1359 t_struct
* arg_struct
= (*f_iter
)->get_arglist();
1360 const vector
<t_field
*>& fields
= arg_struct
->get_members();
1361 vector
<t_field
*>::const_iterator fld_iter
;
1362 string funname
= (*f_iter
)->get_name();
1366 indent(f_service_
) << "def " << function_signature(*f_iter
, false) << ":" << endl
;
1368 generate_python_docstring(f_service_
, (*f_iter
));
1370 indent(f_service_
) << "seqid = self._seqid = self._seqid + 1" << endl
;
1371 indent(f_service_
) << "self._reqs[seqid] = defer.Deferred()" << endl
<< endl
;
1372 indent(f_service_
) << "d = defer.maybeDeferred(self.send_" << funname
;
1374 } else if (gen_tornado_
) {
1375 indent(f_service_
) << "self._seqid += 1" << endl
;
1376 if (!(*f_iter
)->is_oneway()) {
1377 indent(f_service_
) << "future = self._reqs[self._seqid] = concurrent.Future()" << endl
;
1379 indent(f_service_
) << "self.send_" << funname
<< "(";
1382 indent(f_service_
) << "self.send_" << funname
<< "(";
1387 // we need a leading comma if there are args, since it's called as maybeDeferred(funcname,
1391 for (fld_iter
= fields
.begin(); fld_iter
!= fields
.end(); ++fld_iter
) {
1397 f_service_
<< (*fld_iter
)->get_name();
1400 f_service_
<< ")" << endl
;
1402 if (!(*f_iter
)->is_oneway()) {
1404 // nothing. See the next block.
1405 } else if (gen_tornado_
) {
1406 indent(f_service_
) << "return future" << endl
;
1408 f_service_
<< indent();
1409 if (!(*f_iter
)->get_returntype()->is_void()) {
1410 f_service_
<< "return ";
1412 f_service_
<< "self.recv_" << funname
<< "()" << endl
;
1418 // This block injects the body of the send_<> method for twisted (and a cb/eb pair)
1420 indent(f_service_
) << "d.addCallbacks(" << endl
;
1423 f_service_
<< indent() << "callback=self.cb_send_" << funname
<< "," << endl
<< indent()
1424 << "callbackArgs=(seqid,)," << endl
<< indent() << "errback=self.eb_send_"
1425 << funname
<< "," << endl
<< indent() << "errbackArgs=(seqid,))" << endl
;
1428 indent(f_service_
) << "return d" << endl
;
1432 indent(f_service_
) << "def cb_send_" << funname
<< "(self, _, seqid):" << endl
;
1434 if ((*f_iter
)->is_oneway()) {
1435 // if one-way, fire the deferred & remove it from _reqs
1436 f_service_
<< indent() << "d = self._reqs.pop(seqid)" << endl
<< indent()
1437 << "d.callback(None)" << endl
<< indent() << "return d" << endl
;
1439 f_service_
<< indent() << "return self._reqs[seqid]" << endl
;
1444 // add an errback to fail the request if the call to send_<> raised an exception
1445 indent(f_service_
) << "def eb_send_" << funname
<< "(self, f, seqid):" << endl
;
1447 f_service_
<< indent() << "d = self._reqs.pop(seqid)" << endl
<< indent() << "d.errback(f)"
1448 << endl
<< indent() << "return d" << endl
;
1453 indent(f_service_
) << "def send_" << function_signature(*f_iter
, false) << ":" << endl
;
1456 std::string argsname
= (*f_iter
)->get_name() + "_args";
1457 std::string messageType
= (*f_iter
)->is_oneway() ? "TMessageType.ONEWAY" : "TMessageType.CALL";
1459 // Serialize the request header
1460 if (gen_twisted_
|| gen_tornado_
) {
1461 f_service_
<< indent() << "oprot = self._oprot_factory.getProtocol(self._transport)" << endl
1462 << indent() << "oprot.writeMessageBegin('" << (*f_iter
)->get_name() << "', "
1463 << messageType
<< ", self._seqid)" << endl
;
1465 f_service_
<< indent() << "self._oprot.writeMessageBegin('" << (*f_iter
)->get_name() << "', "
1466 << messageType
<< ", self._seqid)" << endl
;
1469 f_service_
<< indent() << "args = " << argsname
<< "()" << endl
;
1471 for (fld_iter
= fields
.begin(); fld_iter
!= fields
.end(); ++fld_iter
) {
1472 f_service_
<< indent() << "args." << (*fld_iter
)->get_name() << " = "
1473 << (*fld_iter
)->get_name() << endl
;
1476 // Write to the stream
1477 if (gen_twisted_
|| gen_tornado_
) {
1478 f_service_
<< indent() << "args.write(oprot)" << endl
<< indent() << "oprot.writeMessageEnd()"
1479 << endl
<< indent() << "oprot.trans.flush()" << endl
;
1481 f_service_
<< indent() << "args.write(self._oprot)" << endl
<< indent()
1482 << "self._oprot.writeMessageEnd()" << endl
<< indent()
1483 << "self._oprot.trans.flush()" << endl
;
1488 if (!(*f_iter
)->is_oneway()) {
1489 std::string resultname
= (*f_iter
)->get_name() + "_result";
1492 if (gen_twisted_
|| gen_tornado_
) {
1493 f_service_
<< indent() << "def recv_" << (*f_iter
)->get_name()
1494 << "(self, iprot, mtype, rseqid):" << endl
;
1496 t_struct
noargs(program_
);
1497 t_function
recv_function((*f_iter
)->get_returntype(),
1498 string("recv_") + (*f_iter
)->get_name(),
1500 f_service_
<< indent() << "def " << function_signature(&recv_function
) << ":" << endl
;
1504 // TODO(mcslee): Validate message reply here, seq ids etc.
1507 f_service_
<< indent() << "d = self._reqs.pop(rseqid)" << endl
;
1508 } else if (gen_tornado_
) {
1510 f_service_
<< indent() << "iprot = self._iprot" << endl
<< indent()
1511 << "(fname, mtype, rseqid) = iprot.readMessageBegin()" << endl
;
1514 f_service_
<< indent() << "if mtype == TMessageType.EXCEPTION:" << endl
1515 << indent() << indent_str() << "x = TApplicationException()" << endl
;
1518 f_service_
<< indent() << indent_str() << "x.read(iprot)" << endl
<< indent()
1519 << indent_str() << "iprot.readMessageEnd()" << endl
<< indent() << indent_str() << "return d.errback(x)"
1520 << endl
<< indent() << "result = " << resultname
<< "()" << endl
<< indent()
1521 << "result.read(iprot)" << endl
<< indent() << "iprot.readMessageEnd()" << endl
;
1523 f_service_
<< indent() << indent_str() << "x.read(iprot)" << endl
<< indent()
1524 << indent_str() << "iprot.readMessageEnd()" << endl
<< indent() << indent_str() << "raise x" << endl
1525 << indent() << "result = " << resultname
<< "()" << endl
<< indent()
1526 << "result.read(iprot)" << endl
<< indent() << "iprot.readMessageEnd()" << endl
;
1529 // Careful, only return _result if not a void function
1530 if (!(*f_iter
)->get_returntype()->is_void()) {
1531 f_service_
<< indent() << "if result.success is not None:" << endl
;
1533 f_service_
<< indent() << indent_str() << "return d.callback(result.success)" << endl
;
1535 f_service_
<< indent() << indent_str() << "return result.success" << endl
;
1539 t_struct
* xs
= (*f_iter
)->get_xceptions();
1540 const std::vector
<t_field
*>& xceptions
= xs
->get_members();
1541 vector
<t_field
*>::const_iterator x_iter
;
1542 for (x_iter
= xceptions
.begin(); x_iter
!= xceptions
.end(); ++x_iter
) {
1543 const string
& xname
= (*x_iter
)->get_name();
1544 f_service_
<< indent() << "if result." << xname
<< " is not None:" << endl
;
1546 f_service_
<< indent() << indent_str() << "return d.errback(result." << xname
<< ")"
1549 f_service_
<< indent() << indent_str() << "raise result." << xname
<< "" << endl
;
1553 // Careful, only return _result if not a void function
1554 if ((*f_iter
)->get_returntype()->is_void()) {
1556 f_service_
<< indent() << "return d.callback(None)" << endl
;
1558 f_service_
<< indent() << "return" << endl
;
1564 << "return d.errback(TApplicationException(TApplicationException.MISSING_RESULT, \""
1565 << (*f_iter
)->get_name() << " failed: unknown result\"))" << endl
;
1567 f_service_
<< indent()
1568 << "raise TApplicationException(TApplicationException.MISSING_RESULT, \""
1569 << (*f_iter
)->get_name() << " failed: unknown result\")" << endl
;
1582 * Generates a command line tool for making remote requests
1584 * @param tservice The service to generate a remote for.
1586 void t_py_generator::generate_service_remote(t_service
* tservice
) {
1587 vector
<t_function
*> functions
= tservice
->get_functions();
1588 // Get all function from parents
1589 t_service
* parent
= tservice
->get_extends();
1590 while (parent
!= NULL
) {
1591 vector
<t_function
*> p_functions
= parent
->get_functions();
1592 functions
.insert(functions
.end(), p_functions
.begin(), p_functions
.end());
1593 parent
= parent
->get_extends();
1595 vector
<t_function
*>::iterator f_iter
;
1597 string f_remote_name
= package_dir_
+ "/" + service_name_
+ "-remote";
1598 ofstream_with_content_based_conditional_update f_remote
;
1599 f_remote
.open(f_remote_name
.c_str());
1602 "#!/usr/bin/env python" << endl
<<
1603 py_autogen_comment() << endl
<<
1604 "import sys" << endl
<<
1605 "import pprint" << endl
<<
1606 "if sys.version_info[0] > 2:" << endl
<<
1607 indent_str() << "from urllib.parse import urlparse" << endl
<<
1609 indent_str() << "from urlparse import urlparse" << endl
<<
1610 "from thrift.transport import TTransport, TSocket, TSSLSocket, THttpClient" << endl
<<
1611 "from thrift.protocol.TBinaryProtocol import TBinaryProtocol" << endl
<<
1615 "from " << module_
<< " import " << service_name_
<< endl
<<
1616 "from " << module_
<< ".ttypes import *" << endl
<<
1620 "if len(sys.argv) <= 1 or sys.argv[1] == '--help':" << endl
<<
1621 indent_str() << "print('')" << endl
<<
1622 indent_str() << "print('Usage: ' + sys.argv[0] + ' [-h host[:port]] [-u url] [-f[ramed]] [-s[sl]] [-novalidate] [-ca_certs certs] [-keyfile keyfile] [-certfile certfile] function [arg1 [arg2...]]')" << endl
<<
1623 indent_str() << "print('')" << endl
<<
1624 indent_str() << "print('Functions:')" << endl
;
1625 for (f_iter
= functions
.begin(); f_iter
!= functions
.end(); ++f_iter
) {
1626 f_remote
<< indent_str() << "print(' " << (*f_iter
)->get_returntype()->get_name() << " "
1627 << (*f_iter
)->get_name() << "(";
1628 t_struct
* arg_struct
= (*f_iter
)->get_arglist();
1629 const std::vector
<t_field
*>& args
= arg_struct
->get_members();
1630 std::vector
<t_field
*>::size_type num_args
= args
.size();
1632 for (std::vector
<t_field
*>::size_type i
= 0; i
< num_args
; ++i
) {
1638 f_remote
<< args
[i
]->get_type()->get_name() << " " << args
[i
]->get_name();
1640 f_remote
<< ")')" << endl
;
1642 f_remote
<< indent_str() << "print('')" << endl
<< indent_str() << "sys.exit(0)" << endl
<< endl
;
1644 f_remote
<< "pp = pprint.PrettyPrinter(indent=2)" << endl
1645 << "host = 'localhost'" << endl
1646 << "port = 9090" << endl
1647 << "uri = ''" << endl
1648 << "framed = False" << endl
1649 << "ssl = False" << endl
1650 << "validate = True" << endl
1651 << "ca_certs = None" << endl
1652 << "keyfile = None" << endl
1653 << "certfile = None" << endl
1654 << "http = False" << endl
1655 << "argi = 1" << endl
1657 << "if sys.argv[argi] == '-h':" << endl
1658 << indent_str() << "parts = sys.argv[argi + 1].split(':')" << endl
1659 << indent_str() << "host = parts[0]" << endl
1660 << indent_str() << "if len(parts) > 1:" << endl
1661 << indent_str() << indent_str() << "port = int(parts[1])" << endl
1662 << indent_str() << "argi += 2" << endl
1664 << "if sys.argv[argi] == '-u':" << endl
1665 << indent_str() << "url = urlparse(sys.argv[argi + 1])" << endl
1666 << indent_str() << "parts = url[1].split(':')" << endl
1667 << indent_str() << "host = parts[0]" << endl
1668 << indent_str() << "if len(parts) > 1:" << endl
1669 << indent_str() << indent_str() << "port = int(parts[1])" << endl
1670 << indent_str() << "else:" << endl
1671 << indent_str() << indent_str() << "port = 80" << endl
1672 << indent_str() << "uri = url[2]" << endl
1673 << indent_str() << "if url[4]:" << endl
1674 << indent_str() << indent_str() << "uri += '?%s' % url[4]" << endl
1675 << indent_str() << "http = True" << endl
1676 << indent_str() << "argi += 2" << endl
1678 << "if sys.argv[argi] == '-f' or sys.argv[argi] == '-framed':" << endl
1679 << indent_str() << "framed = True" << endl
1680 << indent_str() << "argi += 1" << endl
1682 << "if sys.argv[argi] == '-s' or sys.argv[argi] == '-ssl':" << endl
1683 << indent_str() << "ssl = True" << endl
1684 << indent_str() << "argi += 1" << endl
1686 << "if sys.argv[argi] == '-novalidate':" << endl
1687 << indent_str() << "validate = False" << endl
1688 << indent_str() << "argi += 1" << endl
1690 << "if sys.argv[argi] == '-ca_certs':" << endl
1691 << indent_str() << "ca_certs = sys.argv[argi+1]" << endl
1692 << indent_str() << "argi += 2" << endl
1694 << "if sys.argv[argi] == '-keyfile':" << endl
1695 << indent_str() << "keyfile = sys.argv[argi+1]" << endl
1696 << indent_str() << "argi += 2" << endl
1698 << "if sys.argv[argi] == '-certfile':" << endl
1699 << indent_str() << "certfile = sys.argv[argi+1]" << endl
1700 << indent_str() << "argi += 2" << endl
1702 << "cmd = sys.argv[argi]" << endl
1703 << "args = sys.argv[argi + 1:]" << endl
1705 << "if http:" << endl
1706 << indent_str() << "transport = THttpClient.THttpClient(host, port, uri)" << endl
1708 << indent_str() << "if ssl:" << endl
1709 << indent_str() << indent_str() << "socket = TSSLSocket.TSSLSocket(host, port, "
1710 "validate=validate, ca_certs=ca_certs, keyfile=keyfile, certfile=certfile)"
1712 << indent_str() << "else:" << endl
1713 << indent_str() << indent_str() << "socket = TSocket.TSocket(host, port)" << endl
1714 << indent_str() << "if framed:" << endl
1715 << indent_str() << indent_str() << "transport = TTransport.TFramedTransport(socket)" << endl
1716 << indent_str() << "else:" << endl
1717 << indent_str() << indent_str() << "transport = TTransport.TBufferedTransport(socket)" << endl
1718 << "protocol = TBinaryProtocol(transport)" << endl
1719 << "client = " << service_name_
<< ".Client(protocol)" << endl
1720 << "transport.open()" << endl
1723 // Generate the dispatch methods
1726 for (f_iter
= functions
.begin(); f_iter
!= functions
.end(); ++f_iter
) {
1733 t_struct
* arg_struct
= (*f_iter
)->get_arglist();
1734 const std::vector
<t_field
*>& args
= arg_struct
->get_members();
1735 std::vector
<t_field
*>::size_type num_args
= args
.size();
1737 f_remote
<< "if cmd == '" << (*f_iter
)->get_name() << "':" << endl
;
1739 f_remote
<< indent() << "if len(args) != " << num_args
<< ":" << endl
1740 << indent() << indent_str() << "print('" << (*f_iter
)->get_name() << " requires " << num_args
1741 << " args')" << endl
1742 << indent() << indent_str() << "sys.exit(1)" << endl
1743 << indent() << "pp.pprint(client." << (*f_iter
)->get_name() << "(";
1745 bool first_arg
= true;
1746 for (std::vector
<t_field
*>::size_type i
= 0; i
< num_args
; ++i
) {
1751 if (args
[i
]->get_type()->is_string()) {
1752 f_remote
<< "args[" << i
<< "],";
1754 f_remote
<< "eval(args[" << i
<< "]),";
1757 f_remote
<< "))" << endl
;
1762 if (functions
.size() > 0) {
1763 f_remote
<< "else:" << endl
;
1764 f_remote
<< indent_str() << "print('Unrecognized method %s' % cmd)" << endl
;
1765 f_remote
<< indent_str() << "sys.exit(1)" << endl
;
1769 f_remote
<< "transport.close()" << endl
;
1771 // Close service file
1776 // Make file executable, love that bitwise OR action
1777 chmod(f_remote_name
.c_str(),
1778 S_IRUSR
| S_IWUSR
| S_IXUSR
1780 | S_IRGRP
| S_IXGRP
| S_IROTH
| S_IXOTH
1788 * Generates a service server definition.
1790 * @param tservice The service to generate a server for.
1792 void t_py_generator::generate_service_server(t_service
* tservice
) {
1793 // Generate the dispatch methods
1794 vector
<t_function
*> functions
= tservice
->get_functions();
1795 vector
<t_function
*>::iterator f_iter
;
1797 string extends
= "";
1798 string extends_processor
= "";
1799 if (tservice
->get_extends() != NULL
) {
1800 extends
= type_name(tservice
->get_extends());
1801 extends_processor
= extends
+ ".Processor, ";
1804 f_service_
<< endl
<< endl
;
1806 // Generate the header portion
1807 if (gen_zope_interface_
) {
1808 f_service_
<< "@implementer(Iface)" << endl
1809 << "class Processor(" << extends_processor
<< "TProcessor):" << endl
;
1811 f_service_
<< "class Processor(" << extends_processor
<< "Iface, TProcessor):" << endl
;
1816 indent(f_service_
) << "def __init__(self, handler):" << endl
;
1818 if (extends
.empty()) {
1819 if (gen_zope_interface_
) {
1820 f_service_
<< indent() << "self._handler = Iface(handler)" << endl
;
1822 f_service_
<< indent() << "self._handler = handler" << endl
;
1825 f_service_
<< indent() << "self._processMap = {}" << endl
;
1827 if (gen_zope_interface_
) {
1828 f_service_
<< indent() << extends
<< ".Processor.__init__(self, Iface(handler))" << endl
;
1830 f_service_
<< indent() << extends
<< ".Processor.__init__(self, handler)" << endl
;
1833 for (f_iter
= functions
.begin(); f_iter
!= functions
.end(); ++f_iter
) {
1834 f_service_
<< indent() << "self._processMap[\"" << (*f_iter
)->get_name()
1835 << "\"] = Processor.process_" << (*f_iter
)->get_name() << endl
;
1837 f_service_
<< indent() << "self._on_message_begin = None" << endl
;
1841 f_service_
<< indent() << "def on_message_begin(self, func):" << endl
;
1843 f_service_
<< indent() << "self._on_message_begin = func" << endl
;
1847 // Generate the server implementation
1848 f_service_
<< indent() << "def process(self, iprot, oprot):" << endl
;
1851 f_service_
<< indent() << "(name, type, seqid) = iprot.readMessageBegin()" << endl
;
1852 f_service_
<< indent() << "if self._on_message_begin:" << endl
;
1854 f_service_
<< indent() << "self._on_message_begin(name, type, seqid)" << endl
;
1857 // TODO(mcslee): validate message
1859 // HOT: dictionary function lookup
1860 f_service_
<< indent() << "if name not in self._processMap:" << endl
;
1862 f_service_
<< indent() << "iprot.skip(TType.STRUCT)" << endl
1863 << indent() << "iprot.readMessageEnd()" << endl
1865 << "x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown "
1866 "function %s' % (name))"
1868 << indent() << "oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)" << endl
1869 << indent() << "x.write(oprot)" << endl
1870 << indent() << "oprot.writeMessageEnd()" << endl
1871 << indent() << "oprot.trans.flush()" << endl
;
1874 f_service_
<< indent() << "return defer.succeed(None)" << endl
;
1876 f_service_
<< indent() << "return" << endl
;
1880 f_service_
<< indent() << "else:" << endl
;
1882 if (gen_twisted_
|| gen_tornado_
) {
1883 f_service_
<< indent() << indent_str()
1884 << "return self._processMap[name](self, seqid, iprot, oprot)" << endl
;
1886 f_service_
<< indent() << indent_str() << "self._processMap[name](self, seqid, iprot, oprot)"
1889 // Read end of args field, the T_STOP, and the struct close
1890 f_service_
<< indent() << "return True" << endl
;
1895 // Generate the process subfunctions
1896 for (f_iter
= functions
.begin(); f_iter
!= functions
.end(); ++f_iter
) {
1898 generate_process_function(tservice
, *f_iter
);
1905 * Generates a process function definition.
1907 * @param tfunction The function to write a dispatcher for
1909 void t_py_generator::generate_process_function(t_service
* tservice
, t_function
* tfunction
) {
1913 f_service_
<< indent() << "@gen.coroutine" << endl
<< indent() << "def process_"
1914 << tfunction
->get_name() << "(self, seqid, iprot, oprot):" << endl
;
1916 f_service_
<< indent() << "def process_" << tfunction
->get_name()
1917 << "(self, seqid, iprot, oprot):" << endl
;
1922 string argsname
= tfunction
->get_name() + "_args";
1923 string resultname
= tfunction
->get_name() + "_result";
1925 f_service_
<< indent() << "args = " << argsname
<< "()" << endl
<< indent() << "args.read(iprot)"
1926 << endl
<< indent() << "iprot.readMessageEnd()" << endl
;
1928 t_struct
* xs
= tfunction
->get_xceptions();
1929 const std::vector
<t_field
*>& xceptions
= xs
->get_members();
1930 vector
<t_field
*>::const_iterator x_iter
;
1932 // Declare result for non oneway function
1933 if (!tfunction
->is_oneway()) {
1934 f_service_
<< indent() << "result = " << resultname
<< "()" << endl
;
1938 // Generate the function call
1939 t_struct
* arg_struct
= tfunction
->get_arglist();
1940 const std::vector
<t_field
*>& fields
= arg_struct
->get_members();
1941 vector
<t_field
*>::const_iterator f_iter
;
1943 f_service_
<< indent() << "d = defer.maybeDeferred(self._handler." << tfunction
->get_name()
1946 for (f_iter
= fields
.begin(); f_iter
!= fields
.end(); ++f_iter
) {
1952 f_service_
<< "args." << (*f_iter
)->get_name();
1954 f_service_
<< ")" << endl
;
1956 if (tfunction
->is_oneway()) {
1957 f_service_
<< indent() << "d.addErrback(self.handle_exception_" << tfunction
->get_name()
1958 << ", seqid)" << endl
;
1960 f_service_
<< indent() << "d.addCallback(self.write_results_success_" << tfunction
->get_name()
1961 << ", result, seqid, oprot)" << endl
1962 << indent() << "d.addErrback(self.write_results_exception_"
1963 << tfunction
->get_name() << ", result, seqid, oprot)" << endl
;
1965 f_service_
<< indent() << "return d" << endl
<< endl
;
1969 if (tfunction
->is_oneway()) {
1970 indent(f_service_
) << "def handle_exception_" << tfunction
->get_name()
1971 << "(self, error, seqid):" << endl
;
1973 indent(f_service_
) << "def write_results_success_" << tfunction
->get_name()
1974 << "(self, success, result, seqid, oprot):" << endl
;
1976 if (!tfunction
->get_returntype()->is_void()) {
1977 f_service_
<< indent() << "result.success = success" << endl
;
1979 f_service_
<< indent() << "oprot.writeMessageBegin(\"" << tfunction
->get_name()
1980 << "\", TMessageType.REPLY, seqid)" << endl
1981 << indent() << "result.write(oprot)" << endl
1982 << indent() << "oprot.writeMessageEnd()" << endl
1983 << indent() << "oprot.trans.flush()" << endl
1987 indent(f_service_
) << "def write_results_exception_" << tfunction
->get_name()
1988 << "(self, error, result, seqid, oprot):" << endl
;
1991 if (!tfunction
->is_oneway()) {
1992 f_service_
<< indent() << "msg_type = TMessageType.REPLY" << endl
;
1994 f_service_
<< indent() << "try:" << endl
;
1997 f_service_
<< indent() << indent_str() << "error.raiseException()" << endl
;
1998 if (!tfunction
->is_oneway()) {
1999 for (x_iter
= xceptions
.begin(); x_iter
!= xceptions
.end(); ++x_iter
) {
2000 const string
& xname
= (*x_iter
)->get_name();
2001 f_service_
<< indent() << "except " << type_name((*x_iter
)->get_type()) << " as " << xname
2004 f_service_
<< indent() << "result." << xname
<< " = " << xname
<< endl
;
2008 f_service_
<< indent() << "except TTransport.TTransportException:" << endl
2009 << indent() << indent_str() << "raise" << endl
;
2010 if (!tfunction
->is_oneway()) {
2011 f_service_
<< indent() << "except TApplicationException as ex:" << endl
2012 << indent() << indent_str()
2013 << "logging.exception('TApplication exception in handler')" << endl
2014 << indent() << indent_str() << "msg_type = TMessageType.EXCEPTION" << endl
2015 << indent() << indent_str() << "result = ex" << endl
2016 << indent() << "except Exception:" << endl
2017 << indent() << indent_str()
2018 << "logging.exception('Unexpected exception in handler')" << endl
2019 << indent() << indent_str() << "msg_type = TMessageType.EXCEPTION" << endl
2020 << indent() << indent_str()
2021 << "result = TApplicationException(TApplicationException.INTERNAL_ERROR, "
2024 << indent() << "oprot.writeMessageBegin(\"" << tfunction
->get_name()
2025 << "\", msg_type, seqid)" << endl
2026 << indent() << "result.write(oprot)" << endl
2027 << indent() << "oprot.writeMessageEnd()" << endl
2028 << indent() << "oprot.trans.flush()" << endl
;
2030 f_service_
<< indent() << "except Exception:" << endl
2031 << indent() << indent_str()
2032 << "logging.exception('Exception in oneway handler')" << endl
;
2036 } else if (gen_tornado_
) {
2037 // Generate the function call
2038 t_struct
* arg_struct
= tfunction
->get_arglist();
2039 const std::vector
<t_field
*>& fields
= arg_struct
->get_members();
2040 vector
<t_field
*>::const_iterator f_iter
;
2042 if (!tfunction
->is_oneway()) {
2043 indent(f_service_
) << "msg_type = TMessageType.REPLY" << endl
;
2045 f_service_
<< indent() << "try:" << endl
;
2047 f_service_
<< indent();
2048 if (!tfunction
->is_oneway() && !tfunction
->get_returntype()->is_void()) {
2049 f_service_
<< "result.success = ";
2051 f_service_
<< "yield gen.maybe_future(self._handler." << tfunction
->get_name() << "(";
2053 for (f_iter
= fields
.begin(); f_iter
!= fields
.end(); ++f_iter
) {
2059 f_service_
<< "args." << (*f_iter
)->get_name();
2061 f_service_
<< "))" << endl
;
2064 if (!tfunction
->is_oneway()) {
2065 for (x_iter
= xceptions
.begin(); x_iter
!= xceptions
.end(); ++x_iter
) {
2066 const string
& xname
= (*x_iter
)->get_name();
2067 f_service_
<< indent() << "except " << type_name((*x_iter
)->get_type()) << " as " << xname
2069 << indent() << indent_str() << "result." << xname
<< " = " << xname
<< endl
;
2072 f_service_
<< indent() << "except TTransport.TTransportException:" << endl
2073 << indent() << indent_str() << "raise" << endl
;
2074 if (!tfunction
->is_oneway()) {
2075 f_service_
<< indent() << "except TApplicationException as ex:" << endl
2076 << indent() << indent_str()
2077 << "logging.exception('TApplication exception in handler')" << endl
2078 << indent() << indent_str() << "msg_type = TMessageType.EXCEPTION" << endl
2079 << indent() << indent_str() << "result = ex" << endl
2080 << indent() << "except Exception:" << endl
2081 << indent() << indent_str()
2082 << "logging.exception('Unexpected exception in handler')" << endl
2083 << indent() << indent_str() << "msg_type = TMessageType.EXCEPTION" << endl
2084 << indent() << indent_str()
2085 << "result = TApplicationException(TApplicationException.INTERNAL_ERROR, "
2089 f_service_
<< indent() << "except Exception:" << endl
2090 << indent() << indent_str()
2091 << "logging.exception('Exception in oneway handler')" << endl
;
2094 if (!tfunction
->is_oneway()) {
2095 f_service_
<< indent() << "oprot.writeMessageBegin(\"" << tfunction
->get_name()
2096 << "\", msg_type, seqid)" << endl
2097 << indent() << "result.write(oprot)" << endl
2098 << indent() << "oprot.writeMessageEnd()" << endl
2099 << indent() << "oprot.trans.flush()" << endl
;
2106 // Try block for a function with exceptions
2107 // It also catches arbitrary exceptions raised by handler method to propagate them to the client
2108 f_service_
<< indent() << "try:" << endl
;
2111 // Generate the function call
2112 t_struct
* arg_struct
= tfunction
->get_arglist();
2113 const std::vector
<t_field
*>& fields
= arg_struct
->get_members();
2114 vector
<t_field
*>::const_iterator f_iter
;
2116 f_service_
<< indent();
2117 if (!tfunction
->is_oneway() && !tfunction
->get_returntype()->is_void()) {
2118 f_service_
<< "result.success = ";
2120 f_service_
<< "self._handler." << tfunction
->get_name() << "(";
2122 for (f_iter
= fields
.begin(); f_iter
!= fields
.end(); ++f_iter
) {
2128 f_service_
<< "args." << (*f_iter
)->get_name();
2130 f_service_
<< ")" << endl
;
2131 if (!tfunction
->is_oneway()) {
2132 f_service_
<< indent() << "msg_type = TMessageType.REPLY" << endl
;
2136 f_service_
<< indent()
2137 << "except TTransport.TTransportException:" << endl
2138 << indent() << indent_str() << "raise" << endl
;
2140 if (!tfunction
->is_oneway()) {
2141 for (x_iter
= xceptions
.begin(); x_iter
!= xceptions
.end(); ++x_iter
) {
2142 const string
& xname
= (*x_iter
)->get_name();
2143 f_service_
<< indent() << "except " << type_name((*x_iter
)->get_type()) << " as " << xname
2146 f_service_
<< indent() << "msg_type = TMessageType.REPLY" << endl
;
2147 f_service_
<< indent() << "result." << xname
<< " = " << xname
<< endl
;
2151 f_service_
<< indent() << "except TApplicationException as ex:" << endl
2152 << indent() << indent_str()
2153 << "logging.exception('TApplication exception in handler')" << endl
2154 << indent() << indent_str() << "msg_type = TMessageType.EXCEPTION" << endl
2155 << indent() << indent_str() << "result = ex" << endl
2156 << indent() << "except Exception:" << endl
2157 << indent() << indent_str()
2158 << "logging.exception('Unexpected exception in handler')" << endl
2159 << indent() << indent_str() << "msg_type = TMessageType.EXCEPTION" << endl
2160 << indent() << indent_str()
2161 << "result = TApplicationException(TApplicationException.INTERNAL_ERROR, "
2164 << indent() << "oprot.writeMessageBegin(\"" << tfunction
->get_name()
2165 << "\", msg_type, seqid)" << endl
2166 << indent() << "result.write(oprot)" << endl
2167 << indent() << "oprot.writeMessageEnd()" << endl
2168 << indent() << "oprot.trans.flush()" << endl
;
2170 f_service_
<< indent() << "except Exception:" << endl
2171 << indent() << indent_str() << "logging.exception('Exception in oneway handler')" << endl
;
2180 * Deserializes a field of any type.
2182 void t_py_generator::generate_deserialize_field(ostream
& out
,
2185 t_type
* type
= get_true_type(tfield
->get_type());
2187 if (type
->is_void()) {
2188 throw "CANNOT GENERATE DESERIALIZE CODE FOR void TYPE: " + prefix
+ tfield
->get_name();
2191 string name
= prefix
+ tfield
->get_name();
2193 if (type
->is_struct() || type
->is_xception()) {
2194 generate_deserialize_struct(out
, (t_struct
*)type
, name
);
2195 } else if (type
->is_container()) {
2196 generate_deserialize_container(out
, type
, name
);
2197 } else if (type
->is_base_type() || type
->is_enum()) {
2198 indent(out
) << name
<< " = iprot.";
2200 if (type
->is_base_type()) {
2201 t_base_type::t_base tbase
= ((t_base_type
*)type
)->get_base();
2203 case t_base_type::TYPE_VOID
:
2204 throw "compiler error: cannot serialize void field in a struct: " + name
;
2205 case t_base_type::TYPE_STRING
:
2206 if (type
->is_binary()) {
2207 out
<< "readBinary()";
2208 } else if(!gen_utf8strings_
) {
2209 out
<< "readString()";
2211 out
<< "readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()";
2214 case t_base_type::TYPE_BOOL
:
2215 out
<< "readBool()";
2217 case t_base_type::TYPE_I8
:
2218 out
<< "readByte()";
2220 case t_base_type::TYPE_I16
:
2223 case t_base_type::TYPE_I32
:
2226 case t_base_type::TYPE_I64
:
2229 case t_base_type::TYPE_DOUBLE
:
2230 out
<< "readDouble()";
2233 throw "compiler error: no Python name for base type " + t_base_type::t_base_name(tbase
);
2235 } else if (type
->is_enum()) {
2241 printf("DO NOT KNOW HOW TO DESERIALIZE FIELD '%s' TYPE '%s'\n",
2242 tfield
->get_name().c_str(),
2243 type
->get_name().c_str());
2248 * Generates an unserializer for a struct, calling read()
2250 void t_py_generator::generate_deserialize_struct(ostream
& out
, t_struct
* tstruct
, string prefix
) {
2251 if (is_immutable(tstruct
)) {
2252 out
<< indent() << prefix
<< " = " << type_name(tstruct
) << ".read(iprot)" << endl
;
2254 out
<< indent() << prefix
<< " = " << type_name(tstruct
) << "()" << endl
2255 << indent() << prefix
<< ".read(iprot)" << endl
;
2260 * Serialize a container by writing out the header followed by
2261 * data and then a footer.
2263 void t_py_generator::generate_deserialize_container(ostream
& out
, t_type
* ttype
, string prefix
) {
2264 string size
= tmp("_size");
2265 string ktype
= tmp("_ktype");
2266 string vtype
= tmp("_vtype");
2267 string etype
= tmp("_etype");
2269 t_field
fsize(g_type_i32
, size
);
2270 t_field
fktype(g_type_i8
, ktype
);
2271 t_field
fvtype(g_type_i8
, vtype
);
2272 t_field
fetype(g_type_i8
, etype
);
2274 // Declare variables, read header
2275 if (ttype
->is_map()) {
2276 out
<< indent() << prefix
<< " = {}" << endl
<< indent() << "(" << ktype
<< ", " << vtype
2277 << ", " << size
<< ") = iprot.readMapBegin()" << endl
;
2278 } else if (ttype
->is_set()) {
2279 out
<< indent() << prefix
<< " = set()" << endl
<< indent() << "(" << etype
<< ", " << size
2280 << ") = iprot.readSetBegin()" << endl
;
2281 } else if (ttype
->is_list()) {
2282 out
<< indent() << prefix
<< " = []" << endl
<< indent() << "(" << etype
<< ", " << size
2283 << ") = iprot.readListBegin()" << endl
;
2286 // For loop iterates over elements
2287 string i
= tmp("_i");
2289 "for " << i
<< " in range(" << size
<< "):" << endl
;
2293 if (ttype
->is_map()) {
2294 generate_deserialize_map_element(out
, (t_map
*)ttype
, prefix
);
2295 } else if (ttype
->is_set()) {
2296 generate_deserialize_set_element(out
, (t_set
*)ttype
, prefix
);
2297 } else if (ttype
->is_list()) {
2298 generate_deserialize_list_element(out
, (t_list
*)ttype
, prefix
);
2303 // Read container end
2304 if (ttype
->is_map()) {
2305 indent(out
) << "iprot.readMapEnd()" << endl
;
2306 if (is_immutable(ttype
)) {
2307 indent(out
) << prefix
<< " = TFrozenDict(" << prefix
<< ")" << endl
;
2309 } else if (ttype
->is_set()) {
2310 indent(out
) << "iprot.readSetEnd()" << endl
;
2311 if (is_immutable(ttype
)) {
2312 indent(out
) << prefix
<< " = frozenset(" << prefix
<< ")" << endl
;
2314 } else if (ttype
->is_list()) {
2315 if (is_immutable(ttype
)) {
2316 indent(out
) << prefix
<< " = tuple(" << prefix
<< ")" << endl
;
2318 indent(out
) << "iprot.readListEnd()" << endl
;
2323 * Generates code to deserialize a map
2325 void t_py_generator::generate_deserialize_map_element(ostream
& out
, t_map
* tmap
, string prefix
) {
2326 string key
= tmp("_key");
2327 string val
= tmp("_val");
2328 t_field
fkey(tmap
->get_key_type(), key
);
2329 t_field
fval(tmap
->get_val_type(), val
);
2331 generate_deserialize_field(out
, &fkey
);
2332 generate_deserialize_field(out
, &fval
);
2334 indent(out
) << prefix
<< "[" << key
<< "] = " << val
<< endl
;
2338 * Write a set element
2340 void t_py_generator::generate_deserialize_set_element(ostream
& out
, t_set
* tset
, string prefix
) {
2341 string elem
= tmp("_elem");
2342 t_field
felem(tset
->get_elem_type(), elem
);
2344 generate_deserialize_field(out
, &felem
);
2346 indent(out
) << prefix
<< ".add(" << elem
<< ")" << endl
;
2350 * Write a list element
2352 void t_py_generator::generate_deserialize_list_element(ostream
& out
,
2355 string elem
= tmp("_elem");
2356 t_field
felem(tlist
->get_elem_type(), elem
);
2358 generate_deserialize_field(out
, &felem
);
2360 indent(out
) << prefix
<< ".append(" << elem
<< ")" << endl
;
2364 * Serializes a field of any type.
2366 * @param tfield The field to serialize
2367 * @param prefix Name to prepend to field name
2369 void t_py_generator::generate_serialize_field(ostream
& out
, t_field
* tfield
, string prefix
) {
2370 t_type
* type
= get_true_type(tfield
->get_type());
2372 // Do nothing for void types
2373 if (type
->is_void()) {
2374 throw "CANNOT GENERATE SERIALIZE CODE FOR void TYPE: " + prefix
+ tfield
->get_name();
2377 if (type
->is_struct() || type
->is_xception()) {
2378 generate_serialize_struct(out
, (t_struct
*)type
, prefix
+ tfield
->get_name());
2379 } else if (type
->is_container()) {
2380 generate_serialize_container(out
, type
, prefix
+ tfield
->get_name());
2381 } else if (type
->is_base_type() || type
->is_enum()) {
2383 string name
= prefix
+ tfield
->get_name();
2385 indent(out
) << "oprot.";
2387 if (type
->is_base_type()) {
2388 t_base_type::t_base tbase
= ((t_base_type
*)type
)->get_base();
2390 case t_base_type::TYPE_VOID
:
2391 throw "compiler error: cannot serialize void field in a struct: " + name
;
2393 case t_base_type::TYPE_STRING
:
2394 if (type
->is_binary()) {
2395 out
<< "writeBinary(" << name
<< ")";
2396 } else if (!gen_utf8strings_
) {
2397 out
<< "writeString(" << name
<< ")";
2399 out
<< "writeString(" << name
<< ".encode('utf-8') if sys.version_info[0] == 2 else " << name
<< ")";
2402 case t_base_type::TYPE_BOOL
:
2403 out
<< "writeBool(" << name
<< ")";
2405 case t_base_type::TYPE_I8
:
2406 out
<< "writeByte(" << name
<< ")";
2408 case t_base_type::TYPE_I16
:
2409 out
<< "writeI16(" << name
<< ")";
2411 case t_base_type::TYPE_I32
:
2412 out
<< "writeI32(" << name
<< ")";
2414 case t_base_type::TYPE_I64
:
2415 out
<< "writeI64(" << name
<< ")";
2417 case t_base_type::TYPE_DOUBLE
:
2418 out
<< "writeDouble(" << name
<< ")";
2421 throw "compiler error: no Python name for base type " + t_base_type::t_base_name(tbase
);
2423 } else if (type
->is_enum()) {
2424 out
<< "writeI32(" << name
<< ")";
2428 printf("DO NOT KNOW HOW TO SERIALIZE FIELD '%s%s' TYPE '%s'\n",
2430 tfield
->get_name().c_str(),
2431 type
->get_name().c_str());
2436 * Serializes all the members of a struct.
2438 * @param tstruct The struct to serialize
2439 * @param prefix String prefix to attach to all fields
2441 void t_py_generator::generate_serialize_struct(ostream
& out
, t_struct
* tstruct
, string prefix
) {
2443 indent(out
) << prefix
<< ".write(oprot)" << endl
;
2446 void t_py_generator::generate_serialize_container(ostream
& out
, t_type
* ttype
, string prefix
) {
2447 if (ttype
->is_map()) {
2448 indent(out
) << "oprot.writeMapBegin(" << type_to_enum(((t_map
*)ttype
)->get_key_type()) << ", "
2449 << type_to_enum(((t_map
*)ttype
)->get_val_type()) << ", "
2450 << "len(" << prefix
<< "))" << endl
;
2451 } else if (ttype
->is_set()) {
2452 indent(out
) << "oprot.writeSetBegin(" << type_to_enum(((t_set
*)ttype
)->get_elem_type()) << ", "
2453 << "len(" << prefix
<< "))" << endl
;
2454 } else if (ttype
->is_list()) {
2455 indent(out
) << "oprot.writeListBegin(" << type_to_enum(((t_list
*)ttype
)->get_elem_type())
2457 << "len(" << prefix
<< "))" << endl
;
2460 if (ttype
->is_map()) {
2461 string kiter
= tmp("kiter");
2462 string viter
= tmp("viter");
2463 indent(out
) << "for " << kiter
<< ", " << viter
<< " in " << prefix
<< ".items():" << endl
;
2465 generate_serialize_map_element(out
, (t_map
*)ttype
, kiter
, viter
);
2467 } else if (ttype
->is_set()) {
2468 string iter
= tmp("iter");
2469 indent(out
) << "for " << iter
<< " in " << prefix
<< ":" << endl
;
2471 generate_serialize_set_element(out
, (t_set
*)ttype
, iter
);
2473 } else if (ttype
->is_list()) {
2474 string iter
= tmp("iter");
2475 indent(out
) << "for " << iter
<< " in " << prefix
<< ":" << endl
;
2477 generate_serialize_list_element(out
, (t_list
*)ttype
, iter
);
2481 if (ttype
->is_map()) {
2482 indent(out
) << "oprot.writeMapEnd()" << endl
;
2483 } else if (ttype
->is_set()) {
2484 indent(out
) << "oprot.writeSetEnd()" << endl
;
2485 } else if (ttype
->is_list()) {
2486 indent(out
) << "oprot.writeListEnd()" << endl
;
2491 * Serializes the members of a map.
2494 void t_py_generator::generate_serialize_map_element(ostream
& out
,
2498 t_field
kfield(tmap
->get_key_type(), kiter
);
2499 generate_serialize_field(out
, &kfield
, "");
2501 t_field
vfield(tmap
->get_val_type(), viter
);
2502 generate_serialize_field(out
, &vfield
, "");
2506 * Serializes the members of a set.
2508 void t_py_generator::generate_serialize_set_element(ostream
& out
, t_set
* tset
, string iter
) {
2509 t_field
efield(tset
->get_elem_type(), iter
);
2510 generate_serialize_field(out
, &efield
, "");
2514 * Serializes the members of a list.
2516 void t_py_generator::generate_serialize_list_element(ostream
& out
, t_list
* tlist
, string iter
) {
2517 t_field
efield(tlist
->get_elem_type(), iter
);
2518 generate_serialize_field(out
, &efield
, "");
2522 * Generates the docstring for a given struct.
2524 void t_py_generator::generate_python_docstring(ostream
& out
, t_struct
* tstruct
) {
2525 generate_python_docstring(out
, tstruct
, tstruct
, "Attributes");
2529 * Generates the docstring for a given function.
2531 void t_py_generator::generate_python_docstring(ostream
& out
, t_function
* tfunction
) {
2532 generate_python_docstring(out
, tfunction
, tfunction
->get_arglist(), "Parameters");
2536 * Generates the docstring for a struct or function.
2538 void t_py_generator::generate_python_docstring(ostream
& out
,
2541 const char* subheader
) {
2542 bool has_doc
= false;
2544 if (tdoc
->has_doc()) {
2546 ss
<< tdoc
->get_doc();
2549 const vector
<t_field
*>& fields
= tstruct
->get_members();
2550 if (fields
.size() > 0) {
2555 ss
<< subheader
<< ":\n";
2556 vector
<t_field
*>::const_iterator p_iter
;
2557 for (p_iter
= fields
.begin(); p_iter
!= fields
.end(); ++p_iter
) {
2558 t_field
* p
= *p_iter
;
2559 ss
<< " - " << p
->get_name();
2561 ss
<< ": " << p
->get_doc();
2569 generate_docstring_comment(out
, "\"\"\"\n", "", ss
.str(), "\"\"\"\n");
2574 * Generates the docstring for a generic object.
2576 void t_py_generator::generate_python_docstring(ostream
& out
, t_doc
* tdoc
) {
2577 if (tdoc
->has_doc()) {
2578 generate_docstring_comment(out
, "\"\"\"\n", "", tdoc
->get_doc(), "\"\"\"\n");
2583 * Declares an argument, which may include initialization as necessary.
2585 * @param tfield The field
2587 string
t_py_generator::declare_argument(t_field
* tfield
) {
2588 std::ostringstream result
;
2589 result
<< tfield
->get_name() << "=";
2590 if (tfield
->get_value() != NULL
) {
2591 result
<< render_field_default_value(tfield
);
2595 return result
.str();
2599 * Renders a field default value, returns None otherwise.
2601 * @param tfield The field
2603 string
t_py_generator::render_field_default_value(t_field
* tfield
) {
2604 t_type
* type
= get_true_type(tfield
->get_type());
2605 if (tfield
->get_value() != NULL
) {
2606 return render_const_value(type
, tfield
->get_value());
2613 * Renders a function signature of the form 'type name(args)'
2615 * @param tfunction Function definition
2616 * @return String of rendered function definition
2618 string
t_py_generator::function_signature(t_function
* tfunction
, bool interface
) {
2620 vector
<string
> post
;
2621 string signature
= tfunction
->get_name() + "(";
2623 if (!(gen_zope_interface_
&& interface
)) {
2624 pre
.emplace_back("self");
2627 signature
+= argument_list(tfunction
->get_arglist(), &pre
, &post
) + ")";
2632 * Renders a field list
2634 string
t_py_generator::argument_list(t_struct
* tstruct
, vector
<string
>* pre
, vector
<string
>* post
) {
2637 const vector
<t_field
*>& fields
= tstruct
->get_members();
2638 vector
<t_field
*>::const_iterator f_iter
;
2639 vector
<string
>::const_iterator s_iter
;
2642 for (s_iter
= pre
->begin(); s_iter
!= pre
->end(); ++s_iter
) {
2651 for (f_iter
= fields
.begin(); f_iter
!= fields
.end(); ++f_iter
) {
2657 result
+= (*f_iter
)->get_name();
2660 for (s_iter
= post
->begin(); s_iter
!= post
->end(); ++s_iter
) {
2672 string
t_py_generator::type_name(t_type
* ttype
) {
2673 while (ttype
->is_typedef()) {
2674 ttype
= ((t_typedef
*)ttype
)->get_type();
2677 t_program
* program
= ttype
->get_program();
2678 if (ttype
->is_service()) {
2679 return get_real_py_module(program
, gen_twisted_
, package_prefix_
) + "." + ttype
->get_name();
2681 if (program
!= NULL
&& program
!= program_
) {
2682 return get_real_py_module(program
, gen_twisted_
, package_prefix_
) + ".ttypes." + ttype
->get_name();
2684 return ttype
->get_name();
2688 * Converts the parse type to a Python tyoe
2690 string
t_py_generator::type_to_enum(t_type
* type
) {
2691 type
= get_true_type(type
);
2693 if (type
->is_base_type()) {
2694 t_base_type::t_base tbase
= ((t_base_type
*)type
)->get_base();
2696 case t_base_type::TYPE_VOID
:
2697 throw "NO T_VOID CONSTRUCT";
2698 case t_base_type::TYPE_STRING
:
2699 return "TType.STRING";
2700 case t_base_type::TYPE_BOOL
:
2701 return "TType.BOOL";
2702 case t_base_type::TYPE_I8
:
2703 return "TType.BYTE";
2704 case t_base_type::TYPE_I16
:
2706 case t_base_type::TYPE_I32
:
2708 case t_base_type::TYPE_I64
:
2710 case t_base_type::TYPE_DOUBLE
:
2711 return "TType.DOUBLE";
2713 } else if (type
->is_enum()) {
2715 } else if (type
->is_struct() || type
->is_xception()) {
2716 return "TType.STRUCT";
2717 } else if (type
->is_map()) {
2719 } else if (type
->is_set()) {
2721 } else if (type
->is_list()) {
2722 return "TType.LIST";
2725 throw "INVALID TYPE IN type_to_enum: " + type
->get_name();
2728 /** See the comment inside generate_py_struct_definition for what this is. */
2729 string
t_py_generator::type_to_spec_args(t_type
* ttype
) {
2730 while (ttype
->is_typedef()) {
2731 ttype
= ((t_typedef
*)ttype
)->get_type();
2734 if (ttype
->is_binary()) {
2736 } else if (gen_utf8strings_
&& ttype
->is_base_type()
2737 && reinterpret_cast<t_base_type
*>(ttype
)->is_string()) {
2739 } else if (ttype
->is_base_type() || ttype
->is_enum()) {
2741 } else if (ttype
->is_struct() || ttype
->is_xception()) {
2742 return "[" + type_name(ttype
) + ", None]";
2743 } else if (ttype
->is_map()) {
2744 return "(" + type_to_enum(((t_map
*)ttype
)->get_key_type()) + ", "
2745 + type_to_spec_args(((t_map
*)ttype
)->get_key_type()) + ", "
2746 + type_to_enum(((t_map
*)ttype
)->get_val_type()) + ", "
2747 + type_to_spec_args(((t_map
*)ttype
)->get_val_type()) + ", "
2748 + (is_immutable(ttype
) ? "True" : "False") + ")";
2750 } else if (ttype
->is_set()) {
2751 return "(" + type_to_enum(((t_set
*)ttype
)->get_elem_type()) + ", "
2752 + type_to_spec_args(((t_set
*)ttype
)->get_elem_type()) + ", "
2753 + (is_immutable(ttype
) ? "True" : "False") + ")";
2755 } else if (ttype
->is_list()) {
2756 return "(" + type_to_enum(((t_list
*)ttype
)->get_elem_type()) + ", "
2757 + type_to_spec_args(((t_list
*)ttype
)->get_elem_type()) + ", "
2758 + (is_immutable(ttype
) ? "True" : "False") + ")";
2761 throw "INVALID TYPE IN type_to_spec_args: " + ttype
->get_name();
2764 THRIFT_REGISTER_GENERATOR(
2767 " zope.interface: Generate code for use with zope.interface.\n"
2768 " twisted: Generate Twisted-friendly RPC services.\n"
2769 " tornado: Generate code for use with Tornado.\n"
2770 " no_utf8strings: Do not Encode/decode strings using utf8 in the generated code. Basically no effect for Python 3.\n"
2771 " coding=CODING: Add file encoding declare in generated file.\n"
2772 " slots: Generate code using slots for instance members.\n"
2773 " dynamic: Generate dynamic code, less code generated but slower.\n"
2774 " dynbase=CLS Derive generated classes from class CLS instead of TBase.\n"
2775 " dynfrozen=CLS Derive generated immutable classes from class CLS instead of TFrozenBase.\n"
2776 " dynexc=CLS Derive generated exceptions from CLS instead of TExceptionBase.\n"
2777 " dynimport='from foo.bar import CLS'\n"
2778 " Add an import line to generated code to find the dynbase class.\n"
2779 " package_prefix='top.package.'\n"
2780 " Package prefix for generated files.\n"
2781 " old_style: Deprecated. Generate old-style classes.\n")