1
2class Config:
3    """
4    Config
5    """
6
7    def __init__(self):
8        pass
9
10    def CreateFromEnv(self):
11        """
12        CreateFromEnv()
13
14        Create a :py:class:`PyOpenColorIO.Config` object using the environment variable.
15
16        :returns: Config object
17        """
18        pass
19
20    def CreateFromFile(self, filename):
21        """
22        CreateFromFile(filename)
23
24        Create a :py:class:`PyOpenColorIO.Config` object using the information in a file.
25
26        :param filename: name of file
27        :type filename: string
28        :return: Config object
29        """
30        pass
31
32    def CreateFromStream(self, istream):
33        pass
34
35    def isEditable(self):
36        """
37        isEditable()
38
39        Returns whether Config is editable.
40
41        The configurations returned from
42        :py:func:`PyOpenColorIO.GetCurrentConfig` are not editable, and if
43        you want to edit them you can use
44        :py:meth:`PyOpenColorIO.Config.createEditableCopy`.
45
46        If you attempt to call any of the set functions on a noneditable
47        Config, an exception will be thrown.
48
49        :return: state of :py:class:`PyOpenColorIO.Config`'s editability
50        :rtype: bool
51        """
52        pass
53
54    def createEditableCopy(self):
55        """
56        createEditableCopy()
57
58        Returns an editable copy of :py:class:`PyOpenColorIO.Config`.
59
60        :return: editable copy of :py:class:`PyOpenColorIO.Config`
61        :rtype: Config object
62        """
63        pass
64
65    def sanityCheck(self):
66        """
67        sanityCheck()
68
69        This will throw an exception if :py:class:`PyOpenColorIO.Config` is
70        malformed. The most common error occurs when references are made to
71        colorspaces that do not exist.
72        """
73        pass
74
75    def getDescription(self):
76        """
77        getDescription()
78
79        Returns the stored description of :py:class:`PyOpenColorIO.Config`.
80
81        :return: stored description of :py:class:`PyOpenColorIO.Config`
82        :rtype: string
83        """
84        pass
85
86    def setDescription(self, desc):
87        """
88        setDescription(desc)
89
90        Sets the description of :py:class:`PyOpenColorIO.Config`.
91
92        :param desc: description of :py:class:`PyOpenColorIO.Config`
93        :type desc: string
94        """
95        pass
96
97    def serialize(self):
98        """
99        serialize()
100
101        Returns the string representation of :py:class:`PyOpenColorIO.Config`
102        in YAML text form. This is typically stored on disk in a file with the
103        .ocio extension.
104
105        :return: :py:class:`PyOpenColorIO.Config` in YAML text form
106        :rtype: string
107        """
108        pass
109
110    def getCacheID(self, pycontext=None):
111        """
112        getCacheID([, pycontext])
113
114        This will produce a hash of the all colorspace definitions, etc.
115
116        All external references, such as files used in FileTransforms, etc.,
117        will be incorporated into the cacheID. While the contents of the files
118        are not read, the file system is queried for relavent information
119        (mtime, inode) so that the :py:class:`PyOpenColorIO.Config`'s cacheID
120        will change when the underlying luts are updated.
121
122        If a context is not provided, the current Context will be used. If a
123        null context is provided, file references will not be taken into
124        account (this is essentially a hash of :py:meth:`PyOpenColorIO.Config.serialize`).
125
126        :param pycontext: optional
127        :type pycontext: object
128        :return: hash of :py:class:`PyOpenColorIO.Config`
129        :rtype: string
130        """
131        pass
132
133    def getCurrentContext(self):
134        """
135        getCurrentContext()
136
137        Return the current context, which is essentially a record of all
138        the environment variables that are available for use in file path
139        lookups.
140
141        :return: context
142        :rtype: pycontext
143        """
144        pass
145
146    def addEnvironmentVar(self, name, defaultValue):
147        """
148        """
149        pass
150
151    def getNumEnvironmentVars(self):
152        """
153        """
154        pass
155
156    def getEnvironmentVarNameByIndex(self, index):
157        """
158        """
159        pass
160
161    def getEnvironmentVarDefault(self, name):
162        """
163        """
164        pass
165
166    def getEnvironmentVarDefaults(self):
167        """
168        """
169        pass
170
171    def clearEnvironmentVars(self):
172        """
173        """
174        pass
175
176    def getSearchPath(self):
177        """
178        getSearchPath()
179
180        Returns the search path.
181
182        :return: search path
183        :rtype: string
184        """
185        pass
186
187    def setSearchPath(self, searchpath):
188        """
189        setSearchPath(path)
190
191        Sets the search path.
192
193        :param path: the search path
194        :type path: string
195        """
196        pass
197
198    def getWorkingDir(self):
199        """
200        getWorkingDir()
201
202        Returns the working directory.
203
204        :return: the working directory
205        :rtype path: string
206        """
207        pass
208
209    def setWorkingDir(self, dirname):
210        """
211        setWorkingDir(path)
212
213        Sets the working directory.
214
215        :param path: the working directory
216        :type path: string
217        """
218        pass
219
220    def getNumColorSpaces(self):
221        pass
222
223    def getColorSpaceNameByIndex(self, index):
224        pass
225
226    def getColorSpaces(self):
227        """
228        getColorSpaces()
229
230        Returns all the ColorSpaces defined in :py:class:`PyOpenColorIO.Config`.
231
232        :return: ColorSpaces in :py:class:`PyOpenColorIO.Config`
233        :rtype: tuple
234        """
235        pass
236
237    def getColorSpace(self, name):
238        """
239        getColorSpace(name)
240
241        Returns the data for the specified color space in :py:class:`PyOpenColorIO.Config`.
242
243        This will return null if the specified name is not found.
244
245        :param name: name of color space
246        :type name: string
247        :return: data for specified color space
248        :rtype: pyColorSpace object
249        """
250        pass
251
252    def getIndexForColorSpace(self, name):
253        pass
254
255    def addColorSpace(self, colorSpace):
256        """
257        addColorSpace(pyColorSpace)
258
259        Add a specified color space to :py:class:`PyOpenColorIO.Config`.
260
261        :param pyColorSpace: color space
262        :type pyColorSpace: object
263
264        .. note::
265           If another color space is already registered with the same name,
266           this will overwrite it.
267        """
268        pass
269
270    def clearColorSpaces(self):
271        """
272        clearColorSpaces()
273
274        Clear the color spaces in :py:class:`PyOpenColorIO.Config`.
275        """
276        pass
277
278    def parseColorSpaceFromString(self, str):
279        """
280        parseColorSpaceFromString(str)
281
282        Parses out the color space from a string.
283
284        Given the specified string, gets the longest, right-most color space substring.
285        * If strict parsing is enabled, and no color space is found, return an empty string.
286        * If strict parsing is disabled, return the default role, if defined.
287        * If the default role is not defined, return an empty string.
288
289        :param str: ColorSpace data
290        :type str: string
291        :return: parsed data
292        :rtype: string
293        """
294        pass
295
296    def isStrictParsingEnabled(self):
297        pass
298
299    def setStrictParsingEnabled(self, enable):
300        pass
301
302    def setRole(self, role, csname):
303        """
304        setRole(role, csname)
305
306        Set a role's ColorSpace.
307
308        Setting the colorSpaceName name to a null string unsets it.
309
310        :param role: role whose ColorSpace will be set
311        :type role: string
312        :param csname: name of ColorSpace
313        :type csname: string
314        """
315        pass
316
317    def getNumRoles(self):
318        pass
319
320    def hasRole(self, role):
321        pass
322
323    def getRoleName(self, index):
324        pass
325
326    def getDefaultDisplay(self):
327        """
328        getDefaultDisplay()
329
330        Returns the default display set in :py:class:`PyOpenColorIO.Config`.
331
332        :return: default display
333        :rtype: string
334        """
335        pass
336
337    def getNumDisplays(self):
338        pass
339
340    def getDisplay(self, index):
341        pass
342
343    def getDisplays(self):
344        """
345        getDisplays()
346
347        Returns all the displays defined in :py:class:`PyOpenColorIO.Config`.
348
349        :return: displays in :py:class:`PyOpenColorIO.Config`
350        :rtype: list of strings
351        """
352        pass
353
354    def getDefaultView(self, display):
355        """
356        getDefaultView(display)
357
358        Returns the default view of :py:class:`PyOpenColorIO.Config`.
359
360        :param display: default view
361        :type display: string
362        :return: view
363        :rtype: string
364        """
365        pass
366
367    def getNumViews(self, display):
368        pass
369
370    def getView(self, display, index):
371        pass
372
373    def getViews(self, display):
374        """
375        getViews(display)
376
377        Returns all the views defined in :py:class:`PyOpenColorIO.Config`.
378
379        :param display: views in :py:class:`PyOpenColorIO.Config`
380        :type display: string
381        :return: views in :py:class:`PyOpenColorIO.Config`.
382        :rtype: list of strings
383        """
384        pass
385
386    def getDisplayColorSpaceName(self, display, view):
387        """
388        getDisplayColorSpaceName(display, view)
389
390        Returns the ColorSpace name corresponding to the display and view
391        combination in :py:class:`PyOpenColorIO.Config`.
392
393        :param display: display
394        :type display: string
395        :param view: view
396        :type view: string
397        :return: display color space name
398        :rtype: string
399        """
400        pass
401
402    def getDisplayLooks(self, display, view):
403        """
404        getDisplayLooks(display, view)
405
406        Returns the looks corresponding to the display and view combination in
407        :py:class:`PyOpenColorIO.Config`.
408
409        :param display: display
410        :type display: string
411        :param view: view
412        :type view: string
413        :return: looks
414        :rtype: string
415        """
416        pass
417
418    def addDisplay(self, display, view, csname, looks=None):
419        """
420        addDisplay(display, view, colorSpaceName[, looks])
421
422        NEEDS WORK
423
424        :param display:
425        :type display: string
426        :param view:
427        :type view: string
428        :param colorSpaceName:
429        :type colorSpaceName: string
430        :param looks: optional
431        :type looks: string
432        """
433        pass
434
435    def clearDisplays(self):
436        """
437        clearDisplays()
438        """
439        pass
440
441    def setActiveDisplays(self, dislpays):
442        """
443        setActiveDisplays(displays)
444
445        Sets the active displays in :py:class:`PyOpenColorIO.Config`.
446
447        :param displays: active displays
448        :type displays: string
449        """
450        pass
451
452    def getActiveDisplays(self):
453        """
454        getActiveDisplays()
455
456        Returns the active displays in :py:class:`PyOpenColorIO.Config`.
457
458        :return: active displays
459        :rtype: string
460        """
461        pass
462
463    def setActiveViews(self, views):
464        """
465        setActiveViews(views)
466
467        Sets the active views in :py:class:`PyOpenColorIO.Config`.
468
469        :param views: active views
470        :type views: string
471        """
472        pass
473
474    def getActiveViews(self):
475        """
476        getActiveViews()
477
478        Returns the active views in :py:class:`PyOpenColorIO.Config`.
479
480        :return: active views
481        :rtype: string
482        """
483        pass
484
485    def getDefaultLumaCoefs(self):
486        """
487        getDefaultLumaCoefs()
488
489        Returns the default luma coefficients in :py:class:`PyOpenColorIO.Config`.
490
491        :return: luma coefficients
492        :rtype: list of floats
493        """
494        pass
495
496    def setDefaultLumaCoefs(self, coefficients):
497        """
498        setDefaultLumaCoefs(pyCoef)
499
500        Sets the default luma coefficients in :py:class:`PyOpenColorIO.Config`.
501
502        :param pyCoef: luma coefficients
503        :type pyCoef: object
504        """
505        pass
506
507    def getLook(self, lookname):
508        """
509        getLook(str)
510
511        Returns the information of a specified look in
512        :py:class:`PyOpenColorIO.Config`.
513
514        :param str: look
515        :type str: string
516        :return: specified look
517        :rtype: look object
518        """
519        pass
520
521    def getNumLooks(self):
522        pass
523
524    def getLookNameByIndex(self, index):
525        pass
526
527    def getLooks(self):
528        """
529        getLooks()
530
531        Returns a list of all the looks defined in
532        :py:class:`PyOpenColorIO.Config`.
533
534        :return: looks
535        :rtype: tuple of look objects
536        """
537        pass
538
539    def addLook(self, look):
540        """
541        addLook(pylook)
542
543        Adds a look to :py:class:`PyOpenColorIO.Config`.
544
545        :param pylook: look
546        :type pylook: look object
547        """
548        pass
549
550    def clearLooks(self):
551        """
552        clearLooks()
553
554        Clear looks in :py:class:`PyOpenColorIO.Config`.
555        """
556        pass
557
558    def getProcessor(self, arg1, arg2=None, direction=None, context=None):
559        """
560        getProcessor(arg1[, arg2[, direction[, context]])
561
562        Returns a processor for a specified transform.
563
564        Although this is not often needed, it allows for the reuse of atomic
565        OCIO functionality, such as applying an individual LUT file.
566
567        There are two canonical ways of creating a
568        :py:class:`PyOpenColorIO.Processor`:
569
570        #. Pass a transform into arg1, in which case arg2 will be ignored.
571        #. Set arg1 as the source and arg2 as the destination. These can be
572           ColorSpace names, objects, or roles.
573
574        Both arguments, ``direction`` (of transform) and ``context``, are
575        optional and respected for both methods of
576        :py:class:`PyOpenColorIO.Processor` creation.
577
578        This will fail if either the source or destination color space is null.
579
580        See Python: Processor for more details.
581
582        .. note::
583            This may provide higher fidelity than anticipated due to internal
584            optimizations. For example, if inputColorSpace and outputColorSpace
585            are members of the same family, no conversion will be applied, even
586            though, strictly speaking, quantization should be added.
587
588            If you wish to test these calls for quantization characteristics,
589            apply in two steps; the image must contain RGB triples (though
590            arbitrary numbers of additional channels can be optionally
591            supported using the pixelStrideBytes arg). ???
592
593        :param arg1:
594        :type arg1: object
595        :param arg2: ignored if arg1 is a transform
596        :type arg2: object
597        :param direction: optional
598        :type direction: string
599        :param context: optional
600        :type context: object
601        """
602        pass
603