def __init__(self, dev=True, parent=None): super(RenameWidget, self).__init__(title='Rename', parent=parent) names_config = configs.get_config( config_name='tpRigToolkit-names', environment='development' if dev else 'production') naming_config = configs.get_config( config_name='tpRigToolkit-naming', environment='development' if dev else 'production') rename_widget = RenameToolset(names_config=names_config, naming_config=naming_config, parent=self) self.main_layout.addWidget(rename_widget)
def preffix_suffix_widget(client, naming_config=None, parent=None): if not naming_config: naming_config = configs.get_config(config_name='tpDcc-naming') model = PrefixSuffixWidgetModel(config=naming_config) controller = PrefixSuffixWidgetController(client=client, model=model) view = PrefixSuffixView(model=model, controller=controller, parent=parent) return view
def __init__(self, *args, **kwargs): self._names_config = kwargs.get('names_config', None) self._naming_config = kwargs.get('naming_config', None) self._naming_lib = kwargs.get('naming_lib', None) self._dev = kwargs.get('dev', False) if not self._names_config: self._names_config = configs.get_config( config_name='tpDcc-naming', environment='development' if self._dev else 'production') if not self._naming_config: self._naming_config = configs.get_config( config_name='tpDcc-naming', environment='development' if self._dev else 'production') super(RenamerToolsetWidget, self).__init__(*args, **kwargs)
def get_config(cls, config_id=None): """ Returns tool config :return: """ return configs.get_config(config_id or cls.ID, cls.PACKAGE, extra_data=cls.config_dict())
def suffixes(self): if not self._config: return suffixes = self._config.get('suffixes', default=list()) if not suffixes: naming_config = configs.get_config('tpDcc-naming') if naming_config: suffixes = naming_config.get('suffixes', default=dict()) return suffixes
def init_lib(naming_file=None, dev=True, cache=True): global _NAME_LIB global _NAMING_FILE if _NAME_LIB and naming_file and _NAMING_FILE == naming_file and cache: return _NAME_LIB environment = 'development' if dev else 'production' config = configs.get_config('tpRigToolkit-names', environment=environment) _NAMING_FILE = naming_file or config.get_path() _NAME_LIB = namelib.NameLib(naming_file=_NAMING_FILE) return _NAME_LIB
def show_plugin(self): super(RenamerPlugin, self).show_plugin() # TODO: This should be defined dev = False names_config = configs.get_config( config_name='tpRigToolkit-names', environment='development' if dev else 'production') naming_config = configs.get_config( config_name='tpRigToolkit-naming', environment='development' if dev else 'production') self._renamer_widget = renamer.RenamerToolsetWidget( names_config=names_config, naming_config=naming_config, parent=self) self._renamer_widget.initialize() self._renamer_widget.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding) self._content_layout.addWidget(self._renamer_widget)
def init(import_libs=True): """ Initializes tpRigToolkit module :param import_libs: bool, Whether to import deps libraries by default or not """ logger = create_logger() if import_libs: dcc_loader.init() dcc_loader_module = core_dcc.get_dcc_loader_module('tpRigToolkit.dccs') if dcc_loader_module: dcc_loader_module.init() register_resources() # Register configuration files dev = strings.to_boolean(os.getenv('TPRIGTOOLKIT_DEV', 'False')) configs.register_package_configs(PACKAGE, os.path.dirname(tpRigToolkit.config.__file__)) core_config = configs.get_config('tpRigToolkit-core', environment='development' if dev else 'production') if not core_config: logger.warning( 'tpRigToolkit-core configuration file not found! ' 'Make sure that you have tpRigToolkit-config package installed!') return None libs_to_load = core_config.get('libs', list()) tools_to_load = core_config.get('tools', list()) with contexts.Timer('Libraries loaded', logger=logger): libs.LibsManager().register_package_libs(PACKAGE, libs_to_register=libs_to_load) with contexts.Timer('Tools loaded', logger=logger): tools.ToolsManager().register_package_tools(PACKAGE, tools_to_register=tools_to_load) tools_paths = tools.ToolsManager().paths(PACKAGE) with contexts.Timer('Toolsets loaded', logger=logger): qt_toolsets.ToolsetsManager().register_package_toolsets( PACKAGE, os.path.dirname(os.path.abspath(tpRigToolkit.toolsets.__file__)), tools_paths) with contexts.Timer('Menu created', logger=logger): main_menu = menus.create_main_menu( package_name=PACKAGE, force_creation=True, icon=resources.icon('tpRigToolkit')) if main_menu: hub_action = QAction(resources.icon('tpRigToolkit'), 'Hub', main_menu) main_menu.addAction(hub_action) hub_action.triggered.connect(run_hub) menus.create_menus(package_name=PACKAGE, dev=dev, force_main_menu_creation=False)
def init(dev=False): """ Initializes module :param dev: bool, Whether tpDcc-core is initialized in dev mode or not """ if dev: os.environ['TPDCC_DEV'] = str(dev) logger = create_logger(dev=dev) # Get DCC loader module dcc_loader_module = core_dcc.get_dcc_loader_module() logger.info('DCC loader module found: "{}"'.format(dcc_loader_module)) if dcc_loader_module: dcc_loader_module.init_dcc() # After that, we initialize Qt library (we must do it after tpDcc one because tpDcc-libs-qt depends on tpDcc-core) # NOTE: DCC UI modules are automatically loaded by tpDcc-libs-qt qt_loader.init(dev=dev) configs.register_package_configs(PACKAGE, os.path.dirname(tpDcc.config.__file__)) core_config = configs.get_config( 'tpDcc-core', environment='development' if dev else 'production') if not core_config: logger.warning( 'tpDcc-core configuration file not found! Make sure that you have tpDcc-config package installed!' ) return None libs_to_load = core_config.get('libs', list()) tools_to_load = core_config.get('tools', list()) with contexts.Timer('Libraries loaded', logger=logger): libs.LibsManager().register_package_libs(PACKAGE, libs_to_register=libs_to_load, dev=dev) libs.LibsManager().load_registered_libs(PACKAGE) with contexts.Timer('Tools loaded', logger=logger): tools.ToolsManager().register_package_tools( PACKAGE, tools_to_register=tools_to_load, dev=dev) tools.ToolsManager().load_registered_tools(PACKAGE) with contexts.Timer('Toolsets loaded', logger=logger): toolsets.ToolsetsManager().register_path( PACKAGE, os.path.dirname(toolsets.__file__)) toolsets.ToolsetsManager().load_registered_toolsets( PACKAGE, tools_to_load=tools_to_load)
def get_auto_suffixes(dev=True): """ Returns dictionary containing suffixes that can be used to handle nomenclature :return: """ environment = 'development' if dev else 'production' naming_config = configs.get_config(config_name='tpRigToolkit-naming', environment=environment) if not naming_config: return dict() auto_suffixes_dict = naming_config.get('auto_suffixes', default=dict()) if not auto_suffixes_dict: return dict() return auto_suffixes_dict
def __init__(self, config=None, names_config=None, naming_config=None): super(RenamerModel, self).__init__() self._config = config if config else tools.ToolsManager( ).get_tool_config('tpDcc-tools-renamer') self._names_config = names_config if names_config else configs.get_config( config_name='tpDcc-naming') self._naming_config = naming_config self._selection_type = 0 self._hierarchy_check = False self._rename_shape = True self._filter_type = '' self._rules = list() self._active_rule = None self._tokens = list() self._unique_id_auto = True self._last_joint_end_auto = True
def load_plugin(self, pkg_name, pkg_loaders, environment, root_pkg_name=None, config_dict=None, load=True): """ Implements load_plugin function Registers a plugin instance to the manager :param pkg_name: str :param pkg_loaders: plugin instance to register :param environment: :param root_pkg_name: :param config_dict: :param load: :return: Plugin """ from tpDcc.managers import configs if not pkg_loaders: return False package_loader = pkg_loaders[0] if isinstance(pkg_loaders, (list, tuple)) else pkg_loaders if not package_loader: return False if hasattr(package_loader, 'loader'): if not package_loader.loader: return False plugin_path = package_loader.filename if python.is_python2( ) else os.path.dirname(package_loader.loader.path) plugin_name = package_loader.fullname if python.is_python2( ) else package_loader.loader.name if not config_dict: config_dict = dict() config_dict.update({ 'join': os.path.join, 'user': os.path.expanduser('~'), 'filename': plugin_path, 'fullname': plugin_name, 'root': path_utils.clean_path(plugin_path) }) if pkg_name not in self._plugins: self._plugins[pkg_name] = dict() libs_found = list() version_found = None init_fn = None mods_found = list() # packages_to_walk = [plugin_path] if python.is_python2() else [os.path.dirname(plugin_path)] for module_path in modules.iterate_modules(plugin_path, skip_inits=False, recursive=False): module_dot_path = modules.convert_to_dotted_path(module_path) try: mod = modules.import_module(module_dot_path) if not mod: continue except Exception: continue if module_dot_path.endswith('__version__') and hasattr( mod, 'get_version') and callable(mod.get_version): if version_found: LOGGER.warning( 'Already found version: "{}" for "{}"'.format( version_found, plugin_name)) else: version_found = getattr(mod, 'get_version')() if not init_fn and module_dot_path.endswith('loader') and hasattr( mod, 'init') and callable(mod.init): init_fn = mod.init mod.LOADED = load mods_found.append(mod) for mod in mods_found: for cname, obj in inspect.getmembers(mod, inspect.isclass): for interface in self._interfaces: if issubclass(obj, interface): lib_config_dict = obj.config_dict( file_name=plugin_path) or dict() if not lib_config_dict: continue lib_id = lib_config_dict.get('id', None) tool_config_name = lib_config_dict.get('name', None) if not lib_id: LOGGER.warning( 'Impossible to register library "{}" because its ID is not defined!' .format(lib_id)) continue if not tool_config_name: LOGGER.warning( 'Impossible to register library "{}" because its name is not defined!' .format(tool_config_name)) continue if root_pkg_name and root_pkg_name in self._plugins and lib_id in self._plugins[ root_pkg_name]: LOGGER.warning( 'Impossible to register library "{}" because its ID "{}" its already defined!' .format(tool_config_name, lib_id)) continue if not version_found: version_found = '0.0.0' obj.VERSION = version_found obj.FILE_NAME = plugin_path obj.FULL_NAME = plugin_name libs_found.append((module_path, version_found, obj)) version_found = True break if not libs_found: LOGGER.warning( 'No libraries found in module "{}". Skipping ...'.format( plugin_path)) return False if len(libs_found) > 1: LOGGER.warning( 'Multiple libraries found ({}) in module "{}". Loading first one. {} ...' .format(len(libs_found), plugin_path, libs_found[-1])) lib_found = libs_found[-1] else: lib_found = libs_found[0] lib_loader = modules.convert_to_dotted_path(lib_found[0]) lib_loader = loader.find_loader(lib_loader) # Check if DCC specific implementation for plugin exists dcc_path = '{}.dccs.{}'.format(plugin_name, dcc.get_name()) dcc_loader = None dcc_config = None try: dcc_loader = loader.find_loader(dcc_path) except ImportError: pass lib_config_dict = lib_found[2].config_dict( file_name=plugin_path) or dict() lib_id = lib_config_dict['id'] _tool_name = lib_config_dict['name'] tool_config_name = plugin_name.replace('.', '-') lib_config = configs.get_config(config_name=tool_config_name, package_name=pkg_name, root_package_name=root_pkg_name, environment=environment, config_dict=config_dict, extra_data=lib_config_dict) if dcc_loader: dcc_path = dcc_loader.fullname dcc_config = configs.get_config(config_name=dcc_path.replace( '.', '-'), package_name=pkg_name, environment=environment, config_dict=config_dict) if not dcc_config.get_path(): dcc_config = None # Register resources def_resources_path = os.path.join(plugin_path, 'resources') # resources_path = plugin_config.data.get('resources_path', def_resources_path) resources_path = lib_config_dict.get('resources_path', None) if not resources_path or not os.path.isdir(resources_path): resources_path = def_resources_path if os.path.isdir(resources_path): resources.register_resource(resources_path, key='tools') else: pass # tp.logger.debug('No resources directory found for plugin "{}" ...'.format(_plugin_name)) # Register DCC specific resources if dcc_loader and dcc_config: def_resources_path = os.path.join(dcc_loader.filename, 'resources') resources_path = dcc_config.data.get('resources_path', def_resources_path) if not resources_path or not os.path.isdir(resources_path): resources_path = def_resources_path if os.path.isdir(resources_path): resources.register_resource(resources_path, key='plugins') else: pass # tp.logger.debug('No resources directory found for plugin "{}" ...'.format(_plugin_name)) # Create lib loggers directory default_logger_dir = os.path.normpath( os.path.join(os.path.expanduser('~'), 'tpDcc', 'logs', 'libs')) default_logging_config = os.path.join(plugin_path, '__logging__.ini') logger_dir = lib_config_dict.get('logger_dir', default_logger_dir) if not os.path.isdir(logger_dir): os.makedirs(logger_dir) logging_file = lib_config_dict.get('logging_file', default_logging_config) lib_package = plugin_name lib_package_path = plugin_path dcc_package = None dcc_package_path = None if dcc_loader: dcc_package = dcc_loader.fullname if python.is_python2( ) else dcc_loader.loader.path dcc_package_path = dcc_loader.filename if python.is_python2( ) else dcc_loader.loader.name self._plugins[pkg_name][lib_id] = { 'name': _tool_name, 'package_name': pkg_name, 'loader': package_loader, 'config': lib_config, 'config_dict': lib_config_dict, 'plugin_loader': lib_loader, 'plugin_package': lib_package, 'plugin_package_path': lib_package_path, 'version': lib_found[1] if lib_found[1] is not None else "0.0.0", 'dcc_loader': dcc_loader, 'dcc_package': dcc_package, 'dcc_package_path': dcc_package_path, 'dcc_config': dcc_config, 'logging_file': logging_file, 'plugin_instance': None } if init_fn: try: dev = True if environment == 'development' else False init_fn(dev=dev) LOGGER.info( 'Library "{}" registered and initialized successfully!'. format(plugin_name)) except Exception: LOGGER.warning( 'Library "{}" registered successfully but its initialization failed: {}' .format(plugin_name, traceback.format_exc())) else: LOGGER.info( 'Library "{}" registered successfully!'.format(plugin_name)) return True
def load_plugin(self, pkg_name, pkg_loaders, environment, root_pkg_name=None, config_dict=None, load=True): """ Implements load_plugin function Registers a plugin instance to the manager :param pkg_name: str :param pkg_loaders: plugin instance to register :param environment: :param root_pkg_name: :param config_dict: :param load: :return: Plugin """ if not pkg_loaders: return False package_loader = pkg_loaders[0] if isinstance(pkg_loaders, (list, tuple)) else pkg_loaders if not package_loader: return False if hasattr(package_loader, 'loader'): if not package_loader.loader: return False plugin_path = package_loader.filename if python.is_python2( ) else os.path.dirname(package_loader.loader.path) plugin_name = package_loader.fullname if python.is_python2( ) else package_loader.loader.name if not config_dict: config_dict = dict() local = os.getenv('APPDATA') or os.getenv('HOME') config_dict.update({ 'join': os.path.join, 'user': os.path.expanduser('~'), 'filename': plugin_path, 'fullname': plugin_name, 'root': path_utils.clean_path(plugin_path), 'local': local, 'home': local }) if pkg_name not in self._plugins: self._plugins[pkg_name] = dict() tools_found = list() version_found = None packages_to_walk = [plugin_path] if python.is_python2() else [ os.path.dirname(plugin_path) ] for sub_module in pkgutil.walk_packages(packages_to_walk): importer, sub_module_name, _ = sub_module qname = '{}.{}'.format(plugin_name, sub_module_name) try: mod = importer.find_module(sub_module_name).load_module( sub_module_name) except Exception: # LOGGER.exception('Impossible to register plugin: "{}"'.format(plugin_path)) continue if qname.endswith('__version__') and hasattr(mod, '__version__'): if version_found: LOGGER.warning( 'Already found version: "{}" for "{}"'.format( version_found, plugin_name)) else: version_found = getattr(mod, '__version__') mod.LOADED = load for cname, obj in inspect.getmembers(mod, inspect.isclass): for interface in self._interfaces: if issubclass(obj, interface): tool_config_dict = obj.config_dict( file_name=plugin_path) or dict() if not tool_config_dict: continue tool_id = tool_config_dict.get('id', None) tool_config_name = tool_config_dict.get('name', None) # tool_icon = tool_config_dict.get('icon', None) if not tool_id: LOGGER.warning( 'Impossible to register tool "{}" because its ID is not defined!' .format(tool_id)) continue if not tool_config_name: LOGGER.warning( 'Impossible to register tool "{}" because its name is not defined!' .format(tool_config_name)) continue if root_pkg_name and root_pkg_name in self._plugins and tool_id in self._plugins[ root_pkg_name]: LOGGER.warning( 'Impossible to register tool "{}" because its ID "{}" its already defined!' .format(tool_config_name, tool_id)) continue if not version_found: version_found = '0.0.0' obj.VERSION = version_found obj.FILE_NAME = plugin_path obj.FULL_NAME = plugin_name tools_found.append((qname, version_found, obj)) version_found = True break if not tools_found: LOGGER.warning( 'No tools found in module "{}". Skipping ...'.format( plugin_path)) return False if len(tools_found) > 1: LOGGER.warning( 'Multiple tools found ({}) in module "{}". Loading first one. {} ...' .format(len(tools_found), plugin_path, tools_found[-1])) tool_found = tools_found[-1] else: tool_found = tools_found[0] tool_loader = loader.find_loader(tool_found[0]) # Check if DCC specific implementation for plugin exists dcc_path = '{}.dccs.{}'.format(plugin_name, dcc.get_name()) dcc_loader = None dcc_config = None try: dcc_loader = loader.find_loader(dcc_path) except ImportError: pass tool_config_dict = tool_found[2].config_dict( file_name=plugin_path) or dict() tool_id = tool_config_dict['id'] _tool_name = tool_config_dict['name'] tool_icon = tool_config_dict['icon'] tool_config_name = plugin_name.replace('.', '-') tool_config = configs.get_config(config_name=tool_config_name, package_name=pkg_name, root_package_name=root_pkg_name, environment=environment, config_dict=config_dict, extra_data=tool_config_dict) if dcc_loader: dcc_path = dcc_loader.fullname dcc_config = configs.get_config(config_name=dcc_path.replace( '.', '-'), package_name=pkg_name, environment=environment, config_dict=config_dict) if not dcc_config.get_path(): dcc_config = None # Register resources def_resources_path = os.path.join(plugin_path, 'resources') # resources_path = plugin_config.data.get('resources_path', def_resources_path) resources_path = tool_config_dict.get('resources_path', None) if not resources_path or not os.path.isdir(resources_path): resources_path = def_resources_path if os.path.isdir(resources_path): resources.register_resource(resources_path, key='tools') else: pass # tp.logger.debug('No resources directory found for plugin "{}" ...'.format(_plugin_name)) # Register DCC specific resources if dcc_loader and dcc_config: def_resources_path = os.path.join(dcc_loader.filename, 'resources') resources_path = dcc_config.data.get('resources_path', def_resources_path) if not resources_path or not os.path.isdir(resources_path): resources_path = def_resources_path if os.path.isdir(resources_path): resources.register_resource(resources_path, key='plugins') else: pass # tp.logger.debug('No resources directory found for plugin "{}" ...'.format(_plugin_name)) # Create tool loggers directory default_logger_dir = os.path.normpath( os.path.join(os.path.expanduser('~'), 'tpDcc', 'logs', 'tools')) default_logging_config = os.path.join(plugin_path, '__logging__.ini') logger_dir = tool_config_dict.get('logger_dir', default_logger_dir) if not os.path.isdir(logger_dir): os.makedirs(logger_dir) logging_file = tool_config_dict.get('logging_file', default_logging_config) tool_package = plugin_name tool_package_path = plugin_path dcc_package = None dcc_package_path = None if dcc_loader: dcc_package = dcc_loader.fullname if python.is_python2( ) else dcc_loader.loader.path dcc_package_path = dcc_loader.filename if python.is_python2( ) else dcc_loader.loader.name self._plugins[pkg_name][tool_id] = { 'name': _tool_name, 'icon': tool_icon, 'package_name': pkg_name, 'loader': package_loader, 'config': tool_config, 'config_dict': tool_config_dict, 'plugin_loader': tool_loader, 'plugin_package': tool_package, 'plugin_package_path': tool_package_path, 'version': tool_found[1] if tool_found[1] is not None else "0.0.0", 'dcc_loader': dcc_loader, 'dcc_package': dcc_package, 'dcc_package_path': dcc_package_path, 'dcc_config': dcc_config, 'logging_file': logging_file, 'plugin_instance': None } LOGGER.info('Tool "{}" registered successfully!'.format(plugin_name)) return True