po/update_msg.py

   1 # $Id$
   2 # ***** BEGIN GPL LICENSE BLOCK *****
   3 #
   4 # This program is free software; you can redistribute it and/or
   5 # modify it under the terms of the GNU General Public License
   6 # as published by the Free Software Foundation; either version 2
   7 # of the License, or (at your option) any later version.
   8 #
   9 # This program is distributed in the hope that it will be useful,
  10 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12 # GNU General Public License for more details.
  13 #
  14 # You should have received a copy of the GNU General Public License
  15 # along with this program; if not, write to the Free Software Foundation,
  16 # Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  17 #
  18 # ***** END GPL LICENSE BLOCK *****
  19
  20 # <pep8-80 compliant>
  21
  22 # Write out messages.txt from blender
  23
  24 # Execite:
  25 #   blender --background --python po/update_msg.py
  26
  27 import os
  28
  29 CURRENT_DIR = os.path.abspath(os.path.dirname(__file__))
  30 SOURCE_DIR = os.path.normpath(os.path.abspath(os.path.join(CURRENT_DIR, "..")))
  31
  32 FILE_NAME_MESSAGES = os.path.join(CURRENT_DIR, "messages.txt")
  33 COMMENT_PREFIX = "#~ "
  34
  35
  36 def dump_messages_rna(messages):
  37     import bpy
  38
  39     def classBlackList():
  40         blacklist_rna_class = [
  41                                # core classes
  42                                "Context", "Event", "Function", "UILayout",
  43                                "BlendData",
  44                                # registerable classes
  45                                "Panel", "Menu", "Header", "RenderEngine",
  46                                "Operator", "OperatorMacro", "UnknownType"
  47                                # window classes
  48                                "WindowManager", "Window"
  49                                ]
  50
  51         # ---------------------------------------------------------------------
  52         # Collect internal operators
  53
  54         # extend with all internal operators
  55         # note that this uses internal api introspection functions
  56         # all possible operator names
  57         op_names = list(sorted(set(
  58             [cls.bl_rna.identifier for cls in
  59              bpy.types.OperatorProperties.__subclasses__()] +
  60             [cls.bl_rna.identifier for cls in
  61              bpy.types.Operator.__subclasses__()] +
  62             [cls.bl_rna.identifier for cls in
  63              bpy.types.OperatorMacro.__subclasses__()]
  64             )))
  65
  66         get_inatance = __import__("_bpy").ops.get_instance
  67         path_resolve = type(bpy.context).__base__.path_resolve
  68         for idname in op_names:
  69             op = get_inatance(idname)
  70             if 'INTERNAL' in path_resolve(op, "bl_options"):
  71                 blacklist_rna_class.append(idname)
  72
  73         # ---------------------------------------------------------------------
  74         # Collect builtin classes we dont need to doc
  75         blacklist_rna_class.append("Property")
  76         blacklist_rna_class.extend(
  77                 [cls.__name__ for cls in
  78                  bpy.types.Property.__subclasses__()])
  79
  80         # ---------------------------------------------------------------------
  81         # Collect classes which are attached to collections, these are api
  82         # access only.
  83         collection_props = set()
  84         for cls_id in dir(bpy.types):
  85             cls = getattr(bpy.types, cls_id)
  86             for prop in cls.bl_rna.properties:
  87                 if prop.type == 'COLLECTION':
  88                     prop_cls = prop.srna
  89                     if prop_cls is not None:
  90                         collection_props.add(prop_cls.identifier)
  91         blacklist_rna_class.extend(sorted(collection_props))
  92
  93         return blacklist_rna_class
  94
  95     blacklist_rna_class = classBlackList()
  96
  97     def filterRNA(bl_rna):
  98         id = bl_rna.identifier
  99         if id in blacklist_rna_class:
 100             print("  skipping", id)
 101             return True
 102         return False
 103
 104     # -------------------------------------------------------------------------
 105     # Function definitions
 106
 107     def walkProperties(bl_rna):
 108         import bpy
 109
 110         # get our parents properties not to export them multiple times
 111         bl_rna_base = bl_rna.base
 112         if bl_rna_base:
 113             bl_rna_base_props = bl_rna_base.properties.values()
 114         else:
 115             bl_rna_base_props = ()
 116
 117         for prop in bl_rna.properties:
 118             # only write this property is our parent hasn't got it.
 119             if prop in bl_rna_base_props:
 120                 continue
 121             if prop.identifier == "rna_type":
 122                 continue
 123
 124             msgsrc = "bpy.types.%s.%s" % (bl_rna.identifier, prop.identifier)
 125             messages.setdefault(prop.name, []).append(msgsrc)
 126             messages.setdefault(prop.description, []).append(msgsrc)
 127
 128             if isinstance(prop, bpy.types.EnumProperty):
 129                 for item in prop.enum_items:
 130                     msgsrc = "bpy.types.%s.%s, '%s'" % (bl_rna.identifier,
 131                                                         prop.identifier,
 132                                                         item.identifier,
 133                                                         )
 134                     messages.setdefault(item.name, []).append(msgsrc)
 135                     messages.setdefault(item.description, []).append(msgsrc)
 136
 137     def walkRNA(bl_rna):
 138
 139         if filterRNA(bl_rna):
 140             return
 141
 142         msgsrc = "bpy.types.%s" % bl_rna.identifier
 143
 144         if bl_rna.name and bl_rna.name != bl_rna.identifier:
 145             messages.setdefault(bl_rna.name, []).append(msgsrc)
 146
 147         if bl_rna.description:
 148             messages.setdefault(bl_rna.description, []).append(msgsrc)
 149
 150         if hasattr(bl_rna, 'bl_label') and  bl_rna.bl_label:
 151             messages.setdefault(bl_rna.bl_label, []).append(msgsrc)
 152
 153         walkProperties(bl_rna)
 154
 155     def walkClass(cls):
 156         walkRNA(cls.bl_rna)
 157
 158     def walk_keymap_hierarchy(hier, msgsrc_prev):
 159         for lvl in hier:
 160             msgsrc = "%s.%s" % (msgsrc_prev, lvl[1])
 161             messages.setdefault(lvl[0], []).append(msgsrc)
 162
 163             if lvl[3]:
 164                 walk_keymap_hierarchy(lvl[3], msgsrc)
 165
 166     # -------------------------------------------------------------------------
 167     # Dump Messages
 168
 169     def full_class_id(cls):
 170         """ gives us 'ID.Lamp.AreaLamp' which is best for sorting.
 171         """
 172         cls_id = ""
 173         bl_rna = cls.bl_rna
 174         while bl_rna:
 175             cls_id = "%s.%s" % (bl_rna.identifier, cls_id)
 176             bl_rna = bl_rna.base
 177         return cls_id
 178
 179     cls_list = type(bpy.context).__base__.__subclasses__()
 180     cls_list.sort(key=full_class_id)
 181     for cls in cls_list:
 182         walkClass(cls)
 183
 184     cls_list = bpy.types.Space.__subclasses__()
 185     cls_list.sort(key=full_class_id)
 186     for cls in cls_list:
 187         walkClass(cls)
 188
 189     cls_list = bpy.types.Operator.__subclasses__()
 190     cls_list.sort(key=full_class_id)
 191     for cls in cls_list:
 192         walkClass(cls)
 193
 194     cls_list = bpy.types.OperatorProperties.__subclasses__()
 195     cls_list.sort(key=full_class_id)
 196     for cls in cls_list:
 197         walkClass(cls)
 198
 199     cls_list = bpy.types.Menu.__subclasses__()
 200     cls_list.sort(key=full_class_id)
 201     for cls in cls_list:
 202         walkClass(cls)
 203
 204     from bpy_extras.keyconfig_utils import KM_HIERARCHY
 205
 206     walk_keymap_hierarchy(KM_HIERARCHY, "KM_HIERARCHY")
 207
 208
 209 def dump_messages_pytext(messages):
 210     """ dumps text inlined in the python user interface: eg.
 211
 212         layout.prop("someprop", text="My Name")
 213     """
 214     import ast
 215
 216     # -------------------------------------------------------------------------
 217     # Gather function names
 218
 219     import bpy
 220     # key: func_id
 221     # val: [(arg_kw, arg_pos), (arg_kw, arg_pos), ...]
 222     func_translate_args = {}
 223
 224     # so far only 'text' keywords, but we may want others translated later
 225     translate_kw = ("text", )
 226
 227     for func_id, func in bpy.types.UILayout.bl_rna.functions.items():
 228         # check it has a 'text' argument
 229         for (arg_pos, (arg_kw, arg)) in enumerate(func.parameters.items()):
 230             if ((arg_kw in translate_kw) and
 231                 (arg.is_output == False) and
 232                 (arg.type == 'STRING')):
 233
 234                 func_translate_args.setdefault(func_id, []).append((arg_kw,
 235                                                                     arg_pos))
 236     # print(func_translate_args)
 237
 238     # -------------------------------------------------------------------------
 239     # Function definitions
 240
 241     def extract_strings(fp_rel, node_container):
 242         """ Recursively get strings, needed incase we have "Blah" + "Blah",
 243             passed as an argument in that case it wont evaluate to a string.
 244         """
 245
 246         for node in ast.walk(node_container):
 247             if type(node) == ast.Str:
 248                 eval_str = ast.literal_eval(node)
 249                 if eval_str:
 250                     # print("%s:%d: %s" % (fp, node.lineno, eval_str))
 251                     msgsrc = "%s:%s" % (fp_rel, node.lineno)
 252                     messages.setdefault(eval_str, []).append(msgsrc)
 253
 254     def extract_strings_from_file(fp):
 255         filedata = open(fp, 'r', encoding="utf8")
 256         root_node = ast.parse(filedata.read(), fp, 'exec')
 257         filedata.close()
 258
 259         fp_rel = os.path.relpath(fp, SOURCE_DIR)
 260
 261         for node in ast.walk(root_node):
 262             if type(node) == ast.Call:
 263                 # print("found function at")
 264                 # print("%s:%d" % (fp, node.lineno))
 265
 266                 # lambda's
 267                 if type(node.func) == ast.Name:
 268                     continue
 269
 270                 # getattr(self, con.type)(context, box, con)
 271                 if not hasattr(node.func, "attr"):
 272                     continue
 273
 274                 translate_args = func_translate_args.get(node.func.attr, ())
 275
 276                 # do nothing if not found
 277                 for arg_kw, arg_pos in translate_args:
 278                     if arg_pos < len(node.args):
 279                         extract_strings(fp_rel, node.args[arg_pos])
 280                     else:
 281                         for kw in node.keywords:
 282                             if kw.arg == arg_kw:
 283                                 extract_strings(fp_rel, kw.value)
 284
 285     # -------------------------------------------------------------------------
 286     # Dump Messages
 287
 288     mod_dir = os.path.join(SOURCE_DIR,
 289                            "release",
 290                            "scripts",
 291                            "startup",
 292                            "bl_ui")
 293
 294     files = [os.path.join(mod_dir, fn)
 295              for fn in sorted(os.listdir(mod_dir))
 296              if not fn.startswith("_")
 297              if fn.endswith("py")
 298              ]
 299
 300     for fp in files:
 301         extract_strings_from_file(fp)
 302
 303
 304 def dump_messages():
 305
 306     def filter_message(msg):
 307
 308         # check for strings like ": %d"
 309         msg_test = msg
 310         for ignore in ("%d", "%s", "%r",  # string formatting
 311                        "*", ".", "(", ")", "-", "/", "\\", "+", ":", "#", "%"
 312                        "0", "1", "2", "3", "4", "5", "6", "7", "8", "9",
 313                        "x",  # used on its own eg: 100x200
 314                        "X", "Y", "Z",  # used alone. no need to include
 315                        ):
 316             msg_test = msg_test.replace(ignore, "")
 317         msg_test = msg_test.strip()
 318         if not msg_test:
 319             # print("Skipping: '%s'" % msg)
 320             return True
 321
 322         # we could filter out different strings here
 323
 324         return False
 325
 326     if 1:
 327         import collections
 328         messages = collections.OrderedDict()
 329     else:
 330         messages = {}
 331
 332     messages[""] = []
 333
 334     # get strings from RNA
 335     dump_messages_rna(messages)
 336
 337     # get strings from UI layout definitions text="..." args
 338     dump_messages_pytext(messages)
 339
 340     del messages[""]
 341
 342     message_file = open(FILE_NAME_MESSAGES, 'w', encoding="utf8")
 343     # message_file.writelines("\n".join(sorted(messages)))
 344
 345     for key, value in messages.items():
 346
 347         # filter out junk values
 348         if filter_message(key):
 349             continue
 350
 351         for msgsrc in value:
 352             message_file.write("%s%s\n" % (COMMENT_PREFIX, msgsrc))
 353         message_file.write("%s\n" % key)
 354
 355     message_file.close()
 356
 357     print("Written %d messages to: %r" % (len(messages), FILE_NAME_MESSAGES))
 358
 359
 360 def main():
 361
 362     try:
 363         import bpy
 364     except ImportError:
 365         print("This script must run from inside blender")
 366         return
 367
 368     dump_messages()
 369
 370
 371 if __name__ == "__main__":
 372     print("\n\n *** Running %r *** \n" % __file__)
 373     main()