class NewSequence(Action):
'''Create a new Sequence'''
label = 'New Sequence'
identifier = 'new.sequence'
returns = artifact('sequence')
@staticmethod
def parameters(ctx):
params = dict(project={
'label': 'Project',
'help': 'Project Entry',
'required': True,
'type': types.Entry,
},
collection={
'label': 'Collection',
'help': 'Collection Name',
'required': True,
'type': types.String
},
name={
'label': 'Sequence Name',
'required': True,
'type': types.String,
'help': 'Name of sequence',
},
template={
'label': 'Sequence Template',
'required': False,
'type': types.String,
'help': 'Name of sequence template'
})
if not ctx:
return params
if ctx.project:
params['project']['default'] = ctx.project
params['project']['required'] = False
# TODO: fix search speed upstream...
# collection_types = [e.name for e in ctx.project.collections]
# params['collection']['options'] = collection_types
if ctx.collection:
params['collection']['default'] = ctx.collection.name
params['collection']['required'] = False
templates = list(api.get_templates('sequence').keys())
if templates:
params['template']['default'] = templates[0]
params['template']['options'] = templates
return params
@staticmethod
def available(ctx):
return (ctx.project and ctx.collection and not ctx.sequence
and not ctx.asset_type)
class NewProject(Action):
'''Create a new Project'''
label = 'New Project'
identifier = 'new.project'
returns = artifact('project')
@classmethod
def parameters(cls, ctx):
params = dict(root={
'label': 'Project Root',
'required': True,
'type': types.String,
'help': 'project root directory',
},
template={
'label': 'Project Template',
'required': True,
'type': types.String,
'help': 'name of a project template',
})
if not ctx:
return params
templates = list(api.get_templates('project').keys())
params['template']['options'] = templates
if templates:
params['template']['default'] = templates[0]
return params
@staticmethod
def available(ctx):
return not ctx.project
class SetWorkspace(Action):
'''Set the current workspace'''
label = 'Set Workspace'
identifier = 'set_workspace'
returns = artifact('workspace')
@staticmethod
def parameters(ctx):
params = dict(
task={
'label': 'Parent Entry',
'required': True,
'type': types.Entry,
'help': 'Parent entry of workspace',
},
name={
'label': 'Workspace Name',
'required': True,
'type': types.String,
'help': 'Name of workspace'
},
template={
'label': 'Workspace template Name',
'required': True,
'type': types.String,
'help': 'Name of template to use if the task has no workspace'
})
if not ctx:
return params
if ctx.task:
params['task']['default'] = ctx.task
params['task']['required'] = False
# Get default workspace for this host
host = api.get_host()
params['name']['default'] = host.name
default_workspace = host.name
for name, data in api.config['SOFTWARE'].items():
if data['host'] == host.name:
default_workspace = data['default_workspace']
break
template = api.get_template(default_workspace, 'workspace')
if template:
params['template']['default'] = template.name
templates = api.get_templates('workspace')
if templates:
params['template']['options'] = list(templates.keys())
return params
@staticmethod
def available(ctx):
return ctx.host != 'cli' and ctx.project
class NewTask(Action):
'''Create a new Task'''
label = 'New Task'
identifier = 'new.task'
returns = artifact('task')
@staticmethod
def parameters(ctx):
params = dict(parent={
'label': 'Parent Entry',
'required': True,
'type': types.Entry,
'help': 'Parent entry of task',
},
type={
'label': 'Task Type',
'required': True,
'type': types.String,
'help': 'Type of task',
},
name={
'label': 'Task Name',
'required': False,
'type': types.String,
'help': 'Name of task'
},
template={
'label': 'Task Template Name',
'required': False,
'type': types.String,
'help': 'Name of task template'
})
if not ctx:
return params
params['type']['options'] = list(config['TASK_TYPES'].keys())
if ctx.shot:
params['parent']['default'] = ctx.shot
params['parent']['required'] = False
elif ctx.asset:
params['parent']['default'] = ctx.asset
params['parent']['required'] = False
templates = list(api.get_templates('task').keys())
if templates:
params['template']['options'] = templates
params['template']['default'] = templates[0]
return params
@staticmethod
def available(ctx):
return (ctx.project and (ctx.shot or ctx.asset) and not ctx.task)
class Publish(Action):
'''Publish the current open file'''
label = 'Publish'
identifier = 'publish'
returns = artifact('file')
@staticmethod
def parameters(ctx):
return {}
@staticmethod
def available(ctx):
return ctx.host != 'cli' and ctx.task and ctx.file
class NewCollection(Action):
'''Create a new Collection'''
label = 'New Collection'
identifier = 'new.collection'
returns = artifact('collection')
@staticmethod
def parameters(ctx):
params = dict(
project={
'label': 'Project',
'help': 'Project Entry',
'required': True,
'type': types.Entry,
},
name={
'label': 'Collection Name',
'required': True,
'type': types.String,
'help': 'Name of Collection',
},
template={
'label': 'Collection Template',
'require': False,
'type': types.String,
'help': 'Name of template',
},
)
if not ctx:
return params
if ctx.project:
params['project']['default'] = ctx.project
params['project']['required'] = False
templates = list(api.get_templates('collection').keys())
if templates:
params['template']['options'] = templates
params['template']['default'] = templates[0]
return params
@staticmethod
def available(ctx):
return (ctx.project and not ctx.collection)
class NewAssetType(Action):
'''Create a new Asset Type'''
label = 'New Asset Type'
identifier = 'new.asset_type'
returns = artifact('asset_type')
@staticmethod
def parameters(ctx):
params = dict(
project={
'label': 'Project',
'help': 'Project Entry',
'required': True,
'type': types.Entry,
},
collection={
'label': 'Collection',
'help': 'Collection Name',
'required': True,
'type': types.String
},
name={
'label': 'Asset Type Name',
'required': True,
'type': types.String,
'help': 'Name of Asset Type',
},
)
if not ctx:
return params
if ctx.project:
params['project']['default'] = ctx.project
params['project']['required'] = False
if ctx.collection:
params['collection']['default'] = ctx.collection.name
params['collection']['required'] = False
return params
@staticmethod
def available(ctx):
return (ctx.project and ctx.collection and not ctx.asset_type
and not ctx.sequence)
class NewWorkspace(Action):
'''Create a new Workspace'''
label = 'New Workspace'
identifier = 'new.workspace'
returns = artifact('workspace')
@staticmethod
def parameters(ctx):
params = dict(task={
'label': 'Parent Entry',
'required': True,
'type': types.Entry,
'help': 'Parent entry of workspace',
},
name={
'label': 'Workspace Name',
'required': True,
'type': types.String,
'help': 'Name of workspace'
},
template={
'label': 'Workspace Template Name',
'required': True,
'type': types.String,
'help': 'Name of workspace template'
})
if not ctx:
return params
if ctx.task:
params['task']['default'] = ctx.task
params['task']['required'] = False
templates = api.get_templates('workspace')
if templates:
params['template']['options'] = list(templates.keys())
return params
@staticmethod
def available(ctx):
return (ctx.project and (ctx.shot or ctx.asset) and ctx.task
and not ctx.workspace)
class NewTemplate(Action):
'''Create a new Template from an Entry'''
label = 'New Template'
identifier = 'new.template'
returns = artifact('template')
@staticmethod
def parameters(ctx):
params = dict(name={
'label': 'Template Name',
'required': True,
'type': types.String,
'help': 'Name of new template',
},
entry={
'label': 'Entry',
'required': True,
'type': types.Entry,
'help': 'Entry to create template from',
},
include_files={
'label': 'Include Files',
'type': bool,
'default': False,
'help':
'Include all files in entry not just entry data',
})
if not ctx:
return params
if ctx.host == 'cli':
params['entry']['default'] = ctx.get_deepest_entry()
return params
@staticmethod
def available(ctx):
return False
template=template,
)
@task(priority=types.VALIDATE)
@requires(success('stage_shot'))
@params(store('shot_item'))
def validate_shot(shot_item):
'''Make sure shot does not exist'''
if os.path.exists(shot_item['path']):
raise Abort('Shot already exists: ' + shot_item['name'])
return True
@task(priority=types.COMMIT)
@requires(success('validate_shot'))
@params(store('shot_item'))
@returns(artifact('shot'))
def commit_shot(shot_item):
'''Create new shot'''
if shot_item['template']:
shot = shot_item['template'].copy(shot_item['path'])
else:
shot = fsfs.get_entry(shot_item['path'])
shot.tag(*shot_item['tags'])
return shot
template=api.get_template(template, 'task'),
)
@task(priority=types.VALIDATE)
@requires(success('stage_task'))
@params(store('task_item'))
def validate_task(task_item):
'''Validate potential task'''
if os.path.exists(task_item['path']):
raise Abort('Task already exists: ' + task_item['name'])
return True
@task(priority=types.COMMIT)
@requires(success('validate_task'))
@params(store('task_item'))
@returns(artifact('task'))
def commit_task(task_item):
'''Create new task'''
if task_item['template']:
task = task_item['template'].copy(task_item['path'])
else:
task = fsfs.get_entry(task_item['path'])
task.tag(*task_item['tags'])
return task
template_item = types.Namespace(
entry=entry,
name=name,
path=template_path,
include_files=include_files,
)
return template_item
@task(priority=types.VALIDATE)
@requires(success('stage_template_data'))
@params(store('template'))
def validate_template(template):
'''Make sure template does not already exist'''
if (os.path.exists(template.path)
or template.name in construct.get_templates()):
raise Abort('Template already exists: ' + template.name)
@task(priority=types.COMMIT)
@requires(success('validate_template'))
@params(store('template'))
@returns(artifact('template'))
def commit_template(template):
'''Commit template'''
new_template = entry.copy(template_path, only_data=not include_files)
return new_template
@task(priority=types.VALIDATE)
@requires(success('stage_workspace'))
@params(store('workspace_item'))
def validate_workspace(workspace_item):
'''Validate potential workspace'''
if os.path.exists(workspace_item['path']):
raise Abort('Task already exists: ' + workspace_item['name'])
return True
@task(priority=types.COMMIT)
@requires(success('validate_workspace'))
@params(store('workspace_item'))
@returns(artifact('workspace'))
def commit_workspace(workspace_item):
'''Create new workspace'''
if workspace_item['template']:
workspace = workspace_item['template'].copy(workspace_item['path'])
else:
workspace = fsfs.get_entry(workspace_item['path'])
workspace.tag(*workspace_item['tags'])
return workspace
class SetWorkspace(Action):
'''Set the current workspace'''
)
@task(priority=types.VALIDATE)
@requires(success('stage_collection'))
@params(store('collection_item'))
def validate_collection(collection_item):
'''Make sure new collection does not exist'''
if os.path.exists(collection_item['path']):
raise Abort('collection already exists: ' + collection_item['name'])
return True
@task(priority=types.COMMIT)
@requires(success('validate_collection'))
@params(store('collection_item'))
@returns(artifact('collection'))
def commit_collection(collection_item):
'''Make new collection'''
if collection_item['template']:
collection = collection_item['template'].copy(collection_item['path'])
else:
collection = fsfs.get_entry(collection_item['path'])
collection.tag(*collection_item['tags'])
return collection
@pass_kwargs
@pass_context
@returns(store('frame_range'))
def get_frame_range(ctx, asset_or_shot):
'''Get the Asset or Shot frame range'''
frame_range = asset_or_shot.data.get(
'frame_range', ctx.project.data.get('frame_range',
[101, 101, 580, 580]))
return frame_range
@task
@requires(store('frame_range'))
@params(store('frame_range'))
@returns(artifact('frame_range'))
def apply_frame_range(frame_range):
'''Applies the frame range to your current scene'''
host = get_host()
host.set_frame_range(*frame_range)
return {'frame_range': frame_range}
class SaveFPS(Action):
'''Save the frame rate for this shot or asset'''
label = 'Save FPS'
identifier = 'time.savefps'
@staticmethod
@task
@params(kwarg('modules'))
@returns(store('cpenv_modules'))
def validate_cpenv_modules(modules):
'''Validate cpenv modules'''
import cpenv
modules = modules.split()
return cpenv.resolve(modules)
@task
@requires(success('validate_cpenv_modules'))
@params(kwarg('root'), store('cpenv_modules'))
@returns(artifact('cpenv_file'))
def write_cpenv_modules(root, modules):
'''Write a cpenv file to root'''
resolver_str = ' '.join([m.qual_name for m in modules])
cpenv_file = os.path.join(root.path, '.cpenv').replace('\\', '/')
with open(cpenv_file, 'w') as f:
f.write(resolver_str)
return cpenv_file
@task
@params(kwarg('root'))
@returns(store('cpenv_modules'))
def get_cpenv(root):
'''Resolve cpenv modules for the given path'''
class Save(Action):
'''Save the current file'''
label = 'Save'
identifier = 'file.save'
returns = artifact('file')
@staticmethod
def parameters(ctx):
params = dict(
workspace={
'label': 'Workspace',
'required': False,
'type': types.Entry,
'help': 'Workspace to save to',
},
name={
'label': 'Name',
'required': False,
'type': types.String,
'help': 'Filename',
},
version={
'label': 'Version',
'required': True,
'type': types.Integer,
'help': 'File Version',
},
ext={
'label': 'Extension',
'require': True,
'type': types.String,
'help': 'File Extension',
},
)
if not ctx:
return params
params['workspace']['default'] = ctx.workspace
name = ctx.task.parent().name
extensions = ctx.workspace.config['extensions']
extension = extensions[0]
path_template = get_path_template('workspace_file')
try:
data = path_template.parse(str(ctx.file))
except ParseError:
pass
else:
name = data['name']
extension = data['ext']
params['name']['default'] = name
params['ext']['default'] = extension
params['ext']['options'] = extensions
params['ext']['required'] = False
next_version = ctx.workspace.get_next_version(name, extension)
params['version']['default'] = next_version
params['version']['required'] = False
return params
@staticmethod
def available(ctx):
return ctx.host != 'cli' and ctx.workspace
template=template,
)
@task(priority=types.VALIDATE)
@requires(success('stage_sequence'))
@params(store('sequence_item'))
def validate_sequence(sequence_item):
'''Make sure new sequence does not exist.'''
if os.path.exists(sequence_item['path']):
raise Abort('Sequence already exists: ' + sequence_item['name'])
return True
@task(priority=types.COMMIT)
@requires(success('validate_sequence'))
@params(store('sequence_item'))
@returns(artifact('sequence'))
def commit_sequence(sequence_item):
'''Make new sequence'''
if sequence_item['template']:
sequence = sequence_item['template'].copy(sequence_item['path'])
else:
sequence = fsfs.get_entry(sequence_item['path'])
sequence.tag(*sequence_item['tags'])
return sequence
@task(priority=types.VALIDATE)
@requires(success('stage_asset_type'))
@params(store('asset_type'))
def validate_asset_type(asset_type):
'''Make sure new asset_type does not already exist'''
if asset_type.exists:
raise Abort('Asset Type already exists: %s' % asset_type.name)
return True
@task(priority=types.COMMIT)
@requires(success('validate_asset_type'))
@params(store('asset_type'))
@returns(artifact('asset_type'))
def commit_asset_type(asset_type):
'''Commit new asset_type Entry'''
asset_type.tag('asset_type')
return asset_type
class NewAsset(Action):
'''Create a new Asset'''
label = 'New Asset'
identifier = 'new.asset'
returns = artifact('asset')
@staticmethod
@returns(store('project_item'))
def stage_project(root, template):
'''Stage project data for validation'''
return dict(path=unipath(root),
name=os.path.basename(root),
template=api.get_template(template))
@task(priority=types.VALIDATE)
@params(store('project_item'))
@requires(success('stage_project'))
def validate_project(project_item):
'''Make sure the project does not already exist.'''
if os.path.exists(project_item['path']):
raise Abort('Project already exists: %s' % project_item['path'])
return True
@task(priority=types.COMMIT)
@params(store('project_item'))
@requires(success('validate_project'))
@returns(artifact('project'))
def commit_project(project_item):
'''Copy the project template to project directory'''
project = project_item['template'].copy(project_item['path'])
return project