opencue-pycue 1.11.66__tar.gz

opencue_pycue-1.11.66/.gitignore

@@ -0,0 +1,3 @@
+/build/
+/dist/
+/pycue.egg-info/

opencue_pycue-1.11.66/Dockerfile

@@ -0,0 +1,23 @@
+FROM python:3.9
+
+WORKDIR /opt/opencue
+
+# Paths to the pre-built python packages.
+# They are all defined her but no necessary used to make it simpler between the images
+ARG OPENCUE_PROTO_PACKAGE_PATH=/tmp/invalidpath
+ARG OPENCUE_RQD_PACKAGE_PATH=/tmp/invalidpath
+ARG OPENCUE_PYCUE_PACKAGE_PATH=/tmp/invalidpath
+ARG OPENCUE_PYOUTLINE_PACKAGE_PATH=/tmp/invalidpath
+ARG OPENCUE_CUESUBMIT_PACKAGE_PATH=/tmp/invalidpath
+ARG OPENCUE_CUEGUI_PACKAGE_PATH=/tmp/invalidpath
+ARG OPENCUE_CUEADMIN_PACKAGE_PATH=/tmp/invalidpath
+
+RUN python3 -m pip install --upgrade pip
+
+COPY LICENSE ./
+
+RUN mkdir /tmp/packages
+COPY ${OPENCUE_PROTO_PACKAGE_PATH} /tmp/packages/
+COPY ${OPENCUE_PYCUE_PACKAGE_PATH} /tmp/packages/
+
+RUN python3 -m pip install /tmp/packages/*.whl

opencue_pycue-1.11.66/FileSequence/FileSequence.py

@@ -0,0 +1,136 @@
+#  Copyright Contributors to the OpenCue Project
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+
+"""
+Helper class for representing a frame seqeunce path.
+
+It supports a complex syntax implementing features such as comma-separated frame ranges,
+stepped frame ranges and more. See the FileSequence class for more detail.
+"""
+
+import re
+from .FrameSet import FrameSet
+
+
+class FileSequence:
+    """Represents a file path to a frame sequence"""
+    __filepath = None
+    frameSet = None
+    __basename = None
+    __prefix = None
+    __suffix = None
+    __dirname = ""
+    __padSize = 1
+    __iter_index = 0
+
+    def __init__(self, filepath):
+        """
+        Construct a FileSequence object by parsing a filepath.
+        Details on how to specify a frame range can be seen in the FrameRange class
+        """
+
+        filePathMatch = re.match(r"^(?P<pf>.*\.)(?P<fspec>[\d#,\-@x]+)(?P<sf>\.[.\w]+)$", filepath)
+        if filePathMatch is not None:
+            self.__filepath = filepath
+            self.__prefix = filePathMatch.group('pf')
+            self.__suffix = filePathMatch.group('sf')
+            dirmatch = re.match(r"^(?P<dirname>.*/)(?P<basename>.*)$", self.__prefix)
+            if dirmatch is not None:
+                self.__dirname = dirmatch.group("dirname")
+                self.__basename = dirmatch.group("basename")
+            else:
+                self.__basename = self.__prefix
+            framerangematch = re.match(r"^([\d\-x,]+)", filePathMatch.group("fspec"))
+            if framerangematch is not None:
+                self.frameSet = FrameSet(framerangematch.group(1))
+                if self.frameSet.get(0) > self.frameSet.get(-1):
+                    raise ValueError('invalid filesequence range : ' + framerangematch.group(1))
+                firstFrameMatch = re.findall(r"^[-0]\d+", framerangematch.group(1))
+                if len(firstFrameMatch) > 0:
+                    self.__padSize = len(firstFrameMatch[0])
+
+            padmatch = re.findall(r"#+$", filePathMatch.group("fspec"))
+            if len(padmatch) > 0:
+                self.__padSize = len(padmatch[0])
+        else:
+            raise ValueError('invalid filesequence path : ' + filepath)
+
+    def getPrefix(self):
+        """Returns the prefix of the file sequence"""
+        return self.__prefix
+
+    def getSuffix(self):
+        """Returns the suffix of the file sequence"""
+        return self.__suffix
+
+    def getDirname(self):
+        """Returns the dirname of the file sequence, if given otherwise returns empty an string"""
+        return self.__dirname
+
+    def getBasename(self):
+        """Returns the base name of the file sequence"""
+        return self.__basename.rstrip(".")
+
+    def getPadSize(self):
+        """Returns the size of the frame padding. It defaults to 1 if none is detected"""
+        return self.__padSize
+
+    def getFileList(self, frameSet=None):
+        """ Returns the file list of the sequence """
+        filelist = []
+        paddingString = "%%0%dd" % self.getPadSize()
+        if self.frameSet:
+            for frame in self.frameSet.getAll():
+                if (frameSet is None or
+                        (isinstance(frameSet, FrameSet) and frame in frameSet.getAll())):
+                    framepath = self.getPrefix() + paddingString % frame + self.getSuffix()
+                    filelist.append(framepath)
+        else:
+            for frame in frameSet.getAll():
+                framepath = self.getPrefix() + paddingString % frame + self.getSuffix()
+                filelist.append(framepath)
+        return filelist
+
+    def getOpenRVPath(self, frameSet=None):
+        """ Returns a string specific for the OpenRV player"""
+        frameRange = ""
+        curFrameSet = frameSet or self.frameSet
+        if isinstance(curFrameSet, FrameSet):
+            frameRange = "%d-%d" % (curFrameSet.get(0), curFrameSet.get(-1))
+        framepath = self.getPrefix() + frameRange + "@"*self.__padSize + self.getSuffix()
+        return framepath
+
+    def __getitem__(self, index):
+        return self.getFileList()[index]
+
+    def __next__(self):
+        self.__iter_index += 1
+        if self.__iter_index <= len(self):
+            return self.getFileList()[self.__iter_index - 1]
+        raise StopIteration
+
+    def __iter__(self):
+        self.__iter_index = 0
+        return self
+
+    def __len__(self):
+        return len(self.getFileList())
+
+    def __call__(self, frame):
+        paddingString = "%%0%dd" % self.getPadSize()
+        framepath = self.getPrefix() + paddingString % frame + self.getSuffix()
+        return framepath
+
+    def __str__(self):
+        return self.__filepath

opencue_pycue-1.11.66/FileSequence/FrameRange.py

@@ -0,0 +1,188 @@
+#  Copyright Contributors to the OpenCue Project
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+
+"""
+Helper class for representing a frame range.
+
+It supports a complex syntax implementing features such as comma-separated frame ranges,
+stepped frame ranges and more. See the FrameRange class for more detail.
+"""
+
+from __future__ import division
+from __future__ import print_function
+from __future__ import absolute_import
+
+from builtins import str
+from builtins import range
+from builtins import object
+import re
+from collections import OrderedDict
+
+
+class FrameRange(object):
+    """Represents a sequence of frame numbers."""
+
+    SINGLE_FRAME_PATTERN = re.compile(r'^(-?)\d+$')
+    SIMPLE_FRAME_RANGE_PATTERN = re.compile(r'^(?P<sf>(-?)\d+)-(?P<ef>(-?)\d+)$')
+    STEP_PATTERN = re.compile(
+        r'^(?P<sf>(-?)\d+)-(?P<ef>(-?)\d+)(?P<stepSep>[xy])(?P<step>(-?)\d+)$')
+    INTERLEAVE_PATTERN = re.compile(r'^(?P<sf>(-?)\d+)-(?P<ef>(-?)\d+):(?P<step>(-?)\d+)$')
+
+    def __init__(self, frameRange):
+        """
+        Construct a FrameRange object by parsing a spec.
+
+        FrameSet("1-10x3");
+        FrameSet("1-10y3"); // inverted step
+        FrameSet("10-1x-1");
+        FrameSet("1"); // same as "1-1x1"
+        FrameSet("1-10:5"); // interleave of 5
+
+        A valid spec consists of:
+
+        An inTime.
+        An optional hyphen and outTime.
+        An optional x or y and stepSize.
+        Or an optional : and interleaveSize.
+        If outTime is less than inTime, stepSize must be negative.
+
+        A stepSize of 0 produces an empty FrameRange.
+
+        A stepSize cannot be combined with a interleaveSize.
+
+        A stepSize designated with y creates an inverted step. Frames that would be included
+        with an x step are excluded.
+
+        Example: 1-10y3 == 2, 3, 5, 6, 8, 9.
+
+        An interleaveSize alters the order of frames when iterating over the FrameRange. The
+        iterator will first produce the list of frames from inTime to outTime with a stepSize
+        equal to interleaveSize. The interleaveSize is then divided in half, producing another
+        set of frames unique from the first set. This process is repeated until interleaveSize
+        reaches 1.
+
+        Example: 1-10:5 == 1, 6, 2, 4, 8, 10, 3, 5, 7, 9.
+        """
+        self.frameList = self.parseFrameRange(frameRange)
+
+    def __str__(self):
+        # TODO(bcipriano) Make this smarter, group frame ranges and by step. (Issue #83)
+        return ','.join([str(frame) for frame in self.frameList])
+
+    def __getitem__(self, key):
+        return self.frameList[key]
+
+    def __len__(self):
+        return self.size()
+
+    def size(self):
+        """Gets the number of frames contained in this sequence."""
+        return len(self.frameList)
+
+    def get(self, idx):
+        """Gets an individual entry in the sequence, by numerical position."""
+        return self.frameList[idx]
+
+    def index(self, idx):
+        """Query index of frame number in frame set.
+
+        Returns:
+            int, index of frame. -1 if frame set does not contain frame.
+        """
+        try:
+            return self.frameList.index(idx)
+        except ValueError:
+            return -1
+
+    def getAll(self):
+        """Gets the full numerical sequence."""
+        return self.frameList
+
+    def normalize(self):
+        """Sorts and deduplicates the sequence."""
+        self.frameList = list(set(self.frameList))
+        self.frameList.sort()
+
+    @classmethod
+    def parseFrameRange(cls, frameRange):
+        """
+        Parse a string representation into a numerical sequence.
+
+        :type frameRange: str
+        :param frameRange: String representation of the frame range.
+        :rtype: FrameRange
+        :return: FrameRange representing the numerical sequence.
+        """
+        singleFrameMatcher = re.match(cls.SINGLE_FRAME_PATTERN, frameRange)
+        if singleFrameMatcher:
+            return [int(frameRange)]
+
+        simpleRangeMatcher = re.match(cls.SIMPLE_FRAME_RANGE_PATTERN, frameRange)
+        if simpleRangeMatcher:
+            startFrame = int(simpleRangeMatcher.group('sf'))
+            endFrame = int(simpleRangeMatcher.group('ef'))
+            return cls.__getIntRange(startFrame, endFrame, (1 if endFrame >= startFrame else -1))
+
+        rangeWithStepMatcher = re.match(cls.STEP_PATTERN, frameRange)
+        if rangeWithStepMatcher:
+            startFrame = int(rangeWithStepMatcher.group('sf'))
+            endFrame = int(rangeWithStepMatcher.group('ef'))
+            step = int(rangeWithStepMatcher.group('step'))
+            stepSep = rangeWithStepMatcher.group('stepSep')
+            return cls.__getSteppedRange(startFrame, endFrame, step, stepSep == 'y')
+
+        rangeWithInterleaveMatcher = re.match(cls.INTERLEAVE_PATTERN, frameRange)
+        if rangeWithInterleaveMatcher:
+            startFrame = int(rangeWithInterleaveMatcher.group('sf'))
+            endFrame = int(rangeWithInterleaveMatcher.group('ef'))
+            step = int(rangeWithInterleaveMatcher.group('step'))
+            return cls.__getInterleavedRange(startFrame, endFrame, step)
+
+        raise ValueError('unrecognized frame range syntax ' + frameRange)
+
+    @staticmethod
+    def __getIntRange(start, end, step):
+        return list(range(start, end+(step // abs(step)), step))
+
+    @classmethod
+    def __getSteppedRange(cls, start, end, step, inverseStep):
+        cls.__validateStepSign(start, end, step)
+        steppedRange = cls.__getIntRange(start, end, step)
+        if inverseStep:
+            fullRange = cls.__getIntRange(start, end, (-1 if step < 0 else 1))
+            return [frame for frame in fullRange if frame not in steppedRange]
+        return steppedRange
+
+    @classmethod
+    def __getInterleavedRange(cls, start, end, step):
+        cls.__validateStepSign(start, end, step)
+        interleavedFrames = OrderedDict()
+        incrValue = step // abs(step)
+        while abs(step) > 0:
+            interleavedFrames.update(
+                [(frame, None) for frame in cls.__getIntRange(start, end, step)])
+            start += incrValue
+            step = int(step / 2.0)
+        return list(interleavedFrames.keys())
+
+    @staticmethod
+    def __validateStepSign(start, end, step):
+        if step > 1 and end < start:
+            raise ValueError(
+                'end frame may not be less than start frame when using a positive step')
+        if step == 0:
+            raise ValueError('step cannot be zero')
+        if step < 0 and end >= start:
+            raise ValueError(
+                'end frame may not be greater than start frame when using a negative step')

opencue_pycue-1.11.66/FileSequence/FrameSet.py

@@ -0,0 +1,88 @@
+#  Copyright Contributors to the OpenCue Project
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+
+"""Module for `FileSequence.FrameSet`."""
+
+from __future__ import absolute_import
+from __future__ import print_function
+from __future__ import division
+
+from builtins import str
+from builtins import object
+from .FrameRange import FrameRange
+
+
+class FrameSet(object):
+    """Represents a sequence of `FileSequence.FrameRange`."""
+
+    def __init__(self, frameRange):
+        """Construct a FrameSet object by parsing a spec.
+
+        See FrameRange for the supported syntax. A FrameSet follows the same syntax,
+        with the addition that it may be a comma-separated list of different FrameRanges.
+        """
+        self.frameList = self.parseFrameRange(frameRange)
+
+    def __str__(self):
+        # TODO(bcipriano) Make this smarter, group frame ranges and by step. (Issue #83)
+        return ','.join([str(frame) for frame in self.frameList])
+
+    def __getitem__(self, key):
+        return self.frameList[key]
+
+    def __len__(self):
+        return self.size()
+
+    def size(self):
+        """Gets the number of frames contained in this sequence."""
+        return len(self.frameList)
+
+    def get(self, idx):
+        """Gets an individual entry in the sequence, by numerical position."""
+        return self.frameList[idx]
+
+    def index(self, idx):
+        """Query index of frame number in frame set.
+
+        Returns:
+            int, index of frame. -1 if frame set does not contain frame.
+        """
+        try:
+            return self.frameList.index(idx)
+        except ValueError:
+            return -1
+
+    def getAll(self):
+        """Gets the full numerical sequence."""
+        return self.frameList
+
+    def normalize(self):
+        """Sorts and dedeuplicates the sequence."""
+        self.frameList = list(set(self.frameList))
+        self.frameList.sort()
+
+    @staticmethod
+    def parseFrameRange(frameRange):
+        """
+        Parses a string representation of a frame range into a FrameSet.
+
+        :type frameRange: str
+        :param frameRange: String representation of the frame range.
+        :rtype: FrameSet
+        :return: The FrameSet representing the same sequence.
+        """
+        frameList = []
+        for frameRangeSection in frameRange.split(','):
+            frameList.extend(FrameRange.parseFrameRange(frameRangeSection))
+        return frameList

opencue_pycue-1.11.66/FileSequence/__init__.py

@@ -0,0 +1,26 @@
+#  Copyright Contributors to the OpenCue Project
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+
+"""
+Top-level module of FileSequence.
+
+FileSequence contains helper classes for representing a job's frame range.
+"""
+
+from __future__ import absolute_import
+from __future__ import print_function
+from __future__ import division
+from .FrameRange import FrameRange
+from .FrameSet import FrameSet
+from .FileSequence import FileSequence

opencue_pycue-1.11.66/PKG-INFO

@@ -0,0 +1,11 @@
+Metadata-Version: 2.1
+Name: opencue_pycue
+Version: 1.11.66
+Requires-Dist: future==1.0.0
+Requires-Dist: opencue-proto
+Requires-Dist: pyyaml==6.0.1
+Requires-Dist: six==1.16.0
+Provides-Extra: test
+Requires-Dist: mock==2.0.0; extra == 'test'
+Requires-Dist: pyfakefs==5.2.3; extra == 'test'
+Requires-Dist: pytest; extra == 'test'

opencue_pycue-1.11.66/README.md

@@ -0,0 +1,6 @@
+# OpenCue Python API
+
+PyCue is the OpenCue Python API. OpenCue client-side Python tools, such as
+CueGUI and CueAdmin, all call PyCue for communication with your OpenCue
+deployment.
+

opencue_pycue-1.11.66/opencue/__init__.py

@@ -0,0 +1,45 @@
+#  Copyright Contributors to the OpenCue Project
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+
+"""Top level of the opencue module."""
+
+from __future__ import absolute_import
+from __future__ import print_function
+from __future__ import division
+
+import logging
+
+# pylint: disable=cyclic-import
+from .cuebot import Cuebot
+from . import api
+from . import wrappers
+from . import search
+
+from .exception import CueException
+from .exception import EntityNotFoundException
+# pylint: disable=redefined-builtin
+from .util import id
+# pylint: enable=redefined-builtin
+from .util import logPath
+from .util import proxy
+from .util import rep
+
+
+class __NullHandler(logging.Handler):
+    def emit(self, record):
+        pass
+
+
+__logger = logging.getLogger("opencue")
+__logger.addHandler(__NullHandler())