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 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 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 _set_settings_path(self, folder_path):
if not self._settings:
self._load_project()
project_file_path = self.get_project_file()
project_file = path.get_basename(project_file_path)
self._settings.set_directory(folder_path, project_file)
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 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 __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 _update_request(self):
if not self._has_changed():
return
last_modified = fileio.get_last_modified_date(self._file_path)
self._skip_focus = True
permission = qtutils.get_permission(
'File:\n{}\nhas changed, do you want to relaod it?'.format(
path_utils.get_basename(self._file_path)), self)
if permission:
self.set_file(self._file_path)
else:
self._last_modified = last_modified
self._skip_focus = 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 _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 _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 rename(self, new_name):
"""
Rename this data folder
:param new_name: str
:return: str, new folder name
"""
base_name = path_utils.get_basename(new_name)
data_inst = self.get_folder_data_instance()
data_inst.rename(base_name)
renamed_folder = folder.rename_folder(self.folder_path, new_name)
if not renamed_folder:
return
self.folder_path = renamed_folder
self._set_settings_path(renamed_folder)
self._set_name(base_name)
return self.folder_path
def copy_file(file_path, file_path_destination):
"""
Copies the given file to a new given directory
:param file_path: str, file to copy with full path
:param file_path_destination: str, destination directory where we want to copy the file into
:return: str, the new copied path
"""
from tpDcc.libs.python import path, osplatform
osplatform.get_permission(file_path)
if path.is_file(file_path):
if path.is_dir(file_path_destination):
file_name = path.get_basename(file_path)
file_path_destination = path.join_path(file_path_destination,
file_name)
shutil.copy2(file_path, file_path_destination)
return file_path_destination
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 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)
def get_folder_size(directory, round_value=2, skip_names=None):
"""
Returns the size of the given folder
:param directory: str
:param round_value: int, value to round size to
:return: str
"""
from tpDcc.libs.python import python, path, fileio
skip_names = python.force_list(skip_names)
size = 0
for root, dirs, files in os.walk(directory):
root_name = path.get_basename(root)
if root_name in skip_names:
continue
for name in files:
if name in skip_names:
continue
size += fileio.get_file_size(path.join_path(root, name), round_value)
return size
def file_name(self):
if not self._file_path:
return ''
return path.get_basename(self._file_path)
