krpctools 0.5.0__zip → 0.5.4__zip

{krpctools-0.5.0 → krpctools-0.5.4}/krpctools/clientgen/generator.py

@@ -55,6 +55,7 @@ class Generator:
             if 'default_value' in parameter:
                 value = decode_default_value(parameter['default_value'], typ)
                 info['default_value'] = self.parse_default_value(value, typ)
+            info['nullable'] = parameter.get('nullable', False)
             parameters.append(info)
         return parameters
 
@@ -65,6 +66,8 @@ class Generator:
         context = {
             'service_name': self._service,
             'service_id': self._defs['id'],
+            'service_documentation': self.parse_documentation(
+                self._defs.get('documentation', '')),
             'procedures': {},
             'properties': {},
             'classes': {},

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

@@ -3,6 +3,7 @@ import itertools
 from krpc.types import \
     ValueType, ClassType, EnumerationType, MessageType, \
     TupleType, ListType, SetType, DictionaryType
+import krpc.schema.KRPC_pb2 as KRPC
 from krpc.utils import snake_case
 from .generator import Generator
 from .docparser import DocParser
@@ -14,32 +15,80 @@ class PythonGenerator(Generator):
 
     language = PythonLanguage()
 
-    def parse_type_specification(self, typ):
+    def parse_python_type(self, typ):
         if typ is None:
             return 'None'
         if isinstance(typ, ValueType):
-            return self.language.parse_type(typ)
+            mapping = {
+                KRPC.Type.DOUBLE: 'double',
+                KRPC.Type.FLOAT: 'float',
+                KRPC.Type.SINT32: 'sint32',
+                KRPC.Type.SINT64: 'sint64',
+                KRPC.Type.UINT32: 'uint32',
+                KRPC.Type.UINT64: 'uint64',
+                KRPC.Type.BOOL: 'bool',
+                KRPC.Type.STRING: 'string',
+                KRPC.Type.BYTES: 'bytes'
+            }
+            return 'self._client._types.%s_type' % \
+                mapping[typ.protobuf_type.code]
         if isinstance(typ, MessageType):
-            return self.language.parse_type(typ)
+            return 'self._client._types.%s_type' % \
+                snake_case(typ.python_type.__name__)
         if isinstance(typ, ClassType):
-            return self.language.parse_type(typ)
+            return 'self._client._types.class_type("%s", "%s")' % \
+                (typ.protobuf_type.service, typ.protobuf_type.name)
         if isinstance(typ, EnumerationType):
-            return self.language.parse_type(typ)
+            return 'self._client._types.enumeration_type("%s", "%s")' % \
+                (typ.protobuf_type.service, typ.protobuf_type.name)
         if isinstance(typ, TupleType):
-            return 'Tuple[%s]' % \
+            return 'self._client._types.tuple_type(%s)' % \
+                ', '.join(self.parse_python_type(x) for x in typ.value_types)
+        if isinstance(typ, ListType):
+            return 'self._client._types.list_type(%s)' % \
+                self.parse_python_type(typ.value_type)
+        if isinstance(typ, SetType):
+            return 'self._client._types.set_type(%s)' % \
+                self.parse_python_type(typ.value_type)
+        if isinstance(typ, DictionaryType):
+            return 'self._client._types.dictionary_type(%s, %s)' % \
+                (self.parse_python_type(typ.key_type),
+                 self.parse_python_type(typ.value_type))
+        raise RuntimeError('Unknown type ' + typ)
+
+    def parse_type_specification(self, typ, is_nullable=False):
+        if typ is None:
+            spec = 'None'
+        elif isinstance(typ, ValueType):
+            spec = self.language.parse_type(typ)
+        elif isinstance(typ, MessageType):
+            if typ.python_type == KRPC.Event:
+                spec = 'Event'
+            else:
+                return 'KRPC_pb2.%s' % typ.python_type.__name__
+        elif isinstance(typ, (ClassType, EnumerationType)):
+            spec = typ.protobuf_type.name
+            if typ.protobuf_type.service != self.service_name:
+                spec = typ.protobuf_type.service.lower() + "." + spec
+        elif isinstance(typ, TupleType):
+            spec = 'Tuple[%s]' % \
                 ','.join(self.parse_type_specification(t)
                          for t in typ.value_types)
-        if isinstance(typ, ListType):
-            return 'List[%s]' % \
+        elif isinstance(typ, ListType):
+            spec = 'List[%s]' % \
                 self.parse_type_specification(typ.value_type)
-        if isinstance(typ, SetType):
-            return 'Set[%s]' % \
+        elif isinstance(typ, SetType):
+            spec = 'Set[%s]' % \
                 self.parse_type_specification(typ.value_type)
-        if isinstance(typ, DictionaryType):
-            return 'Dict[%s, %s]' % \
+        elif isinstance(typ, DictionaryType):
+            spec = 'Dict[%s, %s]' % \
                 (self.parse_type_specification(typ.key_type),
                  self.parse_type_specification(typ.value_type))
-        raise RuntimeError('Unknown type ' + typ)
+        else:
+            raise RuntimeError('Unknown type ' + typ)
+        if is_nullable:
+            return 'Optional[%s]' % spec
+        return spec
 
     def parse_context(self, context):
         # Expand service properties into get and set methods
@@ -145,16 +194,22 @@ class PythonGenerator(Generator):
         for info in procedures:
             info['return_type'] = {
                 'name': info['return_type'],
+                'python_type': self.parse_python_type(
+                    self.get_return_type(info['procedure'])
+                ),
                 'spec': self.parse_type_specification(
-                    self.get_return_type(info['procedure']))
+                    self.get_return_type(info['procedure']),
+                    info['procedure'].get('return_is_nullable', False))
             }
             pos = 0
             for i, pinfo in enumerate(info['parameters']):
                 ptype = as_type(
                     self.types, info['procedure']['parameters'][i]['type'])
+                nullable = info['procedure']['parameters'][i].get('nullable', False)
                 pinfo['type'] = {
                     'name': pinfo['type'],
-                    'spec': self.parse_type_specification(ptype)
+                    'python_type': self.parse_python_type(ptype),
+                    'spec': self.parse_type_specification(ptype, nullable)
                 }
                 pos += 1
 
@@ -166,74 +221,98 @@ class PythonGenerator(Generator):
             for info in items:
                 info['return_type'] = {
                     'name': info['return_type'],
+                    'python_type': self.parse_python_type(
+                        self.get_return_type(info['procedure'])
+                    ),
                     'spec': self.parse_type_specification(
-                        self.get_return_type(info['procedure']))
+                        self.get_return_type(info['procedure']),
+                        info['procedure'].get('return_is_nullable', False))
                 }
                 pos = 0
                 for i, pinfo in enumerate(info['parameters']):
                     ptype = as_type(
                         self.types,
                         info['procedure']['parameters'][i+1]['type'])
+                    nullable = info['procedure']['parameters'][i+1].get('nullable', False)
                     pinfo['type'] = {
                         'name': pinfo['type'],
-                        'spec': self.parse_type_specification(ptype)
+                        'python_type': self.parse_python_type(ptype),
+                        'spec': self.parse_type_specification(ptype, nullable)
                     }
                     pos += 1
 
         return context
 
+    def parse_default_value(self, value, typ):
+        result = super().parse_default_value(value, typ)
+        # Fix references to types within the same service
+        prefix = self.service_name + "."
+        if result.startswith(prefix):
+            result = result[len(prefix):]
+        return result
+
     @staticmethod
     def parse_documentation(documentation):
         documentation = PythonDocParser().parse(documentation)
-        if documentation == '':
+        if len(documentation) == 0:
             return ''
-        documentation = "\"\"\"" + documentation + "\"\"\""
-        # content = content.replace('  <param', '<param')
-        # content = content.replace('  <returns', '<returns')
-        # content = content.replace('  <remarks', '<remarks')
-        return documentation
+        return '"""\n' + documentation + '\n"""'
 
 
 class PythonDocParser(DocParser):
+    language = PythonLanguage()
+
     def parse_summary(self, node):
-        return self.parse_node(node).strip()
+        return self.parse_node(node).strip('\n')
 
     def parse_remarks(self, node):
-        return '\n\n'+self.parse_node(node).strip()
+        return '\n\n'+self.parse_node(node).strip('\n')
 
     def parse_param(self, node):
-        return '\n:%s %s' % (snake_case(node.attrib['name']),
-                             self.parse_node(node).strip())
+        name = ':param %s: ' % self.language.parse_name(node.attrib['name'])
+        desc = self.parse_node(node, indent=len(name))[len(name):]
+        if len(desc) == 0:
+            return ''
+        return '\n\n' + name + desc
 
     def parse_returns(self, node):
-        return '\n@return %s' % self.parse_node(node).strip()
+        name = ':returns: '
+        desc = self.parse_node(node, indent=len(name))[len(name):]
+        if len(desc) == 0:
+            return ''
+        return '\n\n' + name + desc
 
     def parse_see(self, node):
         return self.parse_cref(node.attrib['cref'])
 
-    @staticmethod
-    def parse_paramref(node):
-        return snake_case(node.attrib['name'])
+    def parse_paramref(self, node):
+        return self.language.parse_name(node.attrib['name'])
 
     @staticmethod
     def parse_a(node):
-        return node.text
+        return "`%s <%s>`_" % \
+            (node.text.replace('\n', ' '), node.attrib['href'])
 
-    @staticmethod
-    def parse_c(node):
-        return '{@code %s}' % node.text
+    def parse_c(self, node):
+        code = node.text
+        code = self.language.value_map.get(code, code)
+        return '``%s``' % code
 
     @staticmethod
     def parse_math(node):
-        return node.text
+        return '``%s``' % node.text
 
     def parse_list(self, node):
-        content = ['<li>%s\n' % self.parse_node(item[0], indent=2)[2:].rstrip()
-                   for item in node]
-        return '<p><ul>'+'\n'+''.join(content)+'</ul></p>'
+        lines = [
+            ' * ' + self.parse_node(item[0], indent=3)[3:].rstrip()
+            for item in node
+        ]
+        content = '\n'.join(lines)
+        return content
 
     @staticmethod
     def parse_cref(cref):
+        # FIXME: is this correct?
         if cref[0] == 'M':
             cref = cref[2:].split('.')
             member = lower_camel_case(cref[-1])

krpctools-0.5.4/krpctools/clientgen/python.tmpl

@@ -0,0 +1,289 @@
+# pylint: disable=line-too-long,invalid-name,redefined-builtin,too-many-lines
+from __future__ import annotations
+from typing import Tuple, Set, Dict, List, Optional, TYPE_CHECKING
+import krpc.schema
+from krpc.schema import KRPC_pb2
+from krpc.types import TypeBase, ClassBase, WrappedClass, DocEnum
+from krpc.event import Event
+if TYPE_CHECKING:
+    from krpc.services import Client
+{% for service in dependencies %}
+from krpc.services import {{service|lower()}}
+{% endfor %}
+
+{% macro arg_list(parameters) %}
+self{% for x in parameters %}, {{x.name}}: {{ x.type.spec }}{%if 'default_value' in x %} = {{x.default_value}}{% endif %}{% endfor %}{% endmacro %}
+{% macro static_arg_list(parameters) %}
+{% for x in parameters %}{{x.name}}: {{ x.type.spec }}{%if 'default_value' in x %} = {{x.default_value}}{% endif %}{% if not loop.last %}, {% endif %}{% endfor %}{% endmacro %}
+{% macro arg_names(parameters) %}
+{% for x in parameters %}"{{x.name}}"{% if not loop.last %}, {% endif %}{% endfor %}{% endmacro %}
+{% macro arg_values(parameters) %}
+{% for x in parameters %}{{x.name}}{% if not loop.last %}, {% endif %}{% endfor %}{% endmacro %}
+{% macro arg_types(parameters) %}
+{% for x in parameters %}{{x.type.python_type}}{% if not loop.last %}, {% endif %}{% endfor %}{% endmacro %}
+
+{% for enum_name, enumeration in enumerations.items() %}
+class {{enum_name}}(DocEnum):
+{% if enumeration.documentation %}{{ enumeration.documentation | indent(width=4) }}
+{% endif %}
+    {% for enum_value in enumeration['values'] %}
+    {{enum_value['name']}} = {{enum_value['value']}}{% if enum_value.documentation %}, {{ enum_value.documentation }}{% endif %}
+
+    {% endfor %}
+
+
+{% endfor %}
+{% for exception_name, exception in exceptions.items() %}
+class {{exception_name}}(RuntimeError):
+{% if exception.documentation %}{{ exception.documentation | indent(width=4) }}
+{% endif %}
+    pass
+
+
+{% endfor %}
+{% for class_name, class in classes.items() %}
+class {{class_name}}(ClassBase):
+{% if class.documentation %}{{ class.documentation | indent(width=4) }}
+{% endif %}
+    {% for prop_name, prop in class['properties'].items() %}
+    {% if 'getter' in prop %}
+    @property
+    def {{prop_name}}(self) -> {{ prop.getter.return_type.spec }}:
+{% if prop.getter.documentation %}{{ prop.getter.documentation | indent(width=8) }}
+{% endif %}
+        return self._client._invoke(
+            "{{ service_name }}",
+            "{{ prop.getter.remote_name }}",
+            [self],
+            ["self"],
+            [self._client._types.class_type("{{ service_name }}", "{{ class_name }}")],
+            {{ prop.getter.return_type.python_type }}
+        )
+
+    {% else %}
+    @property
+    def {{prop_name}}(self) -> {{ prop.setter.parameters[0].type.spec }}:
+        raise NotImplementedError
+
+    {% endif %}
+    {% if 'setter' in prop %}
+    @{{prop_name}}.setter
+    def {{prop_name}}({{ arg_list(prop.setter.parameters) }}) -> None:
+        return self._client._invoke(
+            "{{ service_name }}",
+            "{{ prop.setter.remote_name }}",
+            [self, {{ arg_values(prop.setter.parameters) }}],
+            ["self", {{ arg_names(prop.setter.parameters) }}],
+            [self._client._types.class_type("{{ service_name }}", "{{ class_name }}"), {{ arg_types(prop.setter.parameters) }}],
+            None
+        )
+
+    {% endif %}
+    {% if 'getter' in prop %}
+    def _return_type_{{prop_name}}(self) -> TypeBase:
+        return {{ prop.getter.return_type.python_type }}
+
+    def _build_call_{{prop_name}}(self) -> KRPC_pb2.ProcedureCall:
+        return self._client._build_call(
+            "{{ service_name }}",
+            "{{ prop.getter.remote_name }}",
+            [self],
+            ["self"],
+            [self._client._types.class_type("{{ service_name }}", "{{ class_name }}")],
+            {{ prop.getter.return_type.python_type }}
+        )
+
+    {% endif %}
+    {% endfor %}
+    {% for proc_name, procedure in class['methods'].items() %}
+    def {{proc_name}}({{ arg_list(procedure.parameters) }}) -> {{ procedure.return_type.spec }}:
+{% if procedure.documentation %}{{ procedure.documentation | indent(width=8) }}
+{% endif %}
+        return self._client._invoke(
+            "{{ service_name }}",
+            "{{ procedure.remote_name }}",
+            [self, {{ arg_values(procedure.parameters) }}],
+            ["self", {{ arg_names(procedure.parameters) }}],
+            [self._client._types.class_type("{{ service_name }}", "{{ class_name }}"), {{ arg_types(procedure.parameters) }}],
+            {{ procedure.return_type.python_type }}
+        )
+
+    def _return_type_{{proc_name}}(self) -> TypeBase:
+        return {{ procedure.return_type.python_type }}
+
+    def _build_call_{{proc_name}}({{ arg_list(procedure.parameters) }}) -> KRPC_pb2.ProcedureCall:
+        return self._client._build_call(
+            "{{ service_name }}",
+            "{{ procedure.remote_name }}",
+            [self, {{ arg_values(procedure.parameters) }}],
+            ["self", {{ arg_names(procedure.parameters) }}],
+            [self._client._types.class_type("{{ service_name }}", "{{ class_name }}"), {{ arg_types(procedure.parameters) }}],
+            {{ procedure.return_type.python_type }}
+        )
+
+    {% endfor %}
+    {% for proc_name, procedure in class['static_methods'].items() %}
+    @classmethod
+    def {{proc_name}}(cls, {{ static_arg_list(procedure.parameters) }}) -> {{ procedure.return_type.spec }}:
+{% if procedure.documentation %}{{ procedure.documentation | indent(width=8) }}
+{% endif %}
+        self = cls
+        return cls._client._invoke(
+            "{{ service_name }}",
+            "{{ procedure.remote_name }}",
+            [{{ arg_values(procedure.parameters) }}],
+            [{{ arg_names(procedure.parameters) }}],
+            [{{ arg_types(procedure.parameters) }}],
+            {{ procedure.return_type.python_type }}
+        )
+
+    @classmethod
+    def _return_type_{{proc_name}}(cls) -> TypeBase:
+        self = cls
+        return {{ procedure.return_type.python_type }}
+
+    @classmethod
+    def _build_call_{{proc_name}}(cls, {{ static_arg_list(procedure.parameters) }}) -> KRPC_pb2.ProcedureCall:
+        self = cls
+        return self._client._build_call(
+            "{{ service_name }}",
+            "{{ procedure.remote_name }}",
+            [{{ arg_values(procedure.parameters) }}],
+            [{{ arg_names(procedure.parameters) }}],
+            [{{ arg_types(procedure.parameters) }}],
+            {{ procedure.return_type.python_type }}
+        )
+
+    {% endfor %}
+
+
+{% endfor %}
+class {{ service_name }}:
+{% if service_documentation %}{{ service_documentation | indent(width=4) }}
+{% endif %}
+
+    def __init__(self, client: Client) -> None:
+        self._client = client
+
+    def __getattribute__(self, name):
+        # Intercepts calls to obtain classes from the service,
+        # to inject the client instance so that it can be used
+        # for static method calls
+        classes = object.__getattribute__(self, "_classes")
+        if name in classes:
+            client = object.__getattribute__(self, "_client")
+            return WrappedClass(client, classes[name])
+
+        # Intercept calls to obtain enumeration types
+        enumerations = object.__getattribute__(self, "_enumerations")
+        if name in enumerations:
+           return enumerations[name]
+
+        # Intercept calls to obtain exception types
+        exceptions = object.__getattribute__(self, "_exceptions")
+        if name in exceptions:
+           return exceptions[name]
+
+        # Fall back to default behaviour
+        return object.__getattribute__(self, name)
+
+    def __dir__(self):
+        result = object.__dir__(self)
+        result.extend(object.__getattribute__(self, "_classes").keys())
+        result.extend(object.__getattribute__(self, "_enumerations").keys())
+        result.extend(object.__getattribute__(self, "_exceptions").keys())
+        return result
+
+    _classes = {
+    {% for class_name in classes.keys() %}
+        "{{class_name}}": {{ class_name }},
+    {% endfor %}
+    }
+    _enumerations = {
+    {% for enum_name in enumerations.keys() %}
+        "{{ enum_name }}": {{ enum_name }},
+    {% endfor %}
+    }
+    _exceptions = {
+    {% for exception_name in exceptions.keys() %}
+        "{{ exception_name }}": {{ exception_name }},
+    {% endfor %}
+    }
+
+    {% for prop_name, prop in properties.items() %}
+    {% if 'getter' in prop %}
+    @property
+    def {{prop_name}}(self) -> {{ prop.getter.return_type.spec }}:
+{% if prop.getter.documentation %}{{ prop.getter.documentation | indent(width=8) }}
+{% endif %}
+        return self._client._invoke(
+            "{{ service_name }}",
+            "{{ prop.getter.remote_name }}",
+            [],
+            [],
+            [],
+            {{ prop.getter.return_type.python_type }}
+        )
+
+    {% else %}
+    @property
+    def {{prop_name}}(self) -> {{ prop.setter.parameters[0].type.spec }}:
+        raise NotImplementedError
+
+    {% endif %}
+    {% if 'setter' in prop %}
+    @{{prop_name}}.setter
+    def {{prop_name}}({{ arg_list(prop.setter.parameters) }}) -> None:
+        return self._client._invoke(
+            "{{ service_name }}",
+            "{{ prop.setter.remote_name }}",
+            [{{ arg_values(prop.setter.parameters) }}],
+            [{{ arg_names(prop.setter.parameters) }}],
+            [{{ arg_types(prop.setter.parameters) }}],
+            None
+        )
+
+    {% endif %}
+    {% if 'getter' in prop %}
+    def _return_type_{{prop_name}}(self) -> TypeBase:
+        return {{ prop.getter.return_type.python_type }}
+
+    def _build_call_{{prop_name}}(self) -> KRPC_pb2.ProcedureCall:
+        return self._client._build_call(
+            "{{ service_name }}",
+            "{{ prop.getter.remote_name }}",
+            [],
+            [],
+            [],
+            {{ prop.getter.return_type.python_type }}
+        )
+
+    {% endif %}
+    {% endfor %}
+    {% for proc_name, procedure in procedures.items() %}
+    def {{proc_name}}({{ arg_list(procedure.parameters) }}) -> {{ procedure.return_type.spec }}:
+{% if procedure.documentation %}{{ procedure.documentation | indent(width=8) }}
+{% endif %}
+        return self._client._invoke(
+            "{{ service_name }}",
+            "{{ procedure.remote_name }}",
+            [{{ arg_values(procedure.parameters) }}],
+            [{{ arg_names(procedure.parameters) }}],
+            [{{ arg_types(procedure.parameters) }}],
+            {{ procedure.return_type.python_type }}
+        )
+
+    def _return_type_{{proc_name}}(self) -> TypeBase:
+        return {{ procedure.return_type.python_type }}
+
+    def _build_call_{{proc_name}}({{ arg_list(procedure.parameters) }}) -> KRPC_pb2.ProcedureCall:
+        return self._client._build_call(
+            "{{ service_name }}",
+            "{{ procedure.remote_name }}",
+            [{{ arg_values(procedure.parameters) }}],
+            [{{ arg_names(procedure.parameters) }}],
+            [{{ arg_types(procedure.parameters) }}],
+            {{ procedure.return_type.python_type }}
+        )
+
+    {% endfor %}

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

@@ -41,9 +41,7 @@ Service {{ x.name }}
 {{ parameters_description(x.parameters) }}
 {% 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 }}
 
@@ -64,9 +62,7 @@ Service {{ x.name }}
 
 {% 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 }}
 
@@ -83,9 +79,7 @@ Service {{ x.name }}
 {{ parameters_description(x.parameters[1:]) }}
 {% 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 }}
 
@@ -102,9 +96,7 @@ Service {{ x.name }}
 {{ parameters_description(x.parameters) }}
 {% 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 }}
 
@@ -169,5 +161,7 @@ krpc_connection_t connection{% if domain.return_type(return_type) != 'void' %},
 {% 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/cpp.tmpl

@@ -46,9 +46,7 @@
 {{ parameters_description(x.parameters) }}
 {% 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 }}
 
@@ -69,9 +67,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 }}
 
@@ -88,9 +84,7 @@
 {{ parameters_description(x.parameters[1:]) }}
 {% 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 }}
 
@@ -107,9 +101,7 @@
 {{ parameters_description(x.parameters) }}
 {% 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 }}
 
@@ -181,5 +173,7 @@
 {% endmacro %}
 
 {% macro game_scenes(x) %}
+{% if x != None and x != 'All' %}
 :Game Scenes: {{ x }}
+{% endif %}
 {% endmacro %}