def create_project_from_data(cls, project_data_path):
"""
Creates a new project using a project data JSON file
:param project_data_path: str, path where project JSON data file is located
:return: Project
"""
if project_data_path is None or not path.is_file(project_data_path):
LOGGER.warning('Project Data Path {} is not valid!'.format(project_data_path))
return None
project_data = settings.JSONSettings()
project_options = settings.JSONSettings()
project_dir = path.get_dirname(project_data_path)
project_name = path.get_basename(project_data_path)
project_data.set_directory(project_dir, project_name)
project_options.set_directory(project_dir, 'options.json')
project_name = project_data.get('name')
project_path = path.get_dirname(path.get_dirname(project_data_path))
project_image = project_data.get('image')
LOGGER.debug('New Project found [{}]: {}'.format(project_name, project_path))
project_data = core_project.ProjectData(
name=project_name, project_path=project_path, settings=project_data, options=project_options)
new_project = cls(project_data=project_data)
if project_image:
new_project.set_image(project_image)
return new_project
def update_project(self):
if not self._settings:
self._load_project()
project_file = self.get_project_file()
if not self._settings.has_settings():
logger.warning(
'No valid project data found on Project Data File: {}'.format(
project_file))
self._name = self._settings.get('name')
self._project_path = path.get_dirname(path.get_dirname(project_file))
def rename_folder(directory, name, make_unique=False):
"""
Renames given with a new name
:param directory: str, full path to the diretory we want to rename
:param name: str, new name of the folder we want to rename
:param make_unique: bool, Whether to add a number to the folder name to make it unique
:return: str, path of the renamed folder
"""
from tpDcc.libs.python import path
base_name = path.get_basename(directory=directory)
if base_name == name:
return
parent_path = path.get_dirname(directory=directory)
rename_path = path.join_path(parent_path, name)
if make_unique:
rename_path = path.unique_path_name(directory=rename_path)
if path.is_dir(rename_path) or path.is_file(rename_path):
return False
try:
os.chmod(directory, 0o777)
message = 'rename: {0} >> {1}'.format(directory, rename_path)
LOGGER.info(message)
os.rename(directory, rename_path)
except Exception:
LOGGER.error('{}'.format(traceback.format_exc()))
return False
return rename_path
def copy(source, target, description=''):
"""
Copies given file or files and creates a new version of the file with the given description
:param source: str, source file or folder we want to copy
:param target: str, destination file or folder we want to copy into
:param description: str, description of the new version
"""
is_source_a_file = path_utils.is_file(source)
if is_source_a_file:
copied_path = fileio.copy_file(source, target)
else:
if not path_utils.exists(source):
LOGGER.info(
'Nothing to copy: {}\t\tData was probably created but not saved yet.'
.format(path_utils.get_dirname(is_source_a_file)))
return
if path_utils.exists(target):
folder.delete_folder(target)
copied_path = folder.copy_folder(source, target)
if not copied_path:
LOGGER.warning('Error copying {}\t to\t{}'.format(source, target))
return
if copied_path > -1:
LOGGER.info('Finished copying {} from {} to {}'.format(
description, source, target))
version_file = version.VersionFile(copied_path)
version_file.save('Copied from {}'.format(source))
def create_file(filename, directory=None, make_unique=False):
"""
Creates a file
:param filename: str, name of the new file
:param directory: str, directory of the new file
:param make_unique: bool, whether to make the name unique or not
:return: variant, str || bool, filename with path or False if create file failed
"""
from tpDcc.libs.python import name, path, osplatform
if directory is None:
directory = path.get_dirname(filename)
filename = path.get_basename(filename)
filename = name.clean_file_string(filename)
full_path = path.join_path(directory, filename)
if make_unique:
full_path = path.unique_path_name(full_path)
open_file = None
try:
open_file = open(full_path, 'a')
open_file.close()
except Exception:
if open_file:
open_file.close()
return False
osplatform.get_permission(full_path)
return full_path
def create_item(self, name=None):
"""
Creates a new item (folder) inside the selected item
:param name: str, name of the new item
"""
current_item = self._current_item
if current_item:
item_path = self.get_tree_item_path_string(self._current_item)
item_path = path.join_path(self._directory, item_path)
if path.is_file(item_path):
item_path = path.get_dirname(item_path)
current_item = self._current_item.parent()
if not current_item:
item_path = self._directory
if not name:
name = self.NEW_ITEM_NAME
folder.create_folder(name=name, directory=item_path)
if current_item:
self._add_sub_items(current_item)
self.setItemExpanded(current_item, True)
else:
self.refresh()
def __init__(self, file_path):
self._file_path = file_path
self._path = path.get_dirname(file_path)
self._version_folder_name = '__version__'
self._version_folder = None
self._comment_file = None
self._updated_old = False
def delete(self):
"""
Removes data folder from disk
"""
folder_name = path_utils.get_basename(self.folder_path)
data_directory = path_utils.get_dirname(self.folder_path)
folder.delete_folder(folder_name, data_directory)
def _initialize_library(self, file_name=None):
if file_name:
directory = path_utils.get_dirname(file_name)
name = path_utils.get_basename(file_name)
else:
path = self.format_identifier()
directory = path_utils.get_dirname(path)
name = self.name()
library = ControlCVsLib()
library.set_directory(directory)
if file_name:
library.set_active_library(name, skip_extension=True)
else:
library.set_active_library(name)
return library
def _check_after_save(self, client_data, comment=None):
file_path = maya.cmds.file(query=True, sn=True)
version_file = version.VersionFile(file_path)
dir_path = path.get_dirname(file_path)
if version.VersionFile(dir_path).has_versions():
if not comment:
comment = 'Automatically versioned with Maya save'
version.save(comment)
helpers.display_info('New version saved!')
def _get_version_folder(self):
from tpDcc.libs.python import path
if path.is_file(self.file_path):
dir_name = path.get_dirname(self.file_path)
version_path = path.join_path(dir_name, self._version_folder_name)
else:
version_path = path.join_path(self.file_path, self._version_folder_name)
return version_path
def _get_version_folder(self):
if path.is_file(self._file_path):
version_dir = path.get_dirname(self._file_path)
version_path = path.join_path(version_dir,
self._version_folder_name)
else:
version_path = path.join_path(self._file_path,
self._version_folder_name)
return version_path
def get_scene_file(directory=False):
"""
Returns the scene file name or directory of the current scene
:param directory: bool, Whether to return scene name or scene path
:return: str
"""
scene_path = maya.cmds.file(q=True, sn=True)
if directory and scene_path:
scene_path = path_utils.get_dirname(scene_path)
return scene_path
def __init__(self, file_path):
from tpDcc.libs.python import path
self.file_path = file_path
if file_path:
self.filename = path.get_basename(directory=self.file_path)
self._path = path.get_dirname(file_path)
self._version_folder_name = '__version__'
self._version_name = 'version'
self._version_folder = None
self.comment_file = None
self.updated_old = False
def _has_json_file(self):
"""
Checks if the JSON file where settings should be stored exists or not
:return: bool
"""
if not self.file_path:
return False
settings_directory = path.get_dirname(self.file_path)
name = path.get_basename(self.file_path, with_extension=False)
file_path = path.join_path(settings_directory, name + '.json')
if path.is_file(file_path):
return True
return False
def _set_default_settings(self):
from tpDcc.libs.qt.core import image
project_file_path = self.get_project_file()
project_path = path.get_dirname(project_file_path)
self._settings = settings.JSONSettings()
self._set_settings_path(project_path)
self._settings.set('version', '0.0.0')
self._settings.set('name', self.name)
self._settings.set('path', self._project_path)
self._settings.set('full_path', self.full_path)
self._settings.set(
'image',
str(
image.image_to_base64(
resources.get('icons', 'default', 'tpdcc.png'))))
def check_path(self, warning_text=None):
"""
Check if a path to a file is invalid and raise error if necessary
:param warning_text: str
:return: bool
"""
from tpDcc.libs.python import path
dir_name = path.get_dirname(self.file_path)
if not path.is_dir(dir_name):
if warning_text is not None:
raise UserWarning(str(warning_text))
return False
return True
def _get_json_file(self):
"""
Internal function that returns JSON file where settings are stored
:return: str
"""
if not self.file_path:
return
settings_directory = path.get_dirname(self.file_path)
name = path.get_basename(self.file_path, with_extension=False)
file_path = fileio.create_file(name + '.json', settings_directory)
if not file_path:
test_path = path.join_path(settings_directory, name + '.json')
if path.is_file(test_path):
file_path = test_path
return file_path
def __init__(self, name, file_path, data_path=None):
super(LibraryDataFolder, self).__init__(file_path=file_path)
self.settings = None
new_path = path_utils.join_path(file_path, name)
self.file_path = path_utils.get_dirname(new_path)
self.name = path_utils.get_basename(new_path)
self.data_type = None
# if data_path:
# tp.data_manager.add_directory(data_path)
# Check if the given file path is a folder or not (and create folder if necessary)
test_path = path_utils.join_path(self.file_path, self.name)
is_folder = path_utils.is_dir(test_path)
if is_folder:
self.folder_path = test_path
else:
self._create_folder()
def clean_folder(directory):
"""
Removes everything in the given directory
:param directory: str
"""
from tpDcc.libs.python import path, fileio, folder
base_name = path.get_basename(directory=directory)
dir_name = path.get_dirname(directory=directory)
if path.is_dir(directory):
files = folder.get_files(directory)
for f in files:
fileio.delete_file(f, directory)
delete_folder(base_name, dir_name)
if not path.is_dir(directory):
create_folder(base_name, dir_name)
def delete_pyc_file(python_script):
"""
Deletes the .pyc file that corresponds to the given .py file
:param python_script: str
"""
from tpDcc.libs.python import path, fileio
script_name = path.get_basename(python_script)
if not python_script.endswith('.py'):
print('WARNING: Could not delete .pyc file for {}!'.format(script_name))
return
compile_script = python_script + 'c'
if path.is_file(compile_script):
compile_name = path.get_basename(compile_script)
compile_dir_name = path.get_dirname(compile_script)
if not compile_name.endswith('.pyc'):
return
fileio.delete_file(name=compile_name, directory=compile_dir_name)
def rename_folder(directory, name, make_unique=False):
"""
Renames given with a new name
:param directory: str, full path to the directory we want to rename
:param name: str, new name of the folder we want to rename
:param make_unique: bool, Whether to add a number to the folder name to make it unique
:return: str, path of the renamed folder
"""
from tpDcc.libs.python import path, osplatform
base_name = path.get_basename(directory=directory)
if base_name == name:
return
parent_path = path.get_dirname(directory=directory)
rename_path = path.join_path(parent_path, name)
if make_unique:
rename_path = path.unique_path_name(directory=rename_path)
if path.exists(rename_path):
return False
try:
osplatform.get_permission(directory)
message = 'rename: {0} >> {1}'.format(directory, rename_path)
logger.info(message)
os.rename(directory, rename_path)
except Exception:
time.sleep(0.1)
try:
os.rename(directory, rename_path)
except Exception:
logger.error('{}'.format(traceback.format_exc()))
return False
return rename_path
def delete_item(self):
"""
Deletes the selected item
"""
item = self._current_item
item_path = self.get_item_directory(item)
name = path.get_basename(item_path)
item_directory = path.get_dirname(item_path)
if path.is_dir(item_path):
folder.delete_folder(name, item_directory)
elif path.is_file(item_path):
fileio.delete_file(name, item_directory)
if item_path.endswith('.py'):
fileio.delete_file(name + '.c', item_directory)
parent = item.parent()
if parent:
parent.removeChild(item)
else:
index = self.indexOfTopLevelItem(item)
self.takeTopLevelItem(index)
