def __init__(self, tray_widget, main_window):
self.tray_widget = tray_widget
self.main_window = main_window
self.log = Logger().get_logger(self.__class__.__name__)
self.modules = {}
self.services = {}
self.services_submenu = None
self.errors = []
CURRENT_DIR = os.path.dirname(__file__)
self.modules_imports = config.load_json(
os.path.join(CURRENT_DIR, "modules_imports.json"))
presets = config.get_presets(first_run=True)
menu_items = presets["tray"]["menu_items"]
try:
self.modules_usage = menu_items["item_usage"]
except Exception:
self.modules_usage = {}
self.log.critical("Couldn't find modules usage data.")
self.module_attributes = menu_items.get("attributes") or {}
self.icon_run = QtGui.QIcon(
resources.get_resource("icons", "circle_green.png"))
self.icon_stay = QtGui.QIcon(
resources.get_resource("icons", "circle_orange.png"))
self.icon_failed = QtGui.QIcon(
resources.get_resource("icons", "circle_red.png"))
def __init__(self):
super(IdleManager, self).__init__()
self.log = Logger().get_logger(self.__class__.__name__)
self.qaction = None
self.failed_icon = None
self._is_running = False
self.threads = []
def __init__(self):
super(IdleManager, self).__init__()
self.log = Logger().get_logger(self.__class__.__name__)
self.signal_reset_timer.connect(self._reset_time)
self.qaction = None
self.failed_icon = None
self._is_running = False
def __init__(self, logger=None):
if not logger:
self.log = Logger().get_logger(self.__class__.__name__)
else:
self.log = logger
self.signature = "( {} )".format(self.__class__.__name__)
def __init__(self, tray_widget, main_window):
self.tray_widget = tray_widget
self.main_window = main_window
self.log = Logger().get_logger(self.__class__.__name__)
self.icon_run = QtGui.QIcon(get_resource('circle_green.png'))
self.icon_stay = QtGui.QIcon(get_resource('circle_orange.png'))
self.icon_failed = QtGui.QIcon(get_resource('circle_red.png'))
self.services_thread = None
def __init__(self, main_parent=None, parent=None):
self.log = Logger().get_logger(__name__)
self.main_parent = main_parent
self.parent = parent
self.app_launcher = LauncherWindow()
# actions.register_default_actions()
actions.register_config_actions()
actions.register_environment_actions()
def __init__(self, tray_widget, main_widget):
self.log = Logger().get_logger(self.__class__.__name__)
self.modules = []
self.is_running = False
self.last_task = None
self.tray_widget = tray_widget
self.main_widget = main_widget
self.idle_man = None
self.signal_handler = None
self.widget_user_idle = WidgetUserIdle(self, tray_widget)
def __init__(self, session):
'''Expects a ftrack_api.Session instance'''
self.log = Logger().get_logger(self.__class__.__name__)
if not (isinstance(session, ftrack_api.session.Session)
or isinstance(session, ftrack_server.lib.SocketSession)):
raise Exception(
("Session object entered with args is instance of \"{}\""
" but expected instances are \"{}\" and \"{}\"").format(
str(type(session)), str(ftrack_api.session.Session),
str(ftrack_server.lib.SocketSession)))
self._session = session
# Using decorator
self.register = self.register_decorator(self.register)
self.launch = self.launch_log(self.launch)
def __init__(self, name, port, filepath, additional_args=[]):
super(SocketThread, self).__init__()
self.log = Logger().get_logger(self.__class__.__name__)
self.setName(name)
self.name = name
self.port = port
self.filepath = filepath
self.additional_args = additional_args
self.sock = None
self.subproc = None
self.connection = None
self._is_running = False
self.finished = False
self.mongo_error = False
self._temp_data = {}
def __init__(self, main_parent=None, parent=None):
self.log = Logger().get_logger(self.__class__.__name__, "PypeTray")
self.main_parent = main_parent
self.parent = parent
self.clockapi = ClockifyAPI()
self.message_widget = None
self.widget_settings = ClockifySettings(main_parent, self)
self.widget_settings_required = None
self.thread_timer_check = None
# Bools
self.bool_thread_check_running = False
self.bool_api_key_set = False
self.bool_workspace_set = False
self.bool_timer_run = False
self.clockapi.set_master(self)
self.bool_api_key_set = self.clockapi.set_api()
def __init__(self, main_parent=None, parent=None):
if not self.workspace_name:
raise Exception("Clockify Workspace is not set in config.")
os.environ["CLOCKIFY_WORKSPACE"] = self.workspace_name
self.log = Logger().get_logger(self.__class__.__name__, "PypeTray")
self.main_parent = main_parent
self.parent = parent
self.clockapi = ClockifyAPI(master_parent=self)
self.message_widget = None
self.widget_settings = ClockifySettings(main_parent, self)
self.widget_settings_required = None
self.thread_timer_check = None
# Bools
self.bool_thread_check_running = False
self.bool_api_key_set = False
self.bool_workspace_set = False
self.bool_timer_run = False
self.bool_api_key_set = self.clockapi.set_api()
import os
import sys
import re
import subprocess
import json
import opentimelineio_contrib.adapters.ffmpeg_burnins as ffmpeg_burnins
from pype.api import Logger, config
import pype.lib
log = Logger().get_logger("BurninWrapper", "burninwrap")
ffmpeg_path = pype.lib.get_ffmpeg_tool_path("ffmpeg")
ffprobe_path = pype.lib.get_ffmpeg_tool_path("ffprobe")
FFMPEG = (
'{} -loglevel panic -i %(input)s %(filters)s %(args)s%(output)s'
).format(ffmpeg_path)
FFPROBE = (
'{} -v quiet -print_format json -show_format -show_streams "%(source)s"'
).format(ffprobe_path)
DRAWTEXT = (
"drawtext=text=\\'%(text)s\\':x=%(x)s:y=%(y)s:fontcolor="
"%(color)s@%(opacity).1f:fontsize=%(size)d:fontfile='%(font)s'"
)
TIMECODE = (
"drawtext=timecode=\\'%(timecode)s\\':text=\\'%(text)s\\'"
":timecode_rate=%(fps).2f:x=%(x)s:y=%(y)s:fontcolor="
import os
import time
import datetime
import threading
from Qt import QtCore, QtWidgets, QtGui
import ftrack_api
from ..ftrack_server.lib import check_ftrack_url
from ..ftrack_server import socket_thread
from ..lib import credentials
from ..ftrack_module import FTRACK_MODULE_DIR
from . import login_dialog
from pype.api import Logger, resources
log = Logger().get_logger("FtrackModule")
class FtrackTrayWrapper:
def __init__(self, module):
self.module = module
self.thread_action_server = None
self.thread_socket_server = None
self.thread_timer = None
self.bool_logged = False
self.bool_action_server_running = False
self.bool_action_thread_running = False
self.bool_timer_event = False
import sys
import json
import threading
import signal
import socket
import datetime
import ftrack_api
from ftrack_server import FtrackServer
from pype.modules.ftrack.ftrack_server.lib import (SocketSession,
StatusEventHub,
TOPIC_STATUS_SERVER,
TOPIC_STATUS_SERVER_RESULT)
from pype.api import Logger, config
log = Logger().get_logger("Event storer")
action_identifier = ("event.server.status" + os.environ["FTRACK_EVENT_SUB_ID"])
host_ip = socket.gethostbyname(socket.gethostname())
action_data = {
"label":
"Pype Admin",
"variant":
"- Event server Status ({})".format(host_ip),
"description":
"Get Infromation about event server",
"actionIdentifier":
action_identifier,
"icon":
"{}/ftrack/action_icons/PypeAdmin.svg".format(
os.environ.get(
"PYPE_STATICS_SERVER",
from avalon import api, lib
from pype.api import Logger
log = Logger().get_logger(__name__, "asset_creator")
class AssetCreator(api.Action):
name = "asset_creator"
label = "Asset Creator"
icon = "plus-square"
order = 250
def is_compatible(self, session):
"""Return whether the action is compatible with the session"""
compatible = True
# Check required modules.
module_names = [
"ftrack_api", "ftrack_api_old", "pype.tools.assetcreator"
]
for name in module_names:
try:
__import__(name)
except ImportError:
compatible = False
# Check session environment.
if "AVALON_PROJECT" not in session:
compatible = False
#!/usr/bin/env python
import time
from pype.hosts.resolve.utils import get_resolve_module
from pype.api import Logger
log = Logger().get_logger(__name__)
wait_delay = 2.5
wait = 0.00
ready = None
while True:
try:
# Create project and set parameters:
resolve = get_resolve_module()
pm = resolve.GetProjectManager()
if pm:
ready = None
else:
ready = True
except AttributeError:
pass
if ready is None:
time.sleep(wait_delay)
log.info(f"Waiting {wait}s for Resolve to have opened Project Manager")
wait += wait_delay
else:
print(f"Preloaded variables: \n\n\tResolve module: "
f"`resolve` > {type(resolve)} \n\tProject manager: "
f"`pm` > {type(pm)}")
break
import os
import socket
from Qt import QtCore
from socketserver import ThreadingMixIn
from http.server import HTTPServer
from .lib import RestApiFactory, Handler
from .base_class import route, register_statics
from pype.api import Logger
log = Logger().get_logger("RestApiServer")
class ThreadingSimpleServer(ThreadingMixIn, HTTPServer):
pass
class RestApiServer:
"""Rest Api allows to access statics or callbacks with http requests.
To register statics use `register_statics`.
To register callback use `register_callback` method or use `route` decorator.
`route` decorator should be used with not-class functions, it is possible
to use within class when inherits `RestApi` (defined in `base_class.py`)
or created object, with used decorator, is registered with `register_obj`.
.. code-block:: python
@route("/username", url_prefix="/api", methods=["get"], strict_match=False)
def get_username():
return {"username": getpass.getuser()}
import os
import re
import json
import datetime
import traceback
import http.server
from http import HTTPStatus
from urllib.parse import urlparse
from .lib import RestMethods, CallbackResult, RequestInfo
from .exceptions import AbortException
from . import RestApiFactory, Splitter
from pype.api import Logger
log = Logger().get_logger("RestApiHandler")
class Handler(http.server.SimpleHTTPRequestHandler):
# TODO fill will necessary statuses
default_messages = {
HTTPStatus.BAD_REQUEST: "Bad request",
HTTPStatus.NOT_FOUND: "Not found"
}
statuses = {
"POST": {
"OK": 200,
"CREATED": 201
},
"PUT": {
class ProcessEventHub(SocketBaseEventHub):
hearbeat_msg = b"processor"
uri, port, database, table_name = get_ftrack_event_mongo_info()
is_table_created = False
pypelog = Logger().get_logger("Session Processor")
def __init__(self, *args, **kwargs):
self.dbcon = DbConnector(self.uri, self.port, self.database,
self.table_name)
super(ProcessEventHub, self).__init__(*args, **kwargs)
def prepare_dbcon(self):
try:
self.dbcon.install()
self.dbcon._database.list_collection_names()
except pymongo.errors.AutoReconnect:
self.pypelog.error(
"Mongo server \"{}\" is not responding, exiting.".format(
os.environ["AVALON_MONGO"]))
sys.exit(0)
except pymongo.errors.OperationFailure:
self.pypelog.error(
("Error with Mongo access, probably permissions."
"Check if exist database with name \"{}\""
" and collection \"{}\" inside.").format(
self.database, self.table_name))
self.sock.sendall(b"MongoError")
sys.exit(0)
def wait(self, duration=None):
"""Overriden wait
Event are loaded from Mongo DB when queue is empty. Handled event is
set as processed in Mongo DB.
"""
started = time.time()
self.prepare_dbcon()
while True:
try:
event = self._event_queue.get(timeout=0.1)
except queue.Empty:
if not self.load_events():
time.sleep(0.5)
else:
try:
self._handle(event)
self.dbcon.update_one(
{"id": event["id"]},
{"$set": {
"pype_data.is_processed": True
}})
except pymongo.errors.AutoReconnect:
self.pypelog.error(
("Mongo server \"{}\" is not responding, exiting."
).format(os.environ["AVALON_MONGO"]))
sys.exit(0)
# Additional special processing of events.
if event['topic'] == 'ftrack.meta.disconnected':
break
if duration is not None:
if (time.time() - started) > duration:
break
def load_events(self):
"""Load not processed events sorted by stored date"""
ago_date = datetime.datetime.now() - datetime.timedelta(days=3)
self.dbcon.delete_many({
"pype_data.stored": {
"$lte": ago_date
},
"pype_data.is_processed": True
})
not_processed_events = self.dbcon.find({
"pype_data.is_processed": False
}).sort([("pype_data.stored", pymongo.ASCENDING)])
found = False
for event_data in not_processed_events:
new_event_data = {
k: v
for k, v in event_data.items()
if k not in ["_id", "pype_data"]
}
try:
event = ftrack_api.event.base.Event(**new_event_data)
except Exception:
self.logger.exception(
L('Failed to convert payload into event: {0}', event_data))
continue
found = True
self._event_queue.put(event)
return found
def _handle_packet(self, code, packet_identifier, path, data):
"""Override `_handle_packet` which skip events and extend heartbeat"""
code_name = self._code_name_mapping[code]
if code_name == "event":
return
return super()._handle_packet(code, packet_identifier, path, data)
import sys
import signal
import socket
import traceback
from ftrack_server import FtrackServer
from pype.modules.ftrack.ftrack_server.lib import (
SocketSession,
SocketBaseEventHub
)
from pype.api import Logger
log = Logger().get_logger("FtrackUserServer")
def main(args):
port = int(args[-1])
# Create a TCP/IP socket
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
# Connect the socket to the port where the server is listening
server_address = ("localhost", port)
log.debug(
"User Ftrack Server connected to {} port {}".format(*server_address)
)
sock.connect(server_address)
sock.sendall(b"CreatedUser")
def __init__(self, main_parent=None, parent=None):
self.log = Logger().get_logger(__name__)
self.main_parent = main_parent
self.parent = parent
self.app_launcher = None
import os
import time
import datetime
import threading
from Qt import QtCore, QtWidgets
import ftrack_api
from ..ftrack_server.lib import check_ftrack_url
from ..ftrack_server import socket_thread
from ..lib import credentials
from . import login_dialog
from pype.api import Logger
log = Logger().get_logger("FtrackModule", "ftrack")
class FtrackModule:
def __init__(self, main_parent=None, parent=None):
self.parent = parent
self.widget_login = login_dialog.Login_Dialog_ui(self)
self.thread_action_server = None
self.thread_socket_server = None
self.thread_timer = None
self.bool_logged = False
self.bool_action_server_running = False
self.bool_action_thread_running = False
self.bool_timer_event = False
def show_login_widget(self):
from avalon import api as avalon
from pyblish import api as pyblish
from pype.api import Logger
from .lib import (setup, reload_pipeline, ls, LOAD_PATH, CREATE_PATH,
PUBLISH_PATH)
__all__ = ["setup", "reload_pipeline", "ls"]
log = Logger().get_logger(__name__, "premiere")
def install():
"""Install Premiere-specific functionality of avalon-core.
This is where you install menus and register families, data
and loaders into Premiere.
It is called automatically when installing via `api.install(premiere)`.
See the Maya equivalent for inspiration on how to implement this.
"""
# Disable all families except for the ones we explicitly want to see
family_states = ["imagesequence", "mov"]
avalon.data["familiesStateDefault"] = False
avalon.data["familiesStateToggled"] = family_states
log.info("pype.hosts.premiere installed")
import sys
import signal
import socket
import datetime
from pype.modules.ftrack.ftrack_server.ftrack_server import FtrackServer
from pype.modules.ftrack.ftrack_server.lib import (SocketSession,
ProcessEventHub,
TOPIC_STATUS_SERVER)
from pype.modules import ModulesManager
from pype.api import Logger
import ftrack_api
log = Logger().get_logger("Event processor")
subprocess_started = datetime.datetime.now()
class SessionFactory:
session = None
def send_status(event):
subprocess_id = event["data"].get("subprocess_id")
if not subprocess_id:
return
if subprocess_id != os.environ["FTRACK_EVENT_SUB_ID"]:
return
import os
import pype
from pype.api import Logger
from .lib import AdobeRestApi, PUBLISH_PATHS
log = Logger().get_logger("AdobeCommunicator")
class AdobeCommunicator:
rest_api_obj = None
def __init__(self):
self.rest_api_obj = None
# Add "adobecommunicator" publish paths
PUBLISH_PATHS.append(os.path.sep.join(
[pype.PLUGINS_DIR, "adobecommunicator", "publish"]
))
def tray_start(self):
return
def process_modules(self, modules):
# Module requires RestApiServer
rest_api_module = modules.get("RestApiServer")
if not rest_api_module:
log.warning(
"AdobeCommunicator won't work without RestApiServer."
)
return
import collections
from Qt import QtCore, QtGui
from pype.api import Logger
from pypeapp.lib.log import _bootstrap_mongo_log, LOG_COLLECTION_NAME
log = Logger().get_logger("LogModel", "LoggingModule")
class LogModel(QtGui.QStandardItemModel):
COLUMNS = ("process_name", "hostname", "hostip", "username", "system_name",
"started")
colums_mapping = {
"process_name": "Process Name",
"process_id": "Process Id",
"hostname": "Hostname",
"hostip": "Host IP",
"username": "******",
"system_name": "System name",
"started": "Started at"
}
process_keys = ("process_id", "hostname", "hostip", "username",
"system_name", "process_name")
log_keys = ("timestamp", "level", "thread", "threadName", "message",
"loggerName", "fileName", "module", "method", "lineNumber")
default_value = "- Not set -"
ROLE_LOGS = QtCore.Qt.UserRole + 2
ROLE_PROCESS_ID = QtCore.Qt.UserRole + 3
def __init__(self, parent=None):
super(LogModel, self).__init__(parent)
from .menu import (install as menu_install, _update_menu_task_label)
from .events import register_hiero_events
__all__ = [
# Workfiles API
"open_file",
"save_file",
"current_file",
"has_unsaved_changes",
"file_extensions",
"work_root",
]
# get logger
log = Logger().get_logger(__name__, "nukestudio")
''' Creating all important host related variables '''
AVALON_CONFIG = os.getenv("AVALON_CONFIG", "pype")
# plugin root path
PUBLISH_PATH = os.path.join(PLUGINS_DIR, "nukestudio", "publish")
LOAD_PATH = os.path.join(PLUGINS_DIR, "nukestudio", "load")
CREATE_PATH = os.path.join(PLUGINS_DIR, "nukestudio", "create")
INVENTORY_PATH = os.path.join(PLUGINS_DIR, "nukestudio", "inventory")
# registering particular pyblish gui but `lite` is recomended!!
if os.getenv("PYBLISH_GUI", None):
pyblish.register_gui(os.getenv("PYBLISH_GUI", None))
def install():
"""A module containing generic loader actions that will display in the Loader.
"""
from avalon import api
from pype.api import Logger
log = Logger().get_logger(__name__, "nuke")
class SetFrameRangeLoader(api.Loader):
"""Specific loader of Alembic for the avalon.animation family"""
families = ["animation",
"camera",
"write",
"yeticache",
"pointcache"]
representations = ["*"]
label = "Set frame range"
order = 11
icon = "clock-o"
color = "white"
def load(self, context, name, namespace, data):
from pype.nuke import lib
version = context['version']
version_data = version.get("data", {})
import sys
import time
import datetime
import signal
import threading
from ftrack_server import FtrackServer
import ftrack_api
from pype.api import Logger
log = Logger().get_logger("Event Server Legacy")
class TimerChecker(threading.Thread):
max_time_out = 35
def __init__(self, server, session):
self.server = server
self.session = session
self.is_running = False
self.failed = False
super().__init__()
def stop(self):
self.is_running = False
def run(self):
start = datetime.datetime.now()
self.is_running = True
connected = False
import google.oauth2.service_account as service_account
from googleapiclient import errors
from .abstract_provider import AbstractProvider
from googleapiclient.http import MediaFileUpload, MediaIoBaseDownload
from pype.api import Logger
from pype.api import get_system_settings
from ..utils import time_function
import time
SCOPES = [
'https://www.googleapis.com/auth/drive.metadata.readonly',
'https://www.googleapis.com/auth/drive.file',
'https://www.googleapis.com/auth/drive.readonly'
] # for write|delete
log = Logger().get_logger("SyncServer")
class GDriveHandler(AbstractProvider):
"""
Implementation of Google Drive API.
As GD API doesn't have real folder structure, 'tree' in memory
structure is build in constructor to map folder paths to folder ids,
which are used in API. Building of this tree might be expensive and
slow and should be run only when necessary. Currently is set to
lazy creation, created only after first call when necessary.
Configuration for provider is in
'settings/defaults/project_settings/global.json'
Settings could be overwritten per project.
