krpctools 0.5.0__zip → 0.5.4__zip

{krpctools-0.5.0 → krpctools-0.5.4}/krpctools/docgen/java.tmpl

@@ -44,9 +44,7 @@
 {% endfor %}
 {% if hasdoc(x.documentation, './returns') %}{{ returns(x.documentation) | indent }}
 {% endif %}
-{% if x.game_scenes != None %}
    {{ game_scenes(x.game_scenes) }}
-{% endif %}
 
 {% if hasdoc(x.documentation, './remarks') %}{{ remarks(x.documentation) | indent }}
 
@@ -68,9 +66,7 @@
 
 {% if hasdoc(x.documentation, './returns') %}{{ returns(x.documentation) | indent }}
 {% endif %}
-{% if x.game_scenes != None %}
    {{ game_scenes(x.game_scenes) }}
-{% endif %}
 
 {% if hasdoc(x.documentation, './remarks') %}{{ remarks(x.documentation) | indent }}
 
@@ -90,9 +86,7 @@
 {% endfor %}
 {% if hasdoc(x.documentation, './returns') %}{{ returns(x.documentation) | indent }}
 {% endif %}
-{% if x.game_scenes != None %}
    {{ game_scenes(x.game_scenes) }}
-{% endif %}
 
 {% if hasdoc(x.documentation, './remarks') %}{{ remarks(x.documentation) | indent }}
 
@@ -112,9 +106,7 @@
 {% endfor %}
 {% if hasdoc(x.documentation, './returns') %}{{ returns(x.documentation) | indent }}
 {% endif %}
-{% if x.game_scenes != None %}
    {{ game_scenes(x.game_scenes) }}
-{% endif %}
 
 {% if hasdoc(x.documentation, './remarks') %}{{ remarks(x.documentation) | indent }}
 
@@ -167,5 +159,7 @@
 {% endmacro %}
 
 {% macro game_scenes(x) %}
+{% if x != None and x != 'All' %}
 :Game Scenes: {{ x }}
+{% endif %}
 {% endmacro %}

{krpctools-0.5.0 → krpctools-0.5.4}/krpctools/docgen/nodes.py

@@ -122,7 +122,8 @@ class Class(Appendable):
 
 class Parameter(Appendable):
     # pylint: disable=redefined-builtin
-    def __init__(self, name, type, documentation, default_value=None):
+    def __init__(self, name, type, documentation,
+                 default_value=None, nullable=False):
         super().__init__()
         self.name = name
         self.type = as_type(self.types, type)
@@ -130,6 +131,7 @@ class Parameter(Appendable):
         if default_value is not None:
             default_value = decode_default_value(default_value, self.type)
         self.default_value = default_value
+        self.nullable = nullable
         self.documentation = documentation
 
 

{krpctools-0.5.0 → krpctools-0.5.4}/krpctools/docgen/python.tmpl

@@ -47,9 +47,7 @@
 {% if x.return_type != None %}
    :rtype: {{ domain.type_description(x.return_type) }}
 {% endif %}
-{% if x.game_scenes != None %}
    {{ game_scenes(x.game_scenes) }}
-{% endif %}
 
 {% if hasdoc(x.documentation, './remarks') %}{{ remarks(x.documentation) | indent }}
 
@@ -68,9 +66,7 @@
 {% if hasdoc(x.documentation, './returns') %}{{ returns(x.documentation) | indent }}
 {% endif %}
    :rtype: {{ domain.type_description(x.type) }}
-{% if x.game_scenes != None %}
    {{ game_scenes(x.game_scenes) }}
-{% endif %}
 
 {% if hasdoc(x.documentation, './remarks') %}{{ remarks(x.documentation) | indent }}
 
@@ -93,9 +89,7 @@
 {% if x.return_type != None %}
    :rtype: {{ domain.type_description(x.return_type) }}
 {% endif %}
-{% if x.game_scenes != None %}
    {{ game_scenes(x.game_scenes) }}
-{% endif %}
 
 {% if hasdoc(x.documentation, './remarks') %}{{ remarks(x.documentation) | indent }}
 
@@ -118,9 +112,7 @@
 {% if x.return_type != None %}
    :rtype: {{ domain.type_description(x.return_type) }}
 {% endif %}
-{% if x.game_scenes != None %}
    {{ game_scenes(x.game_scenes) }}
-{% endif %}
 
 {% if hasdoc(x.documentation, './remarks') %}{{ remarks(x.documentation) | indent }}
 
@@ -179,5 +171,7 @@
 {% endmacro %}
 
 {% macro game_scenes(x) %}
+{% if x != None and x != 'All' %}
 :Game Scenes: {{ x }}
+{% endif %}
 {% endmacro %}

{krpctools-0.5.0 → krpctools-0.5.4}/krpctools/lang/python.py

@@ -4,6 +4,7 @@ from krpc.schema.KRPC_pb2 import Type
 from krpc.types import \
     ValueType, ClassType, EnumerationType, MessageType, \
     TupleType, ListType, SetType, DictionaryType
+from krpc.utils import snake_case
 from .language import Language
 
 
@@ -17,6 +18,9 @@ class PythonLanguage(Language):
         'false': 'False'
     }
 
+    def parse_name(self, name):
+        return super().parse_name(snake_case(name))
+
     def parse_type(self, typ):
         if isinstance(typ, ValueType):
             # python3 fix: get type name from protobuf type code
@@ -49,10 +53,10 @@ class PythonLanguage(Language):
         if (isinstance(typ, ValueType) and
                 typ.protobuf_type.code == Type.STRING):
             return '\'%s\'' % value
-        # python2 fix: convert set to string manually
-        if isinstance(typ, SetType):
-            return '{'+', '.join(self.parse_default_value(x, typ.value_type)
-                                 for x in value)+'}'
+        if value is None:
+            return 'None'
+        if isinstance(typ, EnumerationType):
+            return self.parse_type(typ) + '(%d)' % value
         return str(value)
 
     def shorten_ref(self, name):

{krpctools-0.5.0 → krpctools-0.5.4}/krpctools/servicedefs/__init__.py

@@ -53,7 +53,6 @@ def servicedefs(ksp, service, assemblies):
     if not os.path.exists(ksp):
         raise RuntimeError('Kerbal Space Program directory does not exist.')
 
-    # TODO: delete when done
     bindir = tempfile.mkdtemp(prefix='krpc-servicedefs-')
     tmpout = bindir+'/out.json'
 
@@ -70,7 +69,18 @@ def servicedefs(ksp, service, assemblies):
     ksp_dlls = [
         'Assembly-CSharp.dll',
         'Assembly-CSharp-firstpass.dll',
-        'UnityEngine.dll'
+        'UnityEngine.dll',
+        'UnityEngine.AnimationModule.dll',
+        'UnityEngine.AssetBundleModule.dll',
+        'UnityEngine.CoreModule.dll',
+        'UnityEngine.IMGUIModule.dll',
+        'UnityEngine.InputLegacyModule.dll',
+        'UnityEngine.ScreenCaptureModule.dll',
+        'UnityEngine.SharedInternalsModule.dll',
+        'UnityEngine.TextRenderingModule.dll',
+        'UnityEngine.UI.dll',
+        'UnityEngine.UIModule.dll',
+        'UnityEngine.UnityWebRequestWWWModule.dll',
     ]
     ksp_data = 'KSP_Data/Managed'
     if not os.path.exists(os.path.join(ksp, ksp_data)):
@@ -85,11 +95,14 @@ def servicedefs(ksp, service, assemblies):
              '--output=%s' % tmpout, service] + assemblies,
             stderr=subprocess.STDOUT)
     except subprocess.CalledProcessError as ex:
+        shutil.rmtree(bindir)
         raise RuntimeError(ex.output) from ex
 
     with open(tmpout, 'r') as fp:
         return fp.read()
 
+    shutil.rmtree(bindir)
+
 
 if __name__ == '__main__':
     main()

{krpctools-0.5.0 → krpctools-0.5.4}/krpctools/test/TestService.json

@@ -170,7 +170,8 @@
               "code": "CLASS",
               "service": "TestService",
               "name": "TestClass"
-            }
+            },
+            "nullable": true
           }
         ],
         "return_type": {
@@ -896,7 +897,8 @@
               "code": "CLASS",
               "service": "TestService",
               "name": "TestClass"
-            }
+            },
+            "nullable": true
           }
         ],
         "return_type": {
@@ -1055,6 +1057,44 @@
           }
         ],
         "documentation": ""
+      },
+      "TestClass_set_StringPropertyPrivateGet": {
+        "id": 54,
+        "parameters": [
+          {
+            "name": "this",
+            "type": {
+              "code": "CLASS",
+              "service": "TestService",
+              "name": "TestClass"
+            }
+          },
+          {
+            "name": "value",
+            "type": {
+              "code": "STRING"
+            }
+          }
+        ],
+        "documentation": ""
+      },
+      "TestClass_get_StringPropertyPrivateSet": {
+        "id": 55,
+        "parameters": [
+          {
+            "name": "this",
+            "type": {
+              "code": "CLASS",
+              "service": "TestService",
+              "name": "TestClass"
+            }
+          }
+        ],
+        "return_type": {
+          "code": "STRING"
+        },
+        "return_is_nullable": false,
+        "documentation": ""
       }
     },
     "classes": {

{krpctools-0.5.0 → krpctools-0.5.4}/krpctools/test/clientgen-TestService-cnano.txt

@@ -337,6 +337,10 @@ krpc_error_t krpc_TestService_TestClass_ObjectProperty(krpc_connection_t connect
 
 krpc_error_t krpc_TestService_TestClass_set_ObjectProperty(krpc_connection_t connection, krpc_TestService_TestClass_t instance, krpc_TestService_TestClass_t value);
 
+krpc_error_t krpc_TestService_TestClass_set_StringPropertyPrivateGet(krpc_connection_t connection, krpc_TestService_TestClass_t instance, const char * value);
+
+krpc_error_t krpc_TestService_TestClass_StringPropertyPrivateSet(krpc_connection_t connection, char * * returnValue, krpc_TestService_TestClass_t instance);
+
 // Implementation
 
 #ifndef KRPC_IMPL_TYPE_DICTIONARY_INT32_BOOL
@@ -2010,6 +2014,36 @@ inline krpc_error_t krpc_TestService_TestClass_set_ObjectProperty(krpc_connectio
   return KRPC_OK;
 }
 
+inline krpc_error_t krpc_TestService_TestClass_set_StringPropertyPrivateGet(krpc_connection_t connection, krpc_TestService_TestClass_t instance, const char * value) {
+  krpc_call_t _call;
+  krpc_argument_t _arguments[2];
+  KRPC_CHECK(krpc_call(&_call, 9999, 54, 2, _arguments));
+  KRPC_CHECK(krpc_add_argument(&_call, 0, &krpc_encode_callback_uint64, &instance));
+  KRPC_CHECK(krpc_add_argument(&_call, 1, &krpc_encode_callback_string, &value));
+  krpc_result_t _result = KRPC_RESULT_INIT_DEFAULT;
+  KRPC_CHECK(krpc_init_result(&_result));
+  KRPC_CHECK(krpc_invoke(connection, &_result.message, &_call.message));
+  KRPC_CHECK(krpc_free_result(&_result));
+  return KRPC_OK;
+}
+
+inline krpc_error_t krpc_TestService_TestClass_StringPropertyPrivateSet(krpc_connection_t connection, char * * returnValue, krpc_TestService_TestClass_t instance) {
+  krpc_call_t _call;
+  krpc_argument_t _arguments[1];
+  KRPC_CHECK(krpc_call(&_call, 9999, 55, 1, _arguments));
+  KRPC_CHECK(krpc_add_argument(&_call, 0, &krpc_encode_callback_uint64, &instance));
+  krpc_result_t _result = KRPC_RESULT_INIT_DEFAULT;
+  KRPC_CHECK(krpc_init_result(&_result));
+  KRPC_CHECK(krpc_invoke(connection, &_result.message, &_call.message));
+  if (returnValue) {
+    pb_istream_t _stream;
+    KRPC_CHECK(krpc_get_return_value(&_result, &_stream));
+    KRPC_CHECK(krpc_decode_string(&_stream, returnValue));
+  }
+  KRPC_CHECK(krpc_free_result(&_result));
+  return KRPC_OK;
+}
+
 inline krpc_error_t krpc_TestService_TestClass_StaticMethod(krpc_connection_t connection, char * * returnValue, const char * a, const char * b) {
   krpc_call_t _call;
   krpc_argument_t _arguments[2];

{krpctools-0.5.0 → krpctools-0.5.4}/krpctools/test/clientgen-TestService-cpp.txt

@@ -344,6 +344,10 @@ class TestService : public Service {
 
     void set_object_property(TestService::TestClass value);
 
+    void set_string_property_private_get(std::string value);
+
+    std::string string_property_private_set();
+
     ::krpc::Stream<std::string> float_to_string_stream(float x);
 
     ::krpc::Stream<std::string> get_value_stream();
@@ -358,6 +362,8 @@ class TestService : public Service {
 
     ::krpc::Stream<TestService::TestClass> object_property_stream();
 
+    ::krpc::Stream<std::string> string_property_private_set_stream();
+
     ::krpc::schema::ProcedureCall float_to_string_call(float x);
 
     ::krpc::schema::ProcedureCall get_value_call();
@@ -375,6 +381,10 @@ class TestService : public Service {
     ::krpc::schema::ProcedureCall object_property_call();
 
     ::krpc::schema::ProcedureCall set_object_property_call(TestService::TestClass value);
+
+    ::krpc::schema::ProcedureCall set_string_property_private_get_call(std::string value);
+
+    ::krpc::schema::ProcedureCall string_property_private_set_call();
   };
 };
 
@@ -1322,6 +1332,22 @@ inline void TestService::TestClass::set_object_property(TestService::TestClass v
   this->_client->invoke("TestService", "TestClass_set_ObjectProperty", _args);
 }
 
+inline void TestService::TestClass::set_string_property_private_get(std::string value) {
+  std::vector<std::string> _args;
+  _args.push_back(encoder::encode(*this));
+  _args.push_back(encoder::encode(value));
+  this->_client->invoke("TestService", "TestClass_set_StringPropertyPrivateGet", _args);
+}
+
+inline std::string TestService::TestClass::string_property_private_set() {
+  std::vector<std::string> _args;
+  _args.push_back(encoder::encode(*this));
+  std::string _data = this->_client->invoke("TestService", "TestClass_get_StringPropertyPrivateSet", _args);
+  std::string _result;
+  decoder::decode(_result, _data, this->_client);
+  return _result;
+}
+
 inline std::string TestService::TestClass::static_method(Client& _client, std::string a = "", std::string b = "") {
     std::vector<std::string> _args;
   _args.push_back(encoder::encode(a));
@@ -1374,6 +1400,12 @@ inline ::krpc::Stream<TestService::TestClass> TestService::TestClass::object_pro
   return ::krpc::Stream<TestService::TestClass>(this->_client, this->_client->build_call("TestService", "TestClass_get_ObjectProperty", _args));
 }
 
+inline ::krpc::Stream<std::string> TestService::TestClass::string_property_private_set_stream() {
+  std::vector<std::string> _args;
+  _args.push_back(encoder::encode(*this));
+  return ::krpc::Stream<std::string>(this->_client, this->_client->build_call("TestService", "TestClass_get_StringPropertyPrivateSet", _args));
+}
+
 inline ::krpc::Stream<std::string> TestService::TestClass::static_method_stream(Client& _client, std::string a = "", std::string b = "") {
   std::vector<std::string> _args;
   _args.push_back(encoder::encode(a));
@@ -1437,6 +1469,19 @@ inline ::krpc::schema::ProcedureCall TestService::TestClass::set_object_property
   return this->_client->build_call("TestService", "TestClass_set_ObjectProperty", _args);
 }
 
+inline ::krpc::schema::ProcedureCall TestService::TestClass::set_string_property_private_get_call(std::string value) {
+  std::vector<std::string> _args;
+  _args.push_back(encoder::encode(*this));
+  _args.push_back(encoder::encode(value));
+  return this->_client->build_call("TestService", "TestClass_set_StringPropertyPrivateGet", _args);
+}
+
+inline ::krpc::schema::ProcedureCall TestService::TestClass::string_property_private_set_call() {
+  std::vector<std::string> _args;
+  _args.push_back(encoder::encode(*this));
+  return this->_client->build_call("TestService", "TestClass_get_StringPropertyPrivateSet", _args);
+}
+
 inline ::krpc::schema::ProcedureCall TestService::TestClass::static_method_call(Client& _client, std::string a = "", std::string b = "") {
   std::vector<std::string> _args;
   _args.push_back(encoder::encode(a));

{krpctools-0.5.0 → krpctools-0.5.4}/krpctools/test/clientgen-TestService-csharp.txt

@@ -622,5 +622,26 @@ namespace KRPC.Client.Services.TestService
                 connection.Invoke ("TestService", "TestClass_set_ObjectProperty", _args);
             }
         }
+
+        public string StringPropertyPrivateGet {
+            set {
+                var _args = new ByteString[] {
+                    global::KRPC.Client.Encoder.Encode (this, typeof(TestService.TestClass)),
+                    global::KRPC.Client.Encoder.Encode (value, typeof(string))
+                };
+                connection.Invoke ("TestService", "TestClass_set_StringPropertyPrivateGet", _args);
+            }
+        }
+
+        [global::KRPC.Client.Attributes.RPCAttribute ("TestService", "TestClass_get_StringPropertyPrivateSet")]
+        public string StringPropertyPrivateSet {
+            get {
+                var _args = new ByteString[] {
+                    global::KRPC.Client.Encoder.Encode (this, typeof(TestService.TestClass))
+                };
+                ByteString _data = connection.Invoke ("TestService", "TestClass_get_StringPropertyPrivateSet", _args);
+                return (string)global::KRPC.Client.Encoder.Decode (_data, typeof(string), connection);
+            }
+        }
     }
 }

{krpctools-0.5.0 → krpctools-0.5.4}/krpctools/test/clientgen-TestService-java.txt

@@ -613,6 +613,28 @@ public class TestService {
             this.connection.invoke("TestService", "TestClass_set_ObjectProperty", _args);
         }
 
+        @SuppressWarnings({ "unchecked" })
+        @RPCInfo(service = "TestService", procedure = "TestClass_set_StringPropertyPrivateGet", types = _Types.class)
+        public void setStringPropertyPrivateGet(String value) throws RPCException
+        {
+            ByteString[] _args = new ByteString[] {
+                Encoder.encode(this, krpc.client.Types.createClass("TestService", "TestClass")),
+                Encoder.encode(value, krpc.client.Types.createValue(krpc.schema.KRPC.Type.TypeCode.STRING))
+            };
+            this.connection.invoke("TestService", "TestClass_set_StringPropertyPrivateGet", _args);
+        }
+
+        @SuppressWarnings({ "unchecked" })
+        @RPCInfo(service = "TestService", procedure = "TestClass_get_StringPropertyPrivateSet", types = _Types.class)
+        public String getStringPropertyPrivateSet() throws RPCException
+        {
+            ByteString[] _args = new ByteString[] {
+                Encoder.encode(this, krpc.client.Types.createClass("TestService", "TestClass"))
+            };
+            ByteString _data = this.connection.invoke("TestService", "TestClass_get_StringPropertyPrivateSet", _args);
+            return (String) Encoder.decode(_data, krpc.client.Types.createValue(krpc.schema.KRPC.Type.TypeCode.STRING), this.connection);
+        }
+
         @SuppressWarnings({ "unchecked" })
         @RPCInfo(service = "TestService", procedure = "TestClass_static_StaticMethod", types = _Types.class)
         public static String staticMethod(Connection connection, String a, String b) throws RPCException
@@ -735,6 +757,10 @@ public class TestService {
                 return krpc.client.Types.createClass("TestService", "TestClass");
             case "TestClass_set_ObjectProperty":
                 return null;
+            case "TestClass_set_StringPropertyPrivateGet":
+                return null;
+            case "TestClass_get_StringPropertyPrivateSet":
+                return krpc.client.Types.createValue(krpc.schema.KRPC.Type.TypeCode.STRING);
             }
             throw new IllegalArgumentException("Procedure '" + procedure +"' not found");
         }
@@ -954,6 +980,15 @@ public class TestService {
                     krpc.client.Types.createClass("TestService", "TestClass"),
                     krpc.client.Types.createClass("TestService", "TestClass")
                 };
+            case "TestClass_set_StringPropertyPrivateGet":
+                return new krpc.schema.KRPC.Type[] {
+                    krpc.client.Types.createClass("TestService", "TestClass"),
+                    krpc.client.Types.createValue(krpc.schema.KRPC.Type.TypeCode.STRING)
+                };
+            case "TestClass_get_StringPropertyPrivateSet":
+                return new krpc.schema.KRPC.Type[] {
+                    krpc.client.Types.createClass("TestService", "TestClass")
+                };
             case "TestClass_static_StaticMethod":
                 return new krpc.schema.KRPC.Type[] {
                     krpc.client.Types.createValue(krpc.schema.KRPC.Type.TypeCode.STRING),

{krpctools-0.5.0 → krpctools-0.5.4}/krpctools/test/clientgentest.py

@@ -11,6 +11,12 @@ class ClientGenTestCase:
         g = self.generator(
             macro_template, service_name, defs[service_name])
         actual = g.generate()
+
+        # with open('/home/alex/workspaces/krpc/krpc/' +
+        #           'tools/krpctools/krpctools/test/' +
+        #           'clientgen-'+name+'-'+self.language+'.txt', 'w') as f:
+        #     f.write(actual)
+
         expected = resource_string(
             'krpctools.test',
             'clientgen-'+name+'-'+self.language+'.txt').decode('utf-8')