SRC(1)

NAME
src - src Documentation

psd-tools is a Python package for working with Adobe Photoshop PSD files as described in specification.

INSTALLATION

Use pip to install the package:

            pip install psd-tools

NOTE:
        In order to extract images from 32bit PSD files PIL/Pillow must be built with LITTLECMS or LITTLECMS2 support (apt-get install liblcms2-2 or brew install little-cms2)

GETTING STARTED

            from psd_tools import PSDImage

            psd = PSDImage.open('example.psd')
            psd.composite().save('example.png')

            for layer in psd:
                print(layer)
                image = layer.composite()

Check out the Usage documentation for more examples.

  Usage

  Command line

The package provides command line tools to handle a PSD document:

            psd-tools export <input_file> <output_file> [options]
            psd-tools show <input_file> [options]
            psd-tools debug <input_file> [options]
            psd-tools -h | --help
            psd-tools --version

Example:

            psd-tools show example.psd  # Show the file content
            psd-tools export example.psd example.png  # Export as PNG
            psd-tools export example.psd[0] example-0.png  # Export layer as PNG

  Working with PSD document

psd_tools.api package provides the user-friendly API to work with PSD files. PSDImage represents a PSD file.

Open an image:

            from psd_tools import PSDImage
            psd = PSDImage.open('my_image.psd')

Most of the data structure in the psd-tools suppports pretty printing in IPython environment.

            In [1]: PSDImage.open('example.psd')
            Out[1]:
            PSDImage(mode=RGB size=101x55 depth=8 channels=3)
              [0] PixelLayer('Background' size=101x55)
              [1] PixelLayer('Layer 1' size=85x46)

Internal layers are accessible by iterator or indexing:

            for layer in psd:
                print(layer)
                if layer.is_group():
                    for child in layer:
                        print(child)

            child = psd[0][0]

NOTE:
        The iteration order is from background to foreground, which is reversed from version prior to 1.7.x. Use reversed(list(psd)) to iterate from foreground to background.

The opened PSD file can be saved:

            psd.save('output.psd')

  Working with Layers

There are various layer kinds in Photoshop.

The most basic layer type is PixelLayer:

            print(layer.name)
            layer.kind == 'pixel'

Some of the layer attributes are editable, such as a layer name:

            layer.name = 'Updated layer 1'

NOTE:
        Currently, the package does not support adding or removing of a layer.

Group has internal layers:

            for layer in group:
                print(layer)

            first_layer = group[0]

TypeLayer is a layer with texts:

            print(layer.text)

ShapeLayer draws a vector shape, and the shape information is stored in vector_mask and origination property. Other layers can also have shape information as a mask:

            print(layer.vector_mask)
            for shape in layer.origination:
                print(shape)

SmartObjectLayer embeds or links an external file for non-destructive editing. The file content is accessible via smart_object property:

            import io
            if layer.smart_object.filetype in ('jpg', 'png'):
                image = Image.open(io.BytesIO(layer.smart_object.data))

SolidColorFill, PatternFill, and GradientFill are fill layers that paint the entire region if there is no associated mask. Sub-classes of AdjustmentLayer represents layer adjustment applied to the composed image. See Adjustment layers.

  Exporting data to PIL

Export the entire document as PIL.Image:

            image = psd.composite()
            image.save('exported.png')

Export a single layer including masks and clipping layers:

            image = layer.composite()

Export layer and mask separately without composition:

            image = layer.topil()
            mask = layer.mask.topil()

To composite specific layers, such as layers except for texts, use layer_filter option:

            image = psd.composite(
                layer_filter=lambda layer: layer.is_visible() and layer.kind != 'type')

Note that most of the layer effects and adjustment layers are not supported. The compositing result may look different from Photoshop.

  Exporting data to NumPy

PSDImage or layers can be exported to NumPy array by numpy() method:

            image = psd.numpy()
            layer_image = layer.numpy()

  Migrating to 1.9

psd-tools 1.9 switches to NumPy based compositing.

version 1.8.x:

            psd = PSDImage.open(filename)
            image = psd.compose()
            layer = psd[0]
            layer_image = layer.compose()

version 1.9.x:

            psd = PSDImage.open(filename)
            image = psd.composite()
            layer = psd[0]
            layer_image = layer.composite()

NumPy array API is introduced:

            image = psd.numpy()
            layer_image = layer.numpy()

  Migrating to 1.8

There are major API changes in version 1.8.x.

NOTE:
        In version 1.8.0 - 1.8.7, the package name was psd_tools2.

  PSDImage

File open method is changed from load to open().

version 1.7.x:

            psd = PSDImage.load(filename)
            with open(filename, 'rb') as f:
                psd = PSDImage.from_stream(f)

version 1.8.x:

            psd = PSDImage.open(filename)
            with open(filename, 'rb') as f:
                psd = PSDImage.open(f)

  Layers

Children of PSDImage or Group is directly accessible by iterator or indexing.

version 1.7.x:

            for layer in group.layers:
                print(layer)

            first_child = group.layers[0]

version 1.8.x:

            for layer in group:
                print(layer)

            first_child = group[0]

In version 1.8.x, the order of layers is reversed to reflect that the index should not change when a new layer is added on top.

  PIL export

Primary PIL export method is compose().

version 1.7.x:

            image = psd.as_PIL()

            layer_image = compose(layer)
            raw_layer_image = layer.as_PIL()

version 1.8.x:

            image = psd.compose()

            layer_image = layer.compose()
            raw_layer_image = layer.topil()

  Low-level data structure

Data structures are completely rewritten to support writing functionality. See psd_tools.psd subpackage.

version 1.7.x:

            psd.decoded_data

version 1.8.x:

            psd._record

  Drop pymaging support

Pymaging support is dropped.

  Contributing

Development happens at github: bug tracker. Feel free to submit bug reports or pull requests. Attaching an erroneous PSD file makes the debugging process faster. Such PSD file might be added to the test suite.

The license is MIT.

  Package design

The package consists of two major subpackages:

    1.

        psd_tools.psd: subpackage that reads/writes low-level binary
            structure of the PSD/PSB file. The core data structures are built around attrs class that all implement read and write methods. Each data object tries to resemble the structure described in the specification. Although documented, the specification is far from complete and some are even inaccurate. When psd-tools finds unknown data structure, the package keeps such data as bytes in the parsed result.

    2.

        psd_tools.api: User-facing API that implements various
            easy-to-use methods that manipulate low-level psd_tools.psd data structures.

  Testing

In order to run tests, make sure PIL/Pillow is built with LittleCMS or LittleCMS2 support. For example, on Ubuntu, install the following packages:

            apt-get install liblcms2-dev libjpeg-dev libfreetype6-dev zlib1g-dev

Then install psd-tools with the following command:

            pip install -e .[dev]

Finally, run tests with pytest:

            pytest

  Documentation

Install Sphinx to generate documents:

            pip install sphinx sphinx_rtd_theme

Once installed, use Makefile:

            make docs

  Acknowledgments

Great thanks to all the contributors.

FEATURES

Supported:

    •   Read and write of the low-level PSD/PSB file structure

    •   Raw layer image export in NumPy and PIL format

Limited support:

    •   Composition of basic pixel-based layers

    •   Composition of fill layer effects

    •   Vector masks

    •   Editing of some layer attributes such as layer name

    •   Blending modes except for dissolve

    •   Drawing of bezier curves

Not supported:

    •   Editing of layer structure, such as adding or removing a layer

    •   Composition of adjustment layers

    •   Composition of many layer effects

    •   Font rendering

  psd_tools

See Usage for examples.

  PSDImage

    class psd_tools.PSDImage(data)
        Photoshop PSD/PSB file object.

        The low-level data structure is accessible at PSDImage._record.

        Example:

                from psd_tools import PSDImage

                psd = PSDImage.open('example.psd')
                image = psd.compose()

                for layer in psd:
                    layer_image = layer.compose()

        property bbox
            Minimal bounding box that contains all the visible layers.

            Use viewbox to get viewport bounding box. When the psd is empty, bbox is equal to the canvas bounding box.

            Returns
                (left, top, right, bottom) tuple.

        property bottom
            Bottom coordinate.

            Returns
                int

        property channels
            Number of color channels.

            Returns
                int

        property color_mode
            Document color mode, such as 'RGB' or 'GRAYSCALE'. See ColorMode.

            Returns
                ColorMode

        property compatibility_mode
            Set the compositing and layer organization compatibility mode. Writable.

            Returns
                CompatibilityMode

        compose(force=False, bbox=None, layer_filter=None)
            Deprecated, use composite().

            Compose the PSD image.

            Parameters
                bbox -- Viewport tuple (left, top, right, bottom).

            Returns
                PIL.Image, or None if there is no pixel.

        composite(viewport=None, force=False, color=1.0, alpha=0.0, layer_filter=None, ignore_preview=False, apply_icc=False)
            Composite the PSD image.

            Parameters

                •   viewport -- Viewport bounding box specified by (x1, y1, x2, y2) tuple. Default is the viewbox of the PSD.

                •   ignore_preview -- Boolean flag to whether skip compositing when a pre-composited preview is available.

                •   force -- Boolean flag to force vector drawing.

                •   color -- Backdrop color specified by scalar or tuple of scalar. The color value should be in [0.0, 1.0]. For example, (1., 0., 0.) specifies red in RGB color mode.

                •   alpha -- Backdrop alpha in [0.0, 1.0].

                •   layer_filter -- Callable that takes a layer as argument and returns whether if the layer is composited. Default is is_visible().

            Returns
                PIL.Image.

        property depth
            Pixel depth bits.

            Returns
                int

        descendants(include_clip=True)
            Return a generator to iterate over all descendant layers.

            Example:

                    # Iterate over all layers
                    for layer in psd.descendants():
                        print(layer)

                    # Iterate over all layers in reverse order
                    for layer in reversed(list(psd.descendants())):
                        print(layer)

            Parameters
                include_clip -- include clipping layers.

        classmethod frompil(image, compression=Compression.RLE)
            Create a new PSD document from PIL Image.

            Parameters

                •   image -- PIL Image object.

                •   compression -- ImageData compression option. See Compression.

            Returns
                A PSDImage object.

        has_preview()
            Returns if the document has real merged data. When True, topil() returns pre-composed data.

        has_thumbnail()
            True if the PSDImage has a thumbnail resource.

        property height
            Document height.

            Returns
                int

        property image_resources
            Document image resources. ImageResources is a dict-like structure that keeps various document settings.

            See psd_tools.constants.Resource for available keys.

            Returns
                ImageResources

        Example:

                    from psd_tools.constants import Resource
                    version_info = psd.image_resources.get_data(Resource.VERSION_INFO)
                    slices = psd.image_resources.get_data(Resource.SLICES)

        Image resources contain an ICC profile. The following shows how to export a PNG file with embedded ICC profile:

                    from psd_tools.constants import Resource
                    icc_profile = psd.image_resources.get_data(Resource.ICC_PROFILE)
                    image = psd.compose(apply_icc=False)
                    image.save('output.png', icc_profile=icc_profile)

        is_group()
            Return True if the layer is a group.

            Returns
                bool

        is_visible()
            Returns visibility of the element.

            Returns
                bool

        property kind
            Kind.

            Returns
                'psdimage'

        property left
            Left coordinate.

            Returns
                0

        property name
            Element name.

            Returns
                'Root'

        classmethod new(mode, size, color=0, depth=8, **kwargs)
            Create a new PSD document.

            Parameters

                •   mode -- The color mode to use for the new image.

                •   size -- A tuple containing (width, height) in pixels.

                •   color -- What color to use for the image. Default is black.

            Returns
                A PSDImage object.

        numpy(channel=None)
            Get NumPy array of the layer.

            Parameters
                channel -- Which channel to return, can be 'color', 'shape', 'alpha', or 'mask'. Default is 'color+alpha'.

            Returns
                numpy.ndarray

        property offset
            (left, top) tuple.

            Returns
                tuple

        classmethod open(fp, **kwargs)
            Open a PSD document.

            Parameters

                •   fp -- filename or file-like object.

                •   encoding -- charset encoding of the pascal string within the file, default 'macroman'. Some psd files need explicit encoding option.

            Returns
                A PSDImage object.

        property parent
            Parent of this layer.

        property right
            Right coordinate.

            Returns
                int

        save(fp, mode='wb', **kwargs)
            Save the PSD file.

            Parameters

                •   fp -- filename or file-like object.

                •   encoding -- charset encoding of the pascal string within the file, default 'macroman'.

                •   mode -- file open mode, default 'wb'.

        property size
            (width, height) tuple.

            Returns
                tuple

        property tagged_blocks
            Document tagged blocks that is a dict-like container of settings.

            See psd_tools.constants.Tag for available keys.

            Returns
                TaggedBlocks or None.

        Example:

                    from psd_tools.constants import Tag
                    patterns = psd.tagged_blocks.get_data(Tag.PATTERNS1)

        thumbnail()
            Returns a thumbnail image in PIL.Image. When the file does not contain an embedded thumbnail image, returns None.

        property top
            Top coordinate.

            Returns
                0

        topil(channel=None, apply_icc=False)
            Get PIL Image.

            Parameters

                •   channel -- Which channel to return; e.g., 0 for 'R' channel in RGB image. See ChannelID. When None, the method returns all the channels supported by PIL modes.

                •   apply_icc -- Whether to apply ICC profile conversion to sRGB.

            Returns
                PIL.Image, or None if the composed image is not available.

        property version
            Document version. PSD file is 1, and PSB file is 2.

            Returns
                int

        property viewbox
            Return bounding box of the viewport.

            Returns
                (left, top, right, bottom) tuple.

        property visible
            Visibility.

            Returns
                True

        property width
            Document width.

            Returns
                int

  psd_tools.api.adjustments

Adjustment and fill layers.

Example:

            if layer.kind == 'brightnesscontrast':
                print(layer.brightness)

            if layer.kind == 'gradientfill':
                print(layer.gradient_kind)

  Fill layers

Fill layers are similar to ShapeLayer except that the layer might not have an associated vector mask. The layer therefore expands the entire canvas of the PSD document.

Fill layers all inherit from FillLayer.

Example:

            if isinstance(layer, psd_tools.layers.FillLayer):
                image = layer.compose()

  SolidColorFill

    class psd_tools.api.adjustments.SolidColorFill(*args)
        Solid color fill.

        property bbox
            (left, top, right, bottom) tuple.

        property blend_mode
            Blend mode of this layer. Writable.

            Example:

                    from psd_tools.constants import BlendMode
                    if layer.blend_mode == BlendMode.NORMAL:
                        layer.blend_mode = BlendMode.SCREEN

            Returns
                BlendMode.

        property bottom
            Bottom coordinate.

            Returns
                int

        property clip_layers
            Clip layers associated with this layer.

            To compose clipping layers:

                    from psd_tools import compose
                    clip_mask = compose(layer.clip_layers)

            Returns
                list of layers

        property clipping_layer
            Clipping flag for this layer. Writable.

            Returns
                bool

        compose(force=False, bbox=None, layer_filter=None)
            Deprecated, use composite().

            Compose layer and masks (mask, vector mask, and clipping layers).

            Note that the resulting image size is not necessarily equal to the layer size due to different mask dimensions. The offset of the composed image is stored at .info['offset'] attribute of PIL.Image.

            Parameters
                bbox -- Viewport bounding box specified by (x1, y1, x2, y2) tuple.

            Returns
                PIL.Image, or None if the layer has no pixel.

        composite(viewport=None, force=False, color=1.0, alpha=0.0, layer_filter=None, apply_icc=False)
            Composite layer and masks (mask, vector mask, and clipping layers).

            Parameters

                •   viewport -- Viewport bounding box specified by (x1, y1, x2, y2) tuple. Default is the layer's bbox.

                •   force -- Boolean flag to force vector drawing.

                •   color -- Backdrop color specified by scalar or tuple of scalar. The color value should be in [0.0, 1.0]. For example, (1., 0., 0.) specifies red in RGB color mode.

                •   alpha -- Backdrop alpha in [0.0, 1.0].

                •   layer_filter -- Callable that takes a layer as argument and returns whether if the layer is composited. Default is is_visible().

            Returns
                PIL.Image.

        property data
            Color in Descriptor(RGB).

        property effects
            Layer effects.

            Returns
                Effects

        has_clip_layers()
            Returns True if the layer has associated clipping.

            Returns
                bool

        has_effects()
            Returns True if the layer has effects.

            Returns
                bool

        has_mask()
            Returns True if the layer has a mask.

            Returns
                bool

        has_origination()
            Returns True if the layer has live shape properties.

            Returns
                bool

        has_pixels()
            Returns True if the layer has associated pixels. When this is True, topil method returns PIL.Image.

            Returns
                bool

        has_stroke()
            Returns True if the shape has a stroke.

        has_vector_mask()
            Returns True if the layer has a vector mask.

            Returns
                bool

        property height
            Height of the layer.

            Returns
                int

        is_group()
            Return True if the layer is a group.

            Returns
                bool

        is_visible()
            Layer visibility. Takes group visibility in account.

            Returns
                bool

        property kind
            Kind of this layer, such as group, pixel, shape, type, smartobject, or psdimage. Class name without layer suffix.

            Returns
                str

        property layer_id
            Layer ID.

            Returns
                int layer id. if the layer is not assigned an id, -1.

        property left
            Left coordinate. Writable.

            Returns
                int

        property mask
            Returns mask associated with this layer.

            Returns
                Mask or None

        property name
            Layer name. Writable.

            Returns
                str

        numpy(channel=None, real_mask=True)
            Get NumPy array of the layer.

            Parameters
                channel -- Which channel to return, can be 'color', 'shape', 'alpha', or 'mask'. Default is 'color+alpha'.

            Returns
                numpy.ndarray or None if there is no pixel.

        property offset
            (left, top) tuple. Writable.

            Returns
                tuple

        property opacity
            Opacity of this layer in [0, 255] range. Writable.

            Returns
                int

        property origination
            Property for a list of live shapes or a line.

            Some of the vector masks have associated live shape properties, that are Photoshop feature to handle primitive shapes such as a rectangle, an ellipse, or a line. Vector masks without live shape properties are plain path objects.

            See psd_tools.api.shape.

            Returns
                List of Invalidated, Rectangle, RoundedRectangle, Ellipse, or Line.

        property parent
            Parent of this layer.

        property right
            Right coordinate.

            Returns
                int

        property size
            (width, height) tuple.

            Returns
                tuple

        property stroke
            Property for strokes.

        property tagged_blocks
            Layer tagged blocks that is a dict-like container of settings.

            See psd_tools.constants.Tag for available keys.

            Returns
                TaggedBlocks or None.

        Example:

                    from psd_tools.constants import Tag
                    metadata = layer.tagged_blocks.get_data(Tag.METADATA_SETTING)

        property top
            Top coordinate. Writable.

            Returns
                int

        topil(channel=None, apply_icc=False)
            Get PIL Image of the layer.

            Parameters

                •   channel -- Which channel to return; e.g., 0 for 'R' channel in RGB image. See ChannelID. When None, the method returns all the channels supported by PIL modes.

                •   apply_icc -- Whether to apply ICC profile conversion to sRGB.

            Returns
                PIL.Image, or None if the layer has no pixels.

        Example:

                    from psd_tools.constants import ChannelID

                    image = layer.topil()
                    red = layer.topil(ChannelID.CHANNEL_0)
                    alpha = layer.topil(ChannelID.TRANSPARENCY_MASK)

        NOTE:
                Not all of the PSD image modes are supported in PIL.Image. For example, 'CMYK' mode cannot include alpha channel in PIL. In this case, topil drops alpha channel.

        property vector_mask
            Returns vector mask associated with this layer.

            Returns
                VectorMask or None

        property visible
            Layer visibility. Doesn't take group visibility in account. Writable.

            Returns
                bool

        property width
            Width of the layer.

            Returns
                int

  PatternFill

    class psd_tools.api.adjustments.PatternFill(*args)
        Pattern fill.

        property bbox
            (left, top, right, bottom) tuple.

        property blend_mode
            Blend mode of this layer. Writable.

            Example:

                    from psd_tools.constants import BlendMode
                    if layer.blend_mode == BlendMode.NORMAL:
                        layer.blend_mode = BlendMode.SCREEN

            Returns
                BlendMode.

        property bottom
            Bottom coordinate.

            Returns
                int

        property clip_layers
            Clip layers associated with this layer.

            To compose clipping layers:

                    from psd_tools import compose
                    clip_mask = compose(layer.clip_layers)

            Returns
                list of layers

        property clipping_layer
            Clipping flag for this layer. Writable.

            Returns
                bool

        compose(force=False, bbox=None, layer_filter=None)
            Deprecated, use composite().

            Compose layer and masks (mask, vector mask, and clipping layers).

            Note that the resulting image size is not necessarily equal to the layer size due to different mask dimensions. The offset of the composed image is stored at .info['offset'] attribute of PIL.Image.

            Parameters
                bbox -- Viewport bounding box specified by (x1, y1, x2, y2) tuple.

            Returns
                PIL.Image, or None if the layer has no pixel.

        composite(viewport=None, force=False, color=1.0, alpha=0.0, layer_filter=None, apply_icc=False)
            Composite layer and masks (mask, vector mask, and clipping layers).

            Parameters

                •   viewport -- Viewport bounding box specified by (x1, y1, x2, y2) tuple. Default is the layer's bbox.

                •   force -- Boolean flag to force vector drawing.

                •   color -- Backdrop color specified by scalar or tuple of scalar. The color value should be in [0.0, 1.0]. For example, (1., 0., 0.) specifies red in RGB color mode.

                •   alpha -- Backdrop alpha in [0.0, 1.0].

                •   layer_filter -- Callable that takes a layer as argument and returns whether if the layer is composited. Default is is_visible().

            Returns
                PIL.Image.

        property data
            Pattern in Descriptor(PATTERN).

        property effects
            Layer effects.

            Returns
                Effects

        has_clip_layers()
            Returns True if the layer has associated clipping.

            Returns
                bool

        has_effects()
            Returns True if the layer has effects.

            Returns
                bool

        has_mask()
            Returns True if the layer has a mask.

            Returns
                bool

        has_origination()
            Returns True if the layer has live shape properties.

            Returns
                bool

        has_pixels()
            Returns True if the layer has associated pixels. When this is True, topil method returns PIL.Image.

            Returns
                bool

        has_stroke()
            Returns True if the shape has a stroke.

        has_vector_mask()
            Returns True if the layer has a vector mask.

            Returns
                bool

        property height
            Height of the layer.

            Returns
                int

        is_group()
            Return True if the layer is a group.

            Returns
                bool

        is_visible()
            Layer visibility. Takes group visibility in account.

            Returns
                bool

        property kind
            Kind of this layer, such as group, pixel, shape, type, smartobject, or psdimage. Class name without layer suffix.

            Returns
                str

        property layer_id
            Layer ID.

            Returns
                int layer id. if the layer is not assigned an id, -1.

        property left
            Left coordinate. Writable.

            Returns
                int

        property mask
            Returns mask associated with this layer.

            Returns
                Mask or None

        property name
            Layer name. Writable.

            Returns
                str

        numpy(channel=None, real_mask=True)
            Get NumPy array of the layer.

            Parameters
                channel -- Which channel to return, can be 'color', 'shape', 'alpha', or 'mask'. Default is 'color+alpha'.

            Returns
                numpy.ndarray or None if there is no pixel.

        property offset
            (left, top) tuple. Writable.

            Returns
                tuple

        property opacity
            Opacity of this layer in [0, 255] range. Writable.

            Returns
                int

        property origination
            Property for a list of live shapes or a line.

            Some of the vector masks have associated live shape properties, that are Photoshop feature to handle primitive shapes such as a rectangle, an ellipse, or a line. Vector masks without live shape properties are plain path objects.

            See psd_tools.api.shape.

            Returns
                List of Invalidated, Rectangle, RoundedRectangle, Ellipse, or Line.

        property parent
            Parent of this layer.

        property right
            Right coordinate.

            Returns
                int

        property size
            (width, height) tuple.

            Returns
                tuple

        property stroke
            Property for strokes.

        property tagged_blocks
            Layer tagged blocks that is a dict-like container of settings.

            See psd_tools.constants.Tag for available keys.

            Returns
                TaggedBlocks or None.

        Example:

                    from psd_tools.constants import Tag
                    metadata = layer.tagged_blocks.get_data(Tag.METADATA_SETTING)

        property top
            Top coordinate. Writable.

            Returns
                int

        topil(channel=None, apply_icc=False)
            Get PIL Image of the layer.

            Parameters

                •   channel -- Which channel to return; e.g., 0 for 'R' channel in RGB image. See ChannelID. When None, the method returns all the channels supported by PIL modes.

                •   apply_icc -- Whether to apply ICC profile conversion to sRGB.

            Returns
                PIL.Image, or None if the layer has no pixels.

        Example:

                    from psd_tools.constants import ChannelID

                    image = layer.topil()
                    red = layer.topil(ChannelID.CHANNEL_0)
                    alpha = layer.topil(ChannelID.TRANSPARENCY_MASK)

        NOTE:
                Not all of the PSD image modes are supported in PIL.Image. For example, 'CMYK' mode cannot include alpha channel in PIL. In this case, topil drops alpha channel.

        property vector_mask
            Returns vector mask associated with this layer.

            Returns
                VectorMask or None

        property visible
            Layer visibility. Doesn't take group visibility in account. Writable.

            Returns
                bool

        property width
            Width of the layer.

            Returns
                int

  GradientFill

    class psd_tools.api.adjustments.GradientFill(*args)
        Gradient fill.

        property bbox
            (left, top, right, bottom) tuple.

        property blend_mode
            Blend mode of this layer. Writable.

            Example:

                    from psd_tools.constants import BlendMode
                    if layer.blend_mode == BlendMode.NORMAL:
                        layer.blend_mode = BlendMode.SCREEN

            Returns
                BlendMode.

        property bottom
            Bottom coordinate.

            Returns
                int

        property clip_layers
            Clip layers associated with this layer.

            To compose clipping layers:

                    from psd_tools import compose
                    clip_mask = compose(layer.clip_layers)

            Returns
                list of layers

        property clipping_layer
            Clipping flag for this layer. Writable.

            Returns
                bool

        compose(force=False, bbox=None, layer_filter=None)
            Deprecated, use composite().

            Compose layer and masks (mask, vector mask, and clipping layers).

            Note that the resulting image size is not necessarily equal to the layer size due to different mask dimensions. The offset of the composed image is stored at .info['offset'] attribute of PIL.Image.

            Parameters
                bbox -- Viewport bounding box specified by (x1, y1, x2, y2) tuple.

            Returns
                PIL.Image, or None if the layer has no pixel.

        composite(viewport=None, force=False, color=1.0, alpha=0.0, layer_filter=None, apply_icc=False)
            Composite layer and masks (mask, vector mask, and clipping layers).

            Parameters

                •   viewport -- Viewport bounding box specified by (x1, y1, x2, y2) tuple. Default is the layer's bbox.

                •   force -- Boolean flag to force vector drawing.

                •   color -- Backdrop color specified by scalar or tuple of scalar. The color value should be in [0.0, 1.0]. For example, (1., 0., 0.) specifies red in RGB color mode.

                •   alpha -- Backdrop alpha in [0.0, 1.0].

                •   layer_filter -- Callable that takes a layer as argument and returns whether if the layer is composited. Default is is_visible().

            Returns
                PIL.Image.

        property data
            Gradient in Descriptor(GRADIENT).

        property effects
            Layer effects.

            Returns
                Effects

        property gradient_kind
            Kind of the gradient, one of the following:

                    •   Linear

                    •   Radial

                    •   Angle

                    •   Reflected

                    •   Diamond

        has_clip_layers()
            Returns True if the layer has associated clipping.

            Returns
                bool

        has_effects()
            Returns True if the layer has effects.

            Returns
                bool

        has_mask()
            Returns True if the layer has a mask.

            Returns
                bool

        has_origination()
            Returns True if the layer has live shape properties.

            Returns
                bool

        has_pixels()
            Returns True if the layer has associated pixels. When this is True, topil method returns PIL.Image.

            Returns
                bool

        has_stroke()
            Returns True if the shape has a stroke.

        has_vector_mask()
            Returns True if the layer has a vector mask.

            Returns
                bool

        property height
            Height of the layer.

            Returns
                int

        is_group()
            Return True if the layer is a group.

            Returns
                bool

        is_visible()
            Layer visibility. Takes group visibility in account.

            Returns
                bool

        property kind
            Kind of this layer, such as group, pixel, shape, type, smartobject, or psdimage. Class name without layer suffix.

            Returns
                str

        property layer_id
            Layer ID.

            Returns
                int layer id. if the layer is not assigned an id, -1.

        property left
            Left coordinate. Writable.

            Returns
                int

        property mask
            Returns mask associated with this layer.

            Returns
                Mask or None

        property name
            Layer name. Writable.

            Returns
                str

        numpy(channel=None, real_mask=True)
            Get NumPy array of the layer.

            Parameters
                channel -- Which channel to return, can be 'color', 'shape', 'alpha', or 'mask'. Default is 'color+alpha'.

            Returns
                numpy.ndarray or None if there is no pixel.

        property offset
            (left, top) tuple. Writable.

            Returns
                tuple

        property opacity
            Opacity of this layer in [0, 255] range. Writable.

            Returns
                int

        property origination
            Property for a list of live shapes or a line.

            Some of the vector masks have associated live shape properties, that are Photoshop feature to handle primitive shapes such as a rectangle, an ellipse, or a line. Vector masks without live shape properties are plain path objects.

            See psd_tools.api.shape.

            Returns
                List of Invalidated, Rectangle, RoundedRectangle, Ellipse, or Line.

        property parent
            Parent of this layer.

        property right
            Right coordinate.

            Returns
                int

        property size
            (width, height) tuple.

            Returns
                tuple

        property stroke
            Property for strokes.

        property tagged_blocks
            Layer tagged blocks that is a dict-like container of settings.

            See psd_tools.constants.Tag for available keys.

            Returns
                TaggedBlocks or None.

        Example:

                    from psd_tools.constants import Tag
                    metadata = layer.tagged_blocks.get_data(Tag.METADATA_SETTING)

        property top
            Top coordinate. Writable.

            Returns
                int

        topil(channel=None, apply_icc=False)
            Get PIL Image of the layer.

            Parameters

                •   channel -- Which channel to return; e.g., 0 for 'R' channel in RGB image. See ChannelID. When None, the method returns all the channels supported by PIL modes.

                •   apply_icc -- Whether to apply ICC profile conversion to sRGB.

            Returns
                PIL.Image, or None if the layer has no pixels.

        Example:

                    from psd_tools.constants import ChannelID

                    image = layer.topil()
                    red = layer.topil(ChannelID.CHANNEL_0)
                    alpha = layer.topil(ChannelID.TRANSPARENCY_MASK)

        NOTE:
                Not all of the PSD image modes are supported in PIL.Image. For example, 'CMYK' mode cannot include alpha channel in PIL. In this case, topil drops alpha channel.

        property vector_mask
            Returns vector mask associated with this layer.

            Returns
                VectorMask or None

        property visible
            Layer visibility. Doesn't take group visibility in account. Writable.

            Returns
                bool

        property width
            Width of the layer.

            Returns
                int

  Adjustment layers

Adjustment layers apply image filtering to the composed result. All adjustment layers inherit from AdjustmentLayer. Adjustment layers do not have pixels, and currently ignored in compose. Attempts to call topil on adjustment layers always return None.

Just as any other layer, adjustment layers might have an associated mask or vector mask. Adjustment can appear in other layers' clipping layers.

Example:

            if isinstance(layer, psd_tools.layers.AdjustmentLayer):
                print(layer.kind)

  BrightnessContrast

    class psd_tools.api.adjustments.BrightnessContrast(*args)
        Brightness and contrast adjustment.

        property automatic

        property brightness

        property contrast

        property lab

        property mean

        property use_legacy

        property vrsn

  Curves

    class psd_tools.api.adjustments.Curves(*args)
        Curves adjustment.

        property data
            Raw data.

            Returns
                Curves

        property extra

  Exposure

    class psd_tools.api.adjustments.Exposure(*args)
        Exposure adjustment.

        property exposure
            Exposure.

            Returns
                float

        property gamma
            Gamma.

            Returns
                float

        property offset
            Offset.

            Returns
                float

  Levels

    class psd_tools.api.adjustments.Levels(*args)
        Levels adjustment.

        Levels contain a list of LevelRecord.

        property data
            List of level records. The first record is the master.

            Returns
                Levels.

        property master
            Master record.

  Vibrance

    class psd_tools.api.adjustments.Vibrance(*args)
        Vibrance adjustment.

        property saturation
            Saturation.

            Returns
                int

        property vibrance
            Vibrance.

            Returns
                int

  HueSaturation

    class psd_tools.api.adjustments.HueSaturation(*args)
        Hue/Saturation adjustment.

        HueSaturation contains a list of data.

        property colorization
            Colorization.

            Returns
                tuple

        property data
            List of Hue/Saturation records.

            Returns
                list

        property enable_colorization
            Enable colorization.

            Returns
                int

        property master
            Master record.

            Returns
                tuple

  ColorBalance

    class psd_tools.api.adjustments.ColorBalance(*args)
        Color balance adjustment.

        property highlights
            Highlights.

            Returns
                tuple

        property luminosity
            Luminosity.

            Returns
                int

        property midtones
            Mid-tones.

            Returns
                tuple

        property shadows
            Shadows.

            Returns
                tuple

  BlackAndWhite

    class psd_tools.api.adjustments.BlackAndWhite(*args)
        Black and white adjustment.

        property blue

        property cyan

        property green

        property magenta

        property preset_file_name

        property preset_kind

        property red

        property tint_color

        property use_tint

        property yellow

  PhotoFilter

    class psd_tools.api.adjustments.PhotoFilter(*args)
        Photo filter adjustment.

        property color_components

        property color_space

        property density

        property luminosity

        property xyz
            xyz.

            Returns
                bool

  ChannelMixer

    class psd_tools.api.adjustments.ChannelMixer(*args)
        Channel mixer adjustment.

        property data

        property monochrome

  ColorLookup

    class psd_tools.api.adjustments.ColorLookup(*args)
        Color lookup adjustment.

  Posterize

    class psd_tools.api.adjustments.Posterize(*args)
        Posterize adjustment.

        property posterize
            Posterize value.

            Returns
                int

  Threshold

    class psd_tools.api.adjustments.Threshold(*args)
        Threshold adjustment.

        property threshold
            Threshold value.

            Returns
                int

  SelectiveColor

    class psd_tools.api.adjustments.SelectiveColor(*args)
        Selective color adjustment.

        property data

        property method

  GradientMap

    class psd_tools.api.adjustments.GradientMap(*args)
        Gradient map adjustment.

        property color_model

        property color_stops

        property dithered

        property expansion

        property gradient_name

        property interpolation
            Interpolation between 0.0 and 1.0.

        property length

        property max_color

        property min_color

        property mode

        property random_seed

        property reversed

        property roughness

        property show_transparency

        property transparency_stops

        property use_vector_color

  psd_tools.api.effects

Effects module.

    class psd_tools.api.effects.Effects(layer)
        List-like effects.

        property enabled
            Whether if all the effects are enabled.

            Return type
                bool

        find(name)
            Iterate effect items by name.

        property scale
            Scale value.

  DropShadow

    class psd_tools.api.effects.DropShadow(value, image_resources)

        property angle
            Angle value.

        property anti_aliased
            Angi-aliased.

        property blend_mode
            Effect blending mode.

        property choke
            Choke level.

        property color
            Color.

        property contour
            Contour configuration.

        property distance
            Distance.

        property enabled
            Whether if the effect is enabled.

        property layer_knocks_out
            Layers are knocking out.

        property noise
            Noise level.

        property opacity
            Layer effect opacity in percentage.

        property present
            Whether if the effect is present in Photoshop UI.

        property shown
            Whether if the effect is shown in dialog.

        property size
            Size in pixels.

        property use_global_light
            Using global light.

  InnerShadow

    class psd_tools.api.effects.InnerShadow(value, image_resources)

        property angle
            Angle value.

        property anti_aliased
            Angi-aliased.

        property blend_mode
            Effect blending mode.

        property choke
            Choke level.

        property color
            Color.

        property contour
            Contour configuration.

        property distance
            Distance.

        property enabled
            Whether if the effect is enabled.

        property noise
            Noise level.

        property opacity
            Layer effect opacity in percentage.

        property present
            Whether if the effect is present in Photoshop UI.

        property shown
            Whether if the effect is shown in dialog.

        property size
            Size in pixels.

        property use_global_light
            Using global light.

  OuterGlow

    class psd_tools.api.effects.OuterGlow(value, image_resources)

        property angle
            Angle value.

        property anti_aliased
            Angi-aliased.

        property blend_mode
            Effect blending mode.

        property choke
            Choke level.

        property color
            Color.

        property contour
            Contour configuration.

        property dithered
            Dither flag.

        property enabled
            Whether if the effect is enabled.

        property glow_type
            Glow type.

        property gradient
            Gradient configuration.

        property noise
            Noise level.

        property offset
            Offset value.

        property opacity
            Layer effect opacity in percentage.

        property present
            Whether if the effect is present in Photoshop UI.

        property quality_jitter
            Quality jitter

        property quality_range
            Quality range.

        property reversed
            Reverse flag.

        property shown
            Whether if the effect is shown in dialog.

        property size
            Size in pixels.

        property type
            Gradient type, one of linear, radial, angle, reflected, or diamond.

  InnerGlow

    class psd_tools.api.effects.InnerGlow(value, image_resources)

        property angle
            Angle value.

        property anti_aliased
            Angi-aliased.

        property blend_mode
            Effect blending mode.

        property choke
            Choke level.

        property color
            Color.

        property contour
            Contour configuration.

        property dithered
            Dither flag.

        property enabled
            Whether if the effect is enabled.

        property glow_source
            Elements source.

        property glow_type
            Glow type.

        property gradient
            Gradient configuration.

        property noise
            Noise level.

        property offset
            Offset value.

        property opacity
            Layer effect opacity in percentage.

        property present
            Whether if the effect is present in Photoshop UI.

        property quality_jitter
            Quality jitter

        property quality_range
            Quality range.

        property reversed
            Reverse flag.

        property shown
            Whether if the effect is shown in dialog.

        property size
            Size in pixels.

        property type
            Gradient type, one of linear, radial, angle, reflected, or diamond.

  ColorOverlay

    class psd_tools.api.effects.ColorOverlay(value, image_resources)

        property blend_mode
            Effect blending mode.

        property color
            Color.

        property enabled
            Whether if the effect is enabled.

        property opacity
            Layer effect opacity in percentage.

        property present
            Whether if the effect is present in Photoshop UI.

        property shown
            Whether if the effect is shown in dialog.

  GradientOverlay

    class psd_tools.api.effects.GradientOverlay(value, image_resources)

        property aligned
            Aligned.

        property angle
            Angle value.

        property blend_mode
            Effect blending mode.

        property dithered
            Dither flag.

        property enabled
            Whether if the effect is enabled.

        property gradient
            Gradient configuration.

        property offset
            Offset value.

        property opacity
            Layer effect opacity in percentage.

        property present
            Whether if the effect is present in Photoshop UI.

        property reversed
            Reverse flag.

        property scale
            Scale value.

        property shown
            Whether if the effect is shown in dialog.

        property type
            Gradient type, one of linear, radial, angle, reflected, or diamond.

  PatternOverlay

    class psd_tools.api.effects.PatternOverlay(value, image_resources)

        property aligned
            Aligned.

        property angle
            Angle value.

        property blend_mode
            Effect blending mode.

        property enabled
            Whether if the effect is enabled.

        property linked
            Linked.

        property opacity
            Layer effect opacity in percentage.

        property pattern
            Pattern config.

        property phase
            Phase value in Point.

        property present
            Whether if the effect is present in Photoshop UI.

        property scale
            Scale value.

        property shown
            Whether if the effect is shown in dialog.

  Stroke

    class psd_tools.api.effects.Stroke(value, image_resources)

        property angle
            Angle value.

        property blend_mode
            Effect blending mode.

        property color
            Color.

        property dithered
            Dither flag.

        property enabled
            Whether if the effect is enabled.

        property fill_type
            Fill type, SolidColor, Gradient, or Pattern.

        property gradient
            Gradient configuration.

        property linked
            Linked.

        property offset
            Offset value.

        property opacity
            Layer effect opacity in percentage.

        property overprint
            Overprint flag.

        property pattern
            Pattern config.

        property phase
            Phase value in Point.

        property position
            Position of the stroke, InsetFrame, OutsetFrame, or CenteredFrame.

        property present
            Whether if the effect is present in Photoshop UI.

        property reversed
            Reverse flag.

        property shown
            Whether if the effect is shown in dialog.

        property size
            Size value.

        property type
            Gradient type, one of linear, radial, angle, reflected, or diamond.

  BevelEmboss

    class psd_tools.api.effects.BevelEmboss(value, image_resources)

        property altitude
            Altitude value.

        property angle
            Angle value.

        property anti_aliased
            Anti-aliased.

        property bevel_style
            Bevel style, one of OuterBevel, InnerBevel, Emboss, PillowEmboss, or StrokeEmboss.

        property bevel_type
            Bevel type, one of SoftMatte, HardLight, SoftLight.

        property contour
            Contour configuration.

        property depth
            Depth value.

        property direction
            Direction, either StampIn or StampOut.

        property enabled
            Whether if the effect is enabled.

        property highlight_color
            Highlight color value.

        property highlight_mode
            Highlight blending mode.

        property highlight_opacity
            Highlight opacity value.

        property opacity
            Layer effect opacity in percentage.

        property present
            Whether if the effect is present in Photoshop UI.

        property shadow_color
            Shadow color value.

        property shadow_mode
            Shadow blending mode.

        property shadow_opacity
            Shadow opacity value.

        property shown
            Whether if the effect is shown in dialog.

        property size
            Size value in pixel.

        property soften
            Soften value.

        property use_global_light
            Using global light.

        property use_shape
            Using shape.

        property use_texture
            Using texture.

  Satin

    class psd_tools.api.effects.Satin(value, image_resources)
        Satin effect

        property angle
            Angle value.

        property anti_aliased
            Anti-aliased.

        property blend_mode
            Effect blending mode.

        property color
            Color.

        property contour
            Contour configuration.

        property distance
            Distance value.

        property enabled
            Whether if the effect is enabled.

        property inverted
            Inverted.

        property opacity
            Layer effect opacity in percentage.

        property present
            Whether if the effect is present in Photoshop UI.

        property shown
            Whether if the effect is shown in dialog.

        property size
            Size value in pixel.

  psd_tools.api.layers

Layer module.

  Artboard

    class psd_tools.api.layers.Artboard(*args)
        Artboard is a special kind of group that has a pre-defined viewbox.

        Example:

                artboard = psd[1]
                image = artboard.compose()

        property bbox
            (left, top, right, bottom) tuple.

        property blend_mode
            Blend mode of this layer. Writable.

            Example:

                    from psd_tools.constants import BlendMode
                    if layer.blend_mode == BlendMode.NORMAL:
                        layer.blend_mode = BlendMode.SCREEN

            Returns
                BlendMode.

        property bottom
            Bottom coordinate.

            Returns
                int

        property clip_layers
            Clip layers associated with this layer.

            To compose clipping layers:

                    from psd_tools import compose
                    clip_mask = compose(layer.clip_layers)

            Returns
                list of layers

        property clipping_layer
            Clipping flag for this layer. Writable.

            Returns
                bool

        compose(bbox=None, **kwargs)
            Compose the artboard.

            See compose() for available extra arguments.

            Parameters
                bbox -- Viewport tuple (left, top, right, bottom).

            Returns
                PIL.Image, or None if there is no pixel.

        composite(viewport=None, force=False, color=1.0, alpha=0.0, layer_filter=None, apply_icc=False)
            Composite layer and masks (mask, vector mask, and clipping layers).

            Parameters

                •   viewport -- Viewport bounding box specified by (x1, y1, x2, y2) tuple. Default is the layer's bbox.

                •   force -- Boolean flag to force vector drawing.

                •   color -- Backdrop color specified by scalar or tuple of scalar. The color value should be in [0.0, 1.0]. For example, (1., 0., 0.) specifies red in RGB color mode.

                •   alpha -- Backdrop alpha in [0.0, 1.0].

                •   layer_filter -- Callable that takes a layer as argument and returns whether if the layer is composited. Default is is_visible().

            Returns
                PIL.Image.

        descendants(include_clip=True)
            Return a generator to iterate over all descendant layers.

            Example:

                    # Iterate over all layers
                    for layer in psd.descendants():
                        print(layer)

                    # Iterate over all layers in reverse order
                    for layer in reversed(list(psd.descendants())):
                        print(layer)

            Parameters
                include_clip -- include clipping layers.

        property effects
            Layer effects.

            Returns
                Effects

        static extract_bbox(layers, include_invisible=False)
            Returns a bounding box for layers or (0, 0, 0, 0) if the layers have no bounding box.

            Parameters
                include_invisible -- include invisible layers in calculation.

            Returns
                tuple of four int

        has_clip_layers()
            Returns True if the layer has associated clipping.

            Returns
                bool

        has_effects()
            Returns True if the layer has effects.

            Returns
                bool

        has_mask()
            Returns True if the layer has a mask.

            Returns
                bool

        has_origination()
            Returns True if the layer has live shape properties.

            Returns
                bool

        has_pixels()
            Returns True if the layer has associated pixels. When this is True, topil method returns PIL.Image.

            Returns
                bool

        has_stroke()
            Returns True if the shape has a stroke.

        has_vector_mask()
            Returns True if the layer has a vector mask.

            Returns
                bool

        property height
            Height of the layer.

            Returns
                int

        is_group()
            Return True if the layer is a group.

            Returns
                bool

        is_visible()
            Layer visibility. Takes group visibility in account.

            Returns
                bool

        property kind
            Kind of this layer, such as group, pixel, shape, type, smartobject, or psdimage. Class name without layer suffix.

            Returns
                str

        property layer_id
            Layer ID.

            Returns
                int layer id. if the layer is not assigned an id, -1.

        property left
            Left coordinate. Writable.

            Returns
                int

        property mask
            Returns mask associated with this layer.

            Returns
                Mask or None

        property name
            Layer name. Writable.

            Returns
                str

        numpy(channel=None, real_mask=True)
            Get NumPy array of the layer.

            Parameters
                channel -- Which channel to return, can be 'color', 'shape', 'alpha', or 'mask'. Default is 'color+alpha'.

            Returns
                numpy.ndarray or None if there is no pixel.

        property offset
            (left, top) tuple. Writable.

            Returns
                tuple

        property opacity
            Opacity of this layer in [0, 255] range. Writable.

            Returns
                int

        property origination
            Property for a list of live shapes or a line.

            Some of the vector masks have associated live shape properties, that are Photoshop feature to handle primitive shapes such as a rectangle, an ellipse, or a line. Vector masks without live shape properties are plain path objects.

            See psd_tools.api.shape.

            Returns
                List of Invalidated, Rectangle, RoundedRectangle, Ellipse, or Line.

        property parent
            Parent of this layer.

        property right
            Right coordinate.

            Returns
                int

        property size
            (width, height) tuple.

            Returns
                tuple

        property stroke
            Property for strokes.

        property tagged_blocks
            Layer tagged blocks that is a dict-like container of settings.

            See psd_tools.constants.Tag for available keys.

            Returns
                TaggedBlocks or None.

        Example:

                    from psd_tools.constants import Tag
                    metadata = layer.tagged_blocks.get_data(Tag.METADATA_SETTING)

        property top
            Top coordinate. Writable.

            Returns
                int

        topil(channel=None, apply_icc=False)
            Get PIL Image of the layer.

            Parameters

                •   channel -- Which channel to return; e.g., 0 for 'R' channel in RGB image. See ChannelID. When None, the method returns all the channels supported by PIL modes.

                •   apply_icc -- Whether to apply ICC profile conversion to sRGB.

            Returns
                PIL.Image, or None if the layer has no pixels.

        Example:

                    from psd_tools.constants import ChannelID

                    image = layer.topil()
                    red = layer.topil(ChannelID.CHANNEL_0)
                    alpha = layer.topil(ChannelID.TRANSPARENCY_MASK)

        NOTE:
                Not all of the PSD image modes are supported in PIL.Image. For example, 'CMYK' mode cannot include alpha channel in PIL. In this case, topil drops alpha channel.

        property vector_mask
            Returns vector mask associated with this layer.

            Returns
                VectorMask or None

        property visible
            Layer visibility. Doesn't take group visibility in account. Writable.

            Returns
                bool

        property width
            Width of the layer.

            Returns
                int

  Group

    class psd_tools.api.layers.Group(*args)
        Group of layers.

        Example:

                group = psd[1]
                for layer in group:
                    if layer.kind == 'pixel':
                        print(layer.name)

        property bbox
            (left, top, right, bottom) tuple.

        property blend_mode
            Blend mode of this layer. Writable.

            Example:

                    from psd_tools.constants import BlendMode
                    if layer.blend_mode == BlendMode.NORMAL:
                        layer.blend_mode = BlendMode.SCREEN

            Returns
                BlendMode.

        property bottom
            Bottom coordinate.

            Returns
                int

        property clip_layers
            Clip layers associated with this layer.

            To compose clipping layers:

                    from psd_tools import compose
                    clip_mask = compose(layer.clip_layers)

            Returns
                list of layers

        property clipping_layer
            Clipping flag for this layer. Writable.

            Returns
                bool

        compose(force=False, bbox=None, layer_filter=None, context=None, color=None)
            Compose layer and masks (mask, vector mask, and clipping layers).

            Returns
                PIL Image object, or None if the layer has no pixels.

        composite(viewport=None, force=False, color=1.0, alpha=0.0, layer_filter=None, apply_icc=False)
            Composite layer and masks (mask, vector mask, and clipping layers).

            Parameters

                •   viewport -- Viewport bounding box specified by (x1, y1, x2, y2) tuple. Default is the layer's bbox.

                •   force -- Boolean flag to force vector drawing.

                •   color -- Backdrop color specified by scalar or tuple of scalar. The color value should be in [0.0, 1.0]. For example, (1., 0., 0.) specifies red in RGB color mode.

                •   alpha -- Backdrop alpha in [0.0, 1.0].

                •   layer_filter -- Callable that takes a layer as argument and returns whether if the layer is composited. Default is is_visible().

            Returns
                PIL.Image.

        descendants(include_clip=True)
            Return a generator to iterate over all descendant layers.

            Example:

                    # Iterate over all layers
                    for layer in psd.descendants():
                        print(layer)

                    # Iterate over all layers in reverse order
                    for layer in reversed(list(psd.descendants())):
                        print(layer)

            Parameters
                include_clip -- include clipping layers.

        property effects
            Layer effects.

            Returns
                Effects

        static extract_bbox(layers, include_invisible=False)
            Returns a bounding box for layers or (0, 0, 0, 0) if the layers have no bounding box.

            Parameters
                include_invisible -- include invisible layers in calculation.

            Returns
                tuple of four int

        has_clip_layers()
            Returns True if the layer has associated clipping.

            Returns
                bool

        has_effects()
            Returns True if the layer has effects.

            Returns
                bool

        has_mask()
            Returns True if the layer has a mask.

            Returns
                bool

        has_origination()
            Returns True if the layer has live shape properties.

            Returns
                bool

        has_pixels()
            Returns True if the layer has associated pixels. When this is True, topil method returns PIL.Image.

            Returns
                bool

        has_stroke()
            Returns True if the shape has a stroke.

        has_vector_mask()
            Returns True if the layer has a vector mask.

            Returns
                bool

        property height
            Height of the layer.

            Returns
                int

        is_group()
            Return True if the layer is a group.

            Returns
                bool

        is_visible()
            Layer visibility. Takes group visibility in account.

            Returns
                bool

        property kind
            Kind of this layer, such as group, pixel, shape, type, smartobject, or psdimage. Class name without layer suffix.

            Returns
                str

        property layer_id
            Layer ID.

            Returns
                int layer id. if the layer is not assigned an id, -1.

        property left
            Left coordinate. Writable.

            Returns
                int

        property mask
            Returns mask associated with this layer.

            Returns
                Mask or None

        property name
            Layer name. Writable.

            Returns
                str

        numpy(channel=None, real_mask=True)
            Get NumPy array of the layer.

            Parameters
                channel -- Which channel to return, can be 'color', 'shape', 'alpha', or 'mask'. Default is 'color+alpha'.

            Returns
                numpy.ndarray or None if there is no pixel.

        property offset
            (left, top) tuple. Writable.

            Returns
                tuple

        property opacity
            Opacity of this layer in [0, 255] range. Writable.

            Returns
                int

        property origination
            Property for a list of live shapes or a line.

            Some of the vector masks have associated live shape properties, that are Photoshop feature to handle primitive shapes such as a rectangle, an ellipse, or a line. Vector masks without live shape properties are plain path objects.

            See psd_tools.api.shape.

            Returns
                List of Invalidated, Rectangle, RoundedRectangle, Ellipse, or Line.

        property parent
            Parent of this layer.

        property right
            Right coordinate.

            Returns
                int

        property size
            (width, height) tuple.

            Returns
                tuple

        property stroke
            Property for strokes.

        property tagged_blocks
            Layer tagged blocks that is a dict-like container of settings.

            See psd_tools.constants.Tag for available keys.

            Returns
                TaggedBlocks or None.

        Example:

                    from psd_tools.constants import Tag
                    metadata = layer.tagged_blocks.get_data(Tag.METADATA_SETTING)

        property top
            Top coordinate. Writable.

            Returns
                int

        topil(channel=None, apply_icc=False)
            Get PIL Image of the layer.

            Parameters

                •   channel -- Which channel to return; e.g., 0 for 'R' channel in RGB image. See ChannelID. When None, the method returns all the channels supported by PIL modes.

                •   apply_icc -- Whether to apply ICC profile conversion to sRGB.

            Returns
                PIL.Image, or None if the layer has no pixels.

        Example:

                    from psd_tools.constants import ChannelID

                    image = layer.topil()
                    red = layer.topil(ChannelID.CHANNEL_0)
                    alpha = layer.topil(ChannelID.TRANSPARENCY_MASK)

        NOTE:
                Not all of the PSD image modes are supported in PIL.Image. For example, 'CMYK' mode cannot include alpha channel in PIL. In this case, topil drops alpha channel.

        property vector_mask
            Returns vector mask associated with this layer.

            Returns
                VectorMask or None

        property visible
            Layer visibility. Doesn't take group visibility in account. Writable.

            Returns
                bool

        property width
            Width of the layer.

            Returns
                int

  PixelLayer

    class psd_tools.api.layers.PixelLayer(psd, record, channels, parent)
        Layer that has rasterized image in pixels.

        Example:

                assert layer.kind == 'pixel':
                image = layer.topil()
                image.save('layer.png')

                composed_image = layer.compose()
                composed_image.save('composed-layer.png')

        property bbox
            (left, top, right, bottom) tuple.

        property blend_mode
            Blend mode of this layer. Writable.

            Example:

                    from psd_tools.constants import BlendMode
                    if layer.blend_mode == BlendMode.NORMAL:
                        layer.blend_mode = BlendMode.SCREEN

            Returns
                BlendMode.

        property bottom
            Bottom coordinate.

            Returns
                int

        property clip_layers
            Clip layers associated with this layer.

            To compose clipping layers:

                    from psd_tools import compose
                    clip_mask = compose(layer.clip_layers)

            Returns
                list of layers

        property clipping_layer
            Clipping flag for this layer. Writable.

            Returns
                bool

        compose(force=False, bbox=None, layer_filter=None)
            Deprecated, use composite().

            Compose layer and masks (mask, vector mask, and clipping layers).

            Note that the resulting image size is not necessarily equal to the layer size due to different mask dimensions. The offset of the composed image is stored at .info['offset'] attribute of PIL.Image.

            Parameters
                bbox -- Viewport bounding box specified by (x1, y1, x2, y2) tuple.

            Returns
                PIL.Image, or None if the layer has no pixel.

        composite(viewport=None, force=False, color=1.0, alpha=0.0, layer_filter=None, apply_icc=False)
            Composite layer and masks (mask, vector mask, and clipping layers).

            Parameters

                •   viewport -- Viewport bounding box specified by (x1, y1, x2, y2) tuple. Default is the layer's bbox.

                •   force -- Boolean flag to force vector drawing.

                •   color -- Backdrop color specified by scalar or tuple of scalar. The color value should be in [0.0, 1.0]. For example, (1., 0., 0.) specifies red in RGB color mode.

                •   alpha -- Backdrop alpha in [0.0, 1.0].

                •   layer_filter -- Callable that takes a layer as argument and returns whether if the layer is composited. Default is is_visible().

            Returns
                PIL.Image.

        property effects
            Layer effects.

            Returns
                Effects

        has_clip_layers()
            Returns True if the layer has associated clipping.

            Returns
                bool

        has_effects()
            Returns True if the layer has effects.

            Returns
                bool

        has_mask()
            Returns True if the layer has a mask.

            Returns
                bool

        has_origination()
            Returns True if the layer has live shape properties.

            Returns
                bool

        has_pixels()
            Returns True if the layer has associated pixels. When this is True, topil method returns PIL.Image.

            Returns
                bool

        has_stroke()
            Returns True if the shape has a stroke.

        has_vector_mask()
            Returns True if the layer has a vector mask.

            Returns
                bool

        property height
            Height of the layer.

            Returns
                int

        is_group()
            Return True if the layer is a group.

            Returns
                bool

        is_visible()
            Layer visibility. Takes group visibility in account.

            Returns
                bool

        property kind
            Kind of this layer, such as group, pixel, shape, type, smartobject, or psdimage. Class name without layer suffix.

            Returns
                str

        property layer_id
            Layer ID.

            Returns
                int layer id. if the layer is not assigned an id, -1.

        property left
            Left coordinate. Writable.

            Returns
                int

        property mask
            Returns mask associated with this layer.

            Returns
                Mask or None

        property name
            Layer name. Writable.

            Returns
                str

        numpy(channel=None, real_mask=True)
            Get NumPy array of the layer.

            Parameters
                channel -- Which channel to return, can be 'color', 'shape', 'alpha', or 'mask'. Default is 'color+alpha'.

            Returns
                numpy.ndarray or None if there is no pixel.

        property offset
            (left, top) tuple. Writable.

            Returns
                tuple

        property opacity
            Opacity of this layer in [0, 255] range. Writable.

            Returns
                int

        property origination
            Property for a list of live shapes or a line.

            Some of the vector masks have associated live shape properties, that are Photoshop feature to handle primitive shapes such as a rectangle, an ellipse, or a line. Vector masks without live shape properties are plain path objects.

            See psd_tools.api.shape.

            Returns
                List of Invalidated, Rectangle, RoundedRectangle, Ellipse, or Line.

        property parent
            Parent of this layer.

        property right
            Right coordinate.

            Returns
                int

        property size
            (width, height) tuple.

            Returns
                tuple

        property stroke
            Property for strokes.

        property tagged_blocks
            Layer tagged blocks that is a dict-like container of settings.

            See psd_tools.constants.Tag for available keys.

            Returns
                TaggedBlocks or None.

        Example:

                    from psd_tools.constants import Tag
                    metadata = layer.tagged_blocks.get_data(Tag.METADATA_SETTING)

        property top
            Top coordinate. Writable.

            Returns
                int

        topil(channel=None, apply_icc=False)
            Get PIL Image of the layer.

            Parameters

                •   channel -- Which channel to return; e.g., 0 for 'R' channel in RGB image. See ChannelID. When None, the method returns all the channels supported by PIL modes.

                •   apply_icc -- Whether to apply ICC profile conversion to sRGB.

            Returns
                PIL.Image, or None if the layer has no pixels.

        Example:

                    from psd_tools.constants import ChannelID

                    image = layer.topil()
                    red = layer.topil(ChannelID.CHANNEL_0)
                    alpha = layer.topil(ChannelID.TRANSPARENCY_MASK)

        NOTE:
                Not all of the PSD image modes are supported in PIL.Image. For example, 'CMYK' mode cannot include alpha channel in PIL. In this case, topil drops alpha channel.

        property vector_mask
            Returns vector mask associated with this layer.

            Returns
                VectorMask or None

        property visible
            Layer visibility. Doesn't take group visibility in account. Writable.

            Returns
                bool

        property width
            Width of the layer.

            Returns
                int

  ShapeLayer

    class psd_tools.api.layers.ShapeLayer(psd, record, channels, parent)
        Layer that has drawing in vector mask.

        property bbox
            (left, top, right, bottom) tuple.

        property blend_mode
            Blend mode of this layer. Writable.

            Example:

                    from psd_tools.constants import BlendMode
                    if layer.blend_mode == BlendMode.NORMAL:
                        layer.blend_mode = BlendMode.SCREEN

            Returns
                BlendMode.

        property bottom
            Bottom coordinate.

            Returns
                int

        property clip_layers
            Clip layers associated with this layer.

            To compose clipping layers:

                    from psd_tools import compose
                    clip_mask = compose(layer.clip_layers)

            Returns
                list of layers

        property clipping_layer
            Clipping flag for this layer. Writable.

            Returns
                bool

        compose(force=False, bbox=None, layer_filter=None)
            Deprecated, use composite().

            Compose layer and masks (mask, vector mask, and clipping layers).

            Note that the resulting image size is not necessarily equal to the layer size due to different mask dimensions. The offset of the composed image is stored at .info['offset'] attribute of PIL.Image.

            Parameters
                bbox -- Viewport bounding box specified by (x1, y1, x2, y2) tuple.

            Returns
                PIL.Image, or None if the layer has no pixel.

        composite(viewport=None, force=False, color=1.0, alpha=0.0, layer_filter=None, apply_icc=False)
            Composite layer and masks (mask, vector mask, and clipping layers).

            Parameters

                •   viewport -- Viewport bounding box specified by (x1, y1, x2, y2) tuple. Default is the layer's bbox.

                •   force -- Boolean flag to force vector drawing.

                •   color -- Backdrop color specified by scalar or tuple of scalar. The color value should be in [0.0, 1.0]. For example, (1., 0., 0.) specifies red in RGB color mode.

                •   alpha -- Backdrop alpha in [0.0, 1.0].

                •   layer_filter -- Callable that takes a layer as argument and returns whether if the layer is composited. Default is is_visible().

            Returns
                PIL.Image.

        property effects
            Layer effects.

            Returns
                Effects

        has_clip_layers()
            Returns True if the layer has associated clipping.

            Returns
                bool

        has_effects()
            Returns True if the layer has effects.

            Returns
                bool

        has_mask()
            Returns True if the layer has a mask.

            Returns
                bool

        has_origination()
            Returns True if the layer has live shape properties.

            Returns
                bool

        has_pixels()
            Returns True if the layer has associated pixels. When this is True, topil method returns PIL.Image.

            Returns
                bool

        has_stroke()
            Returns True if the shape has a stroke.

        has_vector_mask()
            Returns True if the layer has a vector mask.

            Returns
                bool

        property height
            Height of the layer.

            Returns
                int

        is_group()
            Return True if the layer is a group.

            Returns
                bool

        is_visible()
            Layer visibility. Takes group visibility in account.

            Returns
                bool

        property kind
            Kind of this layer, such as group, pixel, shape, type, smartobject, or psdimage. Class name without layer suffix.

            Returns
                str

        property layer_id
            Layer ID.

            Returns
                int layer id. if the layer is not assigned an id, -1.

        property left
            Left coordinate. Writable.

            Returns
                int

        property mask
            Returns mask associated with this layer.

            Returns
                Mask or None

        property name
            Layer name. Writable.

            Returns
                str

        numpy(channel=None, real_mask=True)
            Get NumPy array of the layer.

            Parameters
                channel -- Which channel to return, can be 'color', 'shape', 'alpha', or 'mask'. Default is 'color+alpha'.

            Returns
                numpy.ndarray or None if there is no pixel.

        property offset
            (left, top) tuple. Writable.

            Returns
                tuple

        property opacity
            Opacity of this layer in [0, 255] range. Writable.

            Returns
                int

        property origination
            Property for a list of live shapes or a line.

            Some of the vector masks have associated live shape properties, that are Photoshop feature to handle primitive shapes such as a rectangle, an ellipse, or a line. Vector masks without live shape properties are plain path objects.

            See psd_tools.api.shape.

            Returns
                List of Invalidated, Rectangle, RoundedRectangle, Ellipse, or Line.

        property parent
            Parent of this layer.

        property right
            Right coordinate.

            Returns
                int

        property size
            (width, height) tuple.

            Returns
                tuple

        property stroke
            Property for strokes.

        property tagged_blocks
            Layer tagged blocks that is a dict-like container of settings.

            See psd_tools.constants.Tag for available keys.

            Returns
                TaggedBlocks or None.

        Example:

                    from psd_tools.constants import Tag
                    metadata = layer.tagged_blocks.get_data(Tag.METADATA_SETTING)

        property top
            Top coordinate. Writable.

            Returns
                int

        topil(channel=None, apply_icc=False)
            Get PIL Image of the layer.

            Parameters

                •   channel -- Which channel to return; e.g., 0 for 'R' channel in RGB image. See ChannelID. When None, the method returns all the channels supported by PIL modes.

                •   apply_icc -- Whether to apply ICC profile conversion to sRGB.

            Returns
                PIL.Image, or None if the layer has no pixels.

        Example:

                    from psd_tools.constants import ChannelID

                    image = layer.topil()
                    red = layer.topil(ChannelID.CHANNEL_0)
                    alpha = layer.topil(ChannelID.TRANSPARENCY_MASK)

        NOTE:
                Not all of the PSD image modes are supported in PIL.Image. For example, 'CMYK' mode cannot include alpha channel in PIL. In this case, topil drops alpha channel.

        property vector_mask
            Returns vector mask associated with this layer.

            Returns
                VectorMask or None

        property visible
            Layer visibility. Doesn't take group visibility in account. Writable.

            Returns
                bool

        property width
            Width of the layer.

            Returns
                int

  SmartObjectLayer

    class psd_tools.api.layers.SmartObjectLayer(psd, record, channels, parent)
        Layer that inserts external data.

        Use smart_object attribute to get the external data. See SmartObject.

        Example:

                import io
                if layer.smart_object.filetype == 'jpg':
                    image = Image.open(io.BytesIO(layer.smart_object.data))

        property bbox
            (left, top, right, bottom) tuple.

        property blend_mode
            Blend mode of this layer. Writable.

            Example:

                    from psd_tools.constants import BlendMode
                    if layer.blend_mode == BlendMode.NORMAL:
                        layer.blend_mode = BlendMode.SCREEN

            Returns
                BlendMode.

        property bottom
            Bottom coordinate.

            Returns
                int

        property clip_layers
            Clip layers associated with this layer.

            To compose clipping layers:

                    from psd_tools import compose
                    clip_mask = compose(layer.clip_layers)

            Returns
                list of layers

        property clipping_layer
            Clipping flag for this layer. Writable.

            Returns
                bool

        compose(force=False, bbox=None, layer_filter=None)
            Deprecated, use composite().

            Compose layer and masks (mask, vector mask, and clipping layers).

            Note that the resulting image size is not necessarily equal to the layer size due to different mask dimensions. The offset of the composed image is stored at .info['offset'] attribute of PIL.Image.

            Parameters
                bbox -- Viewport bounding box specified by (x1, y1, x2, y2) tuple.

            Returns
                PIL.Image, or None if the layer has no pixel.

        composite(viewport=None, force=False, color=1.0, alpha=0.0, layer_filter=None, apply_icc=False)
            Composite layer and masks (mask, vector mask, and clipping layers).

            Parameters

                •   viewport -- Viewport bounding box specified by (x1, y1, x2, y2) tuple. Default is the layer's bbox.

                •   force -- Boolean flag to force vector drawing.

                •   color -- Backdrop color specified by scalar or tuple of scalar. The color value should be in [0.0, 1.0]. For example, (1., 0., 0.) specifies red in RGB color mode.

                •   alpha -- Backdrop alpha in [0.0, 1.0].

                •   layer_filter -- Callable that takes a layer as argument and returns whether if the layer is composited. Default is is_visible().

            Returns
                PIL.Image.

        property effects
            Layer effects.

            Returns
                Effects

        has_clip_layers()
            Returns True if the layer has associated clipping.

            Returns
                bool

        has_effects()
            Returns True if the layer has effects.

            Returns
                bool

        has_mask()
            Returns True if the layer has a mask.

            Returns
                bool

        has_origination()
            Returns True if the layer has live shape properties.

            Returns
                bool

        has_pixels()
            Returns True if the layer has associated pixels. When this is True, topil method returns PIL.Image.

            Returns
                bool

        has_stroke()
            Returns True if the shape has a stroke.

        has_vector_mask()
            Returns True if the layer has a vector mask.

            Returns
                bool

        property height
            Height of the layer.

            Returns
                int

        is_group()
            Return True if the layer is a group.

            Returns
                bool

        is_visible()
            Layer visibility. Takes group visibility in account.

            Returns
                bool

        property kind
            Kind of this layer, such as group, pixel, shape, type, smartobject, or psdimage. Class name without layer suffix.

            Returns
                str

        property layer_id
            Layer ID.

            Returns
                int layer id. if the layer is not assigned an id, -1.

        property left
            Left coordinate. Writable.

            Returns
                int

        property mask
            Returns mask associated with this layer.

            Returns
                Mask or None

        property name
            Layer name. Writable.

            Returns
                str

        numpy(channel=None, real_mask=True)
            Get NumPy array of the layer.

            Parameters
                channel -- Which channel to return, can be 'color', 'shape', 'alpha', or 'mask'. Default is 'color+alpha'.

            Returns
                numpy.ndarray or None if there is no pixel.

        property offset
            (left, top) tuple. Writable.

            Returns
                tuple

        property opacity
            Opacity of this layer in [0, 255] range. Writable.

            Returns
                int

        property origination
            Property for a list of live shapes or a line.

            Some of the vector masks have associated live shape properties, that are Photoshop feature to handle primitive shapes such as a rectangle, an ellipse, or a line. Vector masks without live shape properties are plain path objects.

            See psd_tools.api.shape.

            Returns
                List of Invalidated, Rectangle, RoundedRectangle, Ellipse, or Line.

        property parent
            Parent of this layer.

        property right
            Right coordinate.

            Returns
                int

        property size
            (width, height) tuple.

            Returns
                tuple

        property smart_object
            Associated smart object.

            Returns
                SmartObject.

        property stroke
            Property for strokes.

        property tagged_blocks
            Layer tagged blocks that is a dict-like container of settings.

            See psd_tools.constants.Tag for available keys.

            Returns
                TaggedBlocks or None.

        Example:

                    from psd_tools.constants import Tag
                    metadata = layer.tagged_blocks.get_data(Tag.METADATA_SETTING)

        property top
            Top coordinate. Writable.

            Returns
                int

        topil(channel=None, apply_icc=False)
            Get PIL Image of the layer.

            Parameters

                •   channel -- Which channel to return; e.g., 0 for 'R' channel in RGB image. See ChannelID. When None, the method returns all the channels supported by PIL modes.

                •   apply_icc -- Whether to apply ICC profile conversion to sRGB.

            Returns
                PIL.Image, or None if the layer has no pixels.

        Example:

                    from psd_tools.constants import ChannelID

                    image = layer.topil()
                    red = layer.topil(ChannelID.CHANNEL_0)
                    alpha = layer.topil(ChannelID.TRANSPARENCY_MASK)

        NOTE:
                Not all of the PSD image modes are supported in PIL.Image. For example, 'CMYK' mode cannot include alpha channel in PIL. In this case, topil drops alpha channel.

        property vector_mask
            Returns vector mask associated with this layer.

            Returns
                VectorMask or None

        property visible
            Layer visibility. Doesn't take group visibility in account. Writable.

            Returns
                bool

        property width
            Width of the layer.

            Returns
                int

  TypeLayer

    class psd_tools.api.layers.TypeLayer(*args)
        Layer that has text and styling information for fonts or paragraphs.

        Text is accessible at text property. Styling information for paragraphs is in engine_dict. Document styling information such as font list is is resource_dict.

        Currently, textual information is read-only.

        Example:

                if layer.kind == 'type':
                    print(layer.text)
                    print(layer.engine_dict['StyleRun'])

                    # Extract font for each substring in the text.
                    text = layer.engine_dict['Editor']['Text'].value
                    fontset = layer.resource_dict['FontSet']
                    runlength = layer.engine_dict['StyleRun']['RunLengthArray']
                    rundata = layer.engine_dict['StyleRun']['RunArray']
                    index = 0
                    for length, style in zip(runlength, rundata):
                        substring = text[index:index + length]
                        stylesheet = style['StyleSheet']['StyleSheetData']
                        font = fontset[stylesheet['Font']]
                        print('%r gets %s' % (substring, font))
                        index += length

        property bbox
            (left, top, right, bottom) tuple.

        property blend_mode
            Blend mode of this layer. Writable.

            Example:

                    from psd_tools.constants import BlendMode
                    if layer.blend_mode == BlendMode.NORMAL:
                        layer.blend_mode = BlendMode.SCREEN

            Returns
                BlendMode.

        property bottom
            Bottom coordinate.

            Returns
                int

        property clip_layers
            Clip layers associated with this layer.

            To compose clipping layers:

                    from psd_tools import compose
                    clip_mask = compose(layer.clip_layers)

            Returns
                list of layers

        property clipping_layer
            Clipping flag for this layer. Writable.

            Returns
                bool

        compose(force=False, bbox=None, layer_filter=None)
            Deprecated, use composite().

            Compose layer and masks (mask, vector mask, and clipping layers).

            Note that the resulting image size is not necessarily equal to the layer size due to different mask dimensions. The offset of the composed image is stored at .info['offset'] attribute of PIL.Image.

            Parameters
                bbox -- Viewport bounding box specified by (x1, y1, x2, y2) tuple.

            Returns
                PIL.Image, or None if the layer has no pixel.

        composite(viewport=None, force=False, color=1.0, alpha=0.0, layer_filter=None, apply_icc=False)
            Composite layer and masks (mask, vector mask, and clipping layers).

            Parameters

                •   viewport -- Viewport bounding box specified by (x1, y1, x2, y2) tuple. Default is the layer's bbox.

                •   force -- Boolean flag to force vector drawing.

                •   color -- Backdrop color specified by scalar or tuple of scalar. The color value should be in [0.0, 1.0]. For example, (1., 0., 0.) specifies red in RGB color mode.

                •   alpha -- Backdrop alpha in [0.0, 1.0].

                •   layer_filter -- Callable that takes a layer as argument and returns whether if the layer is composited. Default is is_visible().

            Returns
                PIL.Image.

        property document_resources
            Resource set relevant to the document.

        property effects
            Layer effects.

            Returns
                Effects

        property engine_dict
            Styling information dict.

        has_clip_layers()
            Returns True if the layer has associated clipping.

            Returns
                bool

        has_effects()
            Returns True if the layer has effects.

            Returns
                bool

        has_mask()
            Returns True if the layer has a mask.

            Returns
                bool

        has_origination()
            Returns True if the layer has live shape properties.

            Returns
                bool

        has_pixels()
            Returns True if the layer has associated pixels. When this is True, topil method returns PIL.Image.

            Returns
                bool

        has_stroke()
            Returns True if the shape has a stroke.

        has_vector_mask()
            Returns True if the layer has a vector mask.

            Returns
                bool

        property height
            Height of the layer.

            Returns
                int

        is_group()
            Return True if the layer is a group.

            Returns
                bool

        is_visible()
            Layer visibility. Takes group visibility in account.

            Returns
                bool

        property kind
            Kind of this layer, such as group, pixel, shape, type, smartobject, or psdimage. Class name without layer suffix.

            Returns
                str

        property layer_id
            Layer ID.

            Returns
                int layer id. if the layer is not assigned an id, -1.

        property left
            Left coordinate. Writable.

            Returns
                int

        property mask
            Returns mask associated with this layer.

            Returns
                Mask or None

        property name
            Layer name. Writable.

            Returns
                str

        numpy(channel=None, real_mask=True)
            Get NumPy array of the layer.

            Parameters
                channel -- Which channel to return, can be 'color', 'shape', 'alpha', or 'mask'. Default is 'color+alpha'.

            Returns
                numpy.ndarray or None if there is no pixel.

        property offset
            (left, top) tuple. Writable.

            Returns
                tuple

        property opacity
            Opacity of this layer in [0, 255] range. Writable.

            Returns
                int

        property origination
            Property for a list of live shapes or a line.

            Some of the vector masks have associated live shape properties, that are Photoshop feature to handle primitive shapes such as a rectangle, an ellipse, or a line. Vector masks without live shape properties are plain path objects.

            See psd_tools.api.shape.

            Returns
                List of Invalidated, Rectangle, RoundedRectangle, Ellipse, or Line.

        property parent
            Parent of this layer.

        property resource_dict
            Resource set.

        property right
            Right coordinate.

            Returns
                int

        property size
            (width, height) tuple.

            Returns
                tuple

        property stroke
            Property for strokes.

        property tagged_blocks
            Layer tagged blocks that is a dict-like container of settings.

            See psd_tools.constants.Tag for available keys.

            Returns
                TaggedBlocks or None.

        Example:

                    from psd_tools.constants import Tag
                    metadata = layer.tagged_blocks.get_data(Tag.METADATA_SETTING)

        property text
            Text in the layer. Read-only.

            NOTE:
                New-line character in Photoshop is '\r'.

        property text_type
            Text type. Read-only.

            Returns

                •   psd_tools.constants.TextType.POINT for point type text (also known as character type)

                •   psd_tools.constants.TextType.PARAGRAPH for paragraph type text (also known as area type)

                •   None if text type cannot be determined or information is unavailable

        See psd_tools.constants.TextType.

        property top
            Top coordinate. Writable.

            Returns
                int

        topil(channel=None, apply_icc=False)
            Get PIL Image of the layer.

            Parameters

                •   channel -- Which channel to return; e.g., 0 for 'R' channel in RGB image. See ChannelID. When None, the method returns all the channels supported by PIL modes.

                •   apply_icc -- Whether to apply ICC profile conversion to sRGB.

            Returns
                PIL.Image, or None if the layer has no pixels.

        Example:

                    from psd_tools.constants import ChannelID

                    image = layer.topil()
                    red = layer.topil(ChannelID.CHANNEL_0)
                    alpha = layer.topil(ChannelID.TRANSPARENCY_MASK)

        NOTE:
                Not all of the PSD image modes are supported in PIL.Image. For example, 'CMYK' mode cannot include alpha channel in PIL. In this case, topil drops alpha channel.

        property transform
            Matrix (xx, xy, yx, yy, tx, ty) applies affine transformation.

        property vector_mask
            Returns vector mask associated with this layer.

            Returns
                VectorMask or None

        property visible
            Layer visibility. Doesn't take group visibility in account. Writable.

            Returns
                bool

        property warp
            Warp configuration.

        property width
            Width of the layer.

            Returns
                int

  psd_tools.api.mask

Mask module.

  Mask

    class psd_tools.api.mask.Mask(layer)
        Mask data attached to a layer.

        There are two distinct internal mask data: user mask and vector mask. User mask refers any pixel-based mask whereas vector mask refers a mask from a shape path. Internally, two masks are combined and referred real mask.

        property background_color
            Background color.

        property bbox
            BBox

        property bottom
            Bottom coordinate.

        property disabled
            Disabled.

        property flags
            Flags.

        property height
            Height.

        property left
            Left coordinate.

        property parameters
            Parameters.

        property real_flags
            Real flag.

        property right
            Right coordinate.

        property size
            (Width, Height) tuple.

        property top
            Top coordinate.

        topil(real=True, **kwargs)
            Get PIL Image of the mask.

            Parameters
                real -- When True, returns pixel + vector mask combined.

            Returns
                PIL Image object, or None if the mask is empty.

        property width
            Width.

  psd_tools.api.shape

Shape module.

In PSD/PSB, shapes are all represented as VectorMask in each layer, and optionally there might be Origination object to control live shape properties and Stroke to specify how outline is stylized.

  VectorMask

    class psd_tools.api.shape.VectorMask(data)
        Vector mask data.

        Vector mask is a resolution-independent mask that consists of one or more Path objects. In Photoshop, all the path objects are represented as Bezier curves. Check paths property for how to deal with path objects.

        property bbox
            Bounding box tuple (left, top, right, bottom) in relative coordinates, where top-left corner is (0., 0.) and bottom-right corner is (1., 1.).

            Returns
                tuple

        property clipboard_record
            Clipboard record containing bounding box information.

            Depending on the Photoshop version, this field can be None.

        property disabled
            If the mask is disabled.

        property initial_fill_rule
            Initial fill rule.

            When 0, fill inside of the path. When 1, fill outside of the shape.

            Returns
                int

        property inverted
            Invert the mask.

        property not_linked
            If the knots are not linked.

        property paths
            List of Subpath. Subpath is a list-like structure that contains one or more Knot items. Knot contains relative coordinates of control points for a Bezier curve. index indicates which origination item the subpath belongs, and operation indicates how to combine multiple shape paths.

            In PSD, path fill rule is even-odd.

            Example:

                    for subpath in layer.vector_mask.paths:
                        anchors = [(
                            int(knot.anchor[1] * psd.width),
                            int(knot.anchor[0] * psd.height),
                        ) for knot in subpath]

            Returns
                List of Subpath.

  Stroke

    class psd_tools.api.shape.Stroke(data)
        Stroke contains decorative information for strokes.

        This is a thin wrapper around Descriptor structure. Check _data attribute to get the raw data.

        property blend_mode
            Blend mode.

        property content
            Fill effect.

        property enabled
            If the stroke is enabled.

        property fill_enabled
            If the stroke fill is enabled.

        property line_alignment
            Alignment, one of inner, outer, center.

        property line_cap_type
            Cap type, one of butt, round, square.

        property line_dash_offset
            Line dash offset in float.

            Returns
                float

        property line_dash_set
            Line dash set in list of UnitFloat.

            Returns
                list

        property line_join_type
            Join type, one of miter, round, bevel.

        property line_width
            Stroke width in float.

        property miter_limit
            Miter limit in float.

        property opacity
            Opacity value.

        property stroke_adjust
            Stroke adjust

  Origination

Origination keeps live shape properties for some of the primitive shapes. Origination objects are accessible via origination property of layers. Following primitive shapes are defined: Invalidated, Line, Rectangle, Ellipse, and RoundedRectangle.

  Invalidated

    class psd_tools.api.shape.Invalidated(data)
        Invalidated live shape.

        This equals to a primitive shape that does not provide Live shape properties. Use VectorMask to access shape information instead of this origination object.

        property invalidated

            Returns
                bool

  Line

    class psd_tools.api.shape.Line(data)
        Line live shape.

        property arrow_conc

            Returns
                int

        property arrow_end
            Line arrow end.

            Returns
                bool

        property arrow_length
            Line arrow length.

            Returns
                float

        property arrow_start
            Line arrow start.

            Returns
                bool

        property arrow_width
            Line arrow width.

            Returns
                float

        property bbox
            Bounding box of the live shape.

            Returns
                Descriptor

        property index
            Origination item index.

            Returns
                int

        property invalidated

            Returns
                bool

        property line_end
            Line end.

            Returns
                Descriptor

        property line_start
            Line start.

            Returns
                Descriptor

        property line_weight
            Line weight

            Returns
                float

        property origin_type
            Type of the vector shape.

            •   1: Rectangle

            •   2: RoundedRectangle

            •   4: Line

            •   5: Ellipse

            Returns
                int

        property resolution
            Resolution.

            Returns
                float

  Ellipse

    class psd_tools.api.shape.Ellipse(data)
        Ellipse live shape.

        property bbox
            Bounding box of the live shape.

            Returns
                Descriptor

        property index
            Origination item index.

            Returns
                int

        property invalidated

            Returns
                bool

        property origin_type
            Type of the vector shape.

            •   1: Rectangle

            •   2: RoundedRectangle

            •   4: Line

            •   5: Ellipse

            Returns
                int

        property resolution
            Resolution.

            Returns
                float

  Rectangle

    class psd_tools.api.shape.Rectangle(data)
        Rectangle live shape.

        property bbox
            Bounding box of the live shape.

            Returns
                Descriptor

        property index
            Origination item index.

            Returns
                int

        property invalidated

            Returns
                bool

        property origin_type
            Type of the vector shape.

            •   1: Rectangle

            •   2: RoundedRectangle

            •   4: Line

            •   5: Ellipse

            Returns
                int

        property resolution
            Resolution.

            Returns
                float

  RoundedRectangle

    class psd_tools.api.shape.RoundedRectangle(data)
        Rounded rectangle live shape.

        property bbox
            Bounding box of the live shape.

            Returns
                Descriptor

        property index
            Origination item index.

            Returns
                int

        property invalidated

            Returns
                bool

        property origin_type
            Type of the vector shape.

            •   1: Rectangle

            •   2: RoundedRectangle

            •   4: Line

            •   5: Ellipse

            Returns
                int

        property radii
            Corner radii of rounded rectangles. The order is top-left, top-right, bottom-left, bottom-right.

            Returns
                Descriptor

        property resolution
            Resolution.

            Returns
                float

  psd_tools.api.smart_object

Smart object module.

  SmartObject

    class psd_tools.api.smart_object.SmartObject(layer)
        Smart object that represents embedded or external file.

        Smart objects are attached to SmartObjectLayer.

        property data
            Embedded file content, or empty if kind is external or alias

        property filename
            Original file name of the object.

        property filesize
            File size of the object.

        property filetype
            Preferred file extension, such as jpg.

        is_psd()
            Return True if the file is embedded PSD/PSB.

        property kind
            Kind of the link, 'data', 'alias', or 'external'.

        open(external_dir=None)
            Open the smart object as binary IO.

            Parameters
                external_dir -- Path to the directory of the external file.

        Example:

                    with layer.smart_object.open() as f:
                        data = f.read()

        property resolution
            Resolution of the object.

        save(filename=None)
            Save the smart object to a file.

            Parameters
                filename -- File name to export. If None, use the embedded name.

        property transform_box
            A tuple representing the coordinates of the smart objects's transformed box. This box is the result of one or more transformations such as scaling, rotation, translation, or skewing to the original bounding box of the smart object.

            The format of the tuple is as follows: (x1, y1, x2, y2, x3, y3, x4, y4)

            Where 1 is top left corner, 2 is top right, 3 is bottom right and 4 is bottom left.

        property unique_id
            UUID of the object.

        property warp
            Warp parameters.

  psd_tools.constants

Various constants for psd_tools

  BlendMode

    class psd_tools.constants.BlendMode(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None)
        Blend modes.

        COLOR = b'colr'

        COLOR_BURN = b'idiv'

        COLOR_DODGE = b'div '

        DARKEN = b'dark'

        DARKER_COLOR = b'dkCl'

        DIFFERENCE = b'diff'

        DISSOLVE = b'diss'

        DIVIDE = b'fdiv'

        EXCLUSION = b'smud'

        HARD_LIGHT = b'hLit'

        HARD_MIX = b'hMix'

        HUE = b'hue '

        LIGHTEN = b'lite'

        LIGHTER_COLOR = b'lgCl'

        LINEAR_BURN = b'lbrn'

        LINEAR_DODGE = b'lddg'

        LINEAR_LIGHT = b'lLit'

        LUMINOSITY = b'lum '

        MULTIPLY = b'mul '

        NORMAL = b'norm'

        OVERLAY = b'over'

        PASS_THROUGH = b'pass'

        PIN_LIGHT = b'pLit'

        SATURATION = b'sat '

        SCREEN = b'scrn'

        SOFT_LIGHT = b'sLit'

        SUBTRACT = b'fsub'

        VIVID_LIGHT = b'vLit'

  ChannelID

    class psd_tools.constants.ChannelID(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None)
        Channel types.

        CHANNEL_0 = 0

        CHANNEL_1 = 1

        CHANNEL_2 = 2

        CHANNEL_3 = 3

        CHANNEL_4 = 4

        CHANNEL_5 = 5

        CHANNEL_6 = 6

        CHANNEL_7 = 7

        CHANNEL_8 = 8

        CHANNEL_9 = 9

        REAL_USER_LAYER_MASK = -3

        TRANSPARENCY_MASK = -1

        USER_LAYER_MASK = -2

  Clipping

    class psd_tools.constants.Clipping(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None)
        Clipping.

        BASE = 0

        NON_BASE = 1

  ColorMode

    class psd_tools.constants.ColorMode(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None)
        Color mode.

        BITMAP = 0

        CMYK = 4

        DUOTONE = 8

        GRAYSCALE = 1

        INDEXED = 2

        LAB = 9

        MULTICHANNEL = 7

        RGB = 3

        static channels(value, alpha=False)

  ColorSpaceID

    class psd_tools.constants.ColorSpaceID(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None)
        Color space types.

        CMYK = 2

        GRAYSCALE = 8

        HSB = 1

        LAB = 7

        RGB = 0

  Compression

    class psd_tools.constants.Compression(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None)
        Compression modes.

        Compression. 0 = Raw Data, 1 = RLE compressed, 2 = ZIP without prediction, 3 = ZIP with prediction.

        RAW = 0

        RLE = 1

        ZIP = 2

        ZIP_WITH_PREDICTION = 3

  EffectOSType

    class psd_tools.constants.EffectOSType(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None)
        OS Type keys for Layer Effects.

        BEVEL = b'bevl'

        COMMON_STATE = b'cmnS'

        DROP_SHADOW = b'dsdw'

        INNER_GLOW = b'iglw'

        INNER_SHADOW = b'isdw'

        OUTER_GLOW = b'oglw'

        SOLID_FILL = b'sofi'

  GlobalLayerMaskKind

    class psd_tools.constants.GlobalLayerMaskKind(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None)
        Global layer mask kind.

        COLOR_PROTECTED = 1

        COLOR_SELECTED = 0

        PER_LAYER = 128

  LinkedLayerType

    class psd_tools.constants.LinkedLayerType(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None)
        Linked layer types.

        ALIAS = b'liFA'

        DATA = b'liFD'

        EXTERNAL = b'liFE'

  PathResourceID

    class psd_tools.constants.PathResourceID(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None)

        CLIPBOARD = 7

        CLOSED_KNOT_LINKED = 1

        CLOSED_KNOT_UNLINKED = 2

        CLOSED_LENGTH = 0

        INITIAL_FILL = 8

        OPEN_KNOT_LINKED = 4

        OPEN_KNOT_UNLINKED = 5

        OPEN_LENGTH = 3

        PATH_FILL = 6

  PlacedLayerType

    class psd_tools.constants.PlacedLayerType(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None)

        IMAGE_STACK = 3

        RASTER = 2

        UNKNOWN = 0

        VECTOR = 1

  PrintScaleStyle

    class psd_tools.constants.PrintScaleStyle(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None)
        Print scale style.

        CENTERED = 0

        SIZE_TO_FIT = 1

        USER_DEFINED = 2

  Resource

    class psd_tools.constants.Resource(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None)
        Image resource keys.

        Note the following is not defined for performance reasons.

                •   PATH_INFO_10 to PATH_INFO_989 corresponding to 2010 - 2989

                •

                    PLUGIN_RESOURCES_10 to PLUGIN_RESOURCES_989 corresponding to
                        4010 - 4989

        ALPHA_IDENTIFIERS = 1053

        ALPHA_NAMES_PASCAL = 1006

        ALPHA_NAMES_UNICODE = 1045

        ALTERNATE_DUOTONE_COLORS = 1066

        ALTERNATE_SPOT_COLORS = 1067

        AUTO_SAVE_FILE_PATH = 1086

        AUTO_SAVE_FORMAT = 1087

        BACKGROUND_COLOR = 1010

        BORDER_INFO = 1009

        CAPTION_DIGEST = 1061

        CAPTION_PASCAL = 1008

        CLIPPING_PATH_NAME = 2999

        COLOR_HALFTONING_INFO = 1013

        COLOR_SAMPLERS_RESOURCE = 1073

        COLOR_SAMPLERS_RESOURCE_OBSOLETE = 1038

        COLOR_TRANSFER_FUNCTION = 1016

        COPYRIGHT_FLAG = 1034

        COUNT_INFO = 1080

        DISPLAY_INFO = 1077

        DISPLAY_INFO_OBSOLETE = 1007

        DUOTONE_HALFTONING_INFO = 1014

        DUOTONE_IMAGE_INFO = 1018

        DUOTONE_TRANSFER_FUNCTION = 1017

        EFFECTIVE_BW = 1019

        EFFECTS_VISIBLE = 1042

        EPS_OPTIONS = 1021

        EXIF_DATA_1 = 1058

        EXIF_DATA_3 = 1059

        GLOBAL_ALTITUDE = 1049

        GLOBAL_ANGLE = 1037

        GRAYSCALE_HALFTONING_INFO = 1012

        GRAYSCALE_TRANSFER_FUNCTION = 1015

        GRID_AND_GUIDES_INFO = 1032

        HDR_TONING_INFO = 1070

        ICC_PROFILE = 1039

        ICC_UNTAGGED_PROFILE = 1041

        IDS_SEED_NUMBER = 1044

        IMAGE_MODE_RAW = 1029

        IMAGE_READY_7_ROLLOVER_EXPANDED_STATE = 7003

        IMAGE_READY_DATA_SETS = 7001

        IMAGE_READY_DEFAULT_SELECTED_STATE = 7002

        IMAGE_READY_ROLLOVER_EXPANDED_STATE = 7004

        IMAGE_READY_SAVE_LAYER_SETTINGS = 7005

        IMAGE_READY_VARIABLES = 7000

        IMAGE_READY_VERSION = 7006

        INDEXED_COLOR_TABLE_COUNT = 1046

        IPTC_NAA = 1028

        JPEG_QUALITY = 1030

        JUMP_TO_XPEP = 1052

        LAYER_COMPS = 1065

        LAYER_GROUPS_ENABLED_ID = 1072

        LAYER_GROUP_INFO = 1026

        LAYER_SELECTION_IDS = 1069

        LAYER_STATE_INFO = 1024

        LIGHTROOM_WORKFLOW = 8000

        MAC_NSPRINTINFO = 1084

        MAC_PAGE_FORMAT_INFO = 1002

        MAC_PRINT_MANAGER_INFO = 1001

        MEASUREMENT_SCALE = 1074

        OBSOLETE1 = 1000

        OBSOLETE2 = 1003

        OBSOLETE3 = 1020

        OBSOLETE4 = 1023

        OBSOLETE5 = 1027

        ONION_SKINS = 1078

        ORIGIN_PATH_INFO = 3000

        PATH_INFO_0 = 2000

        PATH_INFO_1 = 2001

        PATH_INFO_2 = 2002

        PATH_INFO_3 = 2003

        PATH_INFO_4 = 2004

        PATH_INFO_5 = 2005

        PATH_INFO_6 = 2006

        PATH_INFO_7 = 2007

        PATH_INFO_8 = 2008

        PATH_INFO_9 = 2009

        PATH_INFO_990 = 2990

        PATH_INFO_991 = 2991

        PATH_INFO_992 = 2992

        PATH_INFO_993 = 2993

        PATH_INFO_994 = 2994

        PATH_INFO_995 = 2995

        PATH_INFO_996 = 2996

        PATH_INFO_997 = 2997

        PATH_SELECTION_STATE = 1088

        PIXEL_ASPECT_RATIO = 1064

        PLUGIN_RESOURCE_0 = 4000

        PLUGIN_RESOURCE_1 = 4001

        PLUGIN_RESOURCE_2 = 4002

        PLUGIN_RESOURCE_3 = 4003

        PLUGIN_RESOURCE_4 = 4004

        PLUGIN_RESOURCE_4990 = 4990

        PLUGIN_RESOURCE_4991 = 4991

        PLUGIN_RESOURCE_4992 = 4992

        PLUGIN_RESOURCE_4993 = 4993

        PLUGIN_RESOURCE_4994 = 4994

        PLUGIN_RESOURCE_4995 = 4995

        PLUGIN_RESOURCE_4996 = 4996

        PLUGIN_RESOURCE_4997 = 4997

        PLUGIN_RESOURCE_4998 = 4998

        PLUGIN_RESOURCE_4999 = 4990

        PLUGIN_RESOURCE_5 = 4005

        PLUGIN_RESOURCE_6 = 4006

        PLUGIN_RESOURCE_7 = 4007

        PLUGIN_RESOURCE_8 = 4008

        PLUGIN_RESOURCE_9 = 4009

        PRINT_FLAGS = 1011

        PRINT_FLAGS_INFO = 10000

        PRINT_INFO_CS2 = 1071

        PRINT_INFO_CS5 = 1082

        PRINT_SCALE = 1062

        PRINT_STYLE = 1083

        QUICK_MASK_INFO = 1022

        RESOLUTION_INFO = 1005

        SHEET_DISCLOSURE = 1076

        SLICES = 1050

        SPOT_HALFTONE = 1043

        THUMBNAIL_RESOURCE = 1036

        THUMBNAIL_RESOURCE_PS4 = 1033

        TIMELINE_INFO = 1075

        TRANSPARENCY_INDEX = 1047

        URL = 1035

        URL_LIST = 1054

        VERSION_INFO = 1057

        WATERMARK = 1040

        WINDOWS_DEVMODE = 1085

        WORKFLOW_URL = 1051

        WORKING_PATH = 1025

        XMP_METADATA = 1060

        static is_path_info(value)

        static is_plugin_resource(value)

  SectionDivider

    class psd_tools.constants.SectionDivider(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None)

        BOUNDING_SECTION_DIVIDER = 3

        CLOSED_FOLDER = 2

        OPEN_FOLDER = 1

        OTHER = 0

  Tag

    class psd_tools.constants.Tag(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None)
        Tagged blocks keys.

        ALPHA = b'Alph'

        ANIMATION_EFFECTS = b'anFX'

        ANNOTATIONS = b'Anno'

        ARTBOARD_DATA1 = b'artb'

        ARTBOARD_DATA2 = b'artd'

        ARTBOARD_DATA3 = b'abdd'

        BLACK_AND_WHITE = b'blwh'

        BLEND_CLIPPING_ELEMENTS = b'clbl'

        BLEND_FILL_OPACITY = b'iOpa'

        BLEND_INTERIOR_ELEMENTS = b'infx'

        BRIGHTNESS_AND_CONTRAST = b'brit'

        CHANNEL_BLENDING_RESTRICTIONS_SETTING = b'brst'

        CHANNEL_MIXER = b'mixr'

        COLOR_BALANCE = b'blnc'

        COLOR_LOOKUP = b'clrL'

        COMPOSITOR_INFO = b'cinf'

        CONTENT_GENERATOR_EXTRA_DATA = b'CgEd'

        CURVES = b'curv'

        EFFECTS_LAYER = b'lrFX'

        EXPORT_SETTING1 = b'extd'

        EXPORT_SETTING2 = b'extn'

        EXPOSURE = b'expA'

        FILTER_EFFECTS1 = b'FXid'

        FILTER_EFFECTS2 = b'FEid'

        FILTER_EFFECTS3 = b'FELS'

        FILTER_MASK = b'FMsk'

        FOREIGN_EFFECT_ID = b'ffxi'

        FRAMED_GROUP = b'frgb'

        GRADIENT_FILL_SETTING = b'GdFl'

        GRADIENT_MAP = b'grdm'

        HUE_SATURATION = b'hue2'

        HUE_SATURATION_V4 = b'hue '

        INVERT = b'nvrt'

        KNOCKOUT_SETTING = b'knko'

        LAYER = b'Layr'

        LAYER_16 = b'Lr16'

        LAYER_32 = b'Lr32'

        LAYER_ID = b'lyid'

        LAYER_MASK_AS_GLOBAL_MASK = b'lmgm'

        LAYER_NAME_SOURCE_SETTING = b'lnsr'

        LAYER_VERSION = b'lyvr'

        LEVELS = b'levl'

        LINKED_LAYER1 = b'lnkD'

        LINKED_LAYER2 = b'lnk2'

        LINKED_LAYER3 = b'lnk3'

        LINKED_LAYER_EXTERNAL = b'lnkE'

        METADATA_SETTING = b'shmd'

        NESTED_SECTION_DIVIDER_SETTING = b'lsdk'

        OBJECT_BASED_EFFECTS_LAYER_INFO = b'lfx2'

        OBJECT_BASED_EFFECTS_LAYER_INFO_V0 = b'lmfx'

        OBJECT_BASED_EFFECTS_LAYER_INFO_V1 = b'lfxs'

        PATT = b'patt'

        PATTERNS1 = b'Patt'

        PATTERNS2 = b'Pat2'

        PATTERNS3 = b'Pat3'

        PATTERN_DATA = b'shpa'

        PATTERN_FILL_SETTING = b'PtFl'

        PHOTO_FILTER = b'phfl'

        PIXEL_SOURCE_DATA1 = b'PxSc'

        PIXEL_SOURCE_DATA2 = b'PxSD'

        PLACED_LAYER1 = b'plLd'

        PLACED_LAYER2 = b'PlLd'

        POSTERIZE = b'post'

        PROTECTED_SETTING = b'lspf'

        REFERENCE_POINT = b'fxrp'

        SAVING_MERGED_TRANSPARENCY = b'Mtrn'

        SAVING_MERGED_TRANSPARENCY16 = b'Mt16'

        SAVING_MERGED_TRANSPARENCY32 = b'Mt32'

        SECTION_DIVIDER_SETTING = b'lsct'

        SELECTIVE_COLOR = b'selc'

        SHEET_COLOR_SETTING = b'lclr'

        SMART_OBJECT_LAYER_DATA1 = b'SoLd'

        SMART_OBJECT_LAYER_DATA2 = b'SoLE'

        SOLID_COLOR_SHEET_SETTING = b'SoCo'

        TEXT_ENGINE_DATA = b'Txt2'

        THRESHOLD = b'thrs'

        TRANSPARENCY_SHAPES_LAYER = b'tsly'

        TYPE_TOOL_INFO = b'tySh'

        TYPE_TOOL_OBJECT_SETTING = b'TySh'

        UNICODE_LAYER_NAME = b'luni'

        UNICODE_PATH_NAME = b'pths'

        USER_MASK = b'LMsk'

        USING_ALIGNED_RENDERING = b'sn2P'

        VECTOR_MASK_AS_GLOBAL_MASK = b'vmgm'

        VECTOR_MASK_SETTING1 = b'vmsk'

        VECTOR_MASK_SETTING2 = b'vsms'

        VECTOR_ORIGINATION_DATA = b'vogk'

        VECTOR_ORIGINATION_UNKNOWN = b'vowv'

        VECTOR_STROKE_CONTENT_DATA = b'vscg'

        VECTOR_STROKE_DATA = b'vstk'

        VIBRANCE = b'vibA'

  TextType

    class psd_tools.constants.TextType(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None)
        Type of text

        PARAGRAPH = 1

        POINT = 0

  psd_tools.psd

Low-level API that translates binary data to Python structure.

All the data structure in this subpackage inherits from one of the object defined in psd_tools.psd.base module.

  PSD

    class psd_tools.psd.PSD(header=NOTHING, color_mode_data=NOTHING, image_resources=NOTHING, layer_and_mask_information=NOTHING, image_data=NOTHING)
        Low-level PSD file structure that resembles the specification.

        Example:

                from psd_tools.psd import PSD

                with open(input_file, 'rb') as f:
                    psd = PSD.read(f)

                with open(output_file, 'wb') as f:
                    psd.write(f)

        header
            See FileHeader.

        color_mode_data
            See ColorModeData.

        image_resources
            See ImageResources.

        layer_and_mask_information
            See LayerAndMaskInformation.

        image_data
            See ImageData.

  psd_tools.psd.base

Base data structures intended for inheritance.

All the data objects in this subpackage inherit from the base classes here. That means, all the data structures in the psd_tools.psd subpackage implements the methods of BaseElement for serialization and decoding.

Objects that inherit from the BaseElement typically gets attrs decoration to have data fields.

  BaseElement

    class psd_tools.psd.base.BaseElement
        Base element of various PSD file structs. All the data objects in psd_tools.psd subpackage inherit from this class.

        classmethod read(cls, fp)
            Read the element from a file-like object.

        write(self, fp)
            Write the element to a file-like object.

        classmethod frombytes(self, data, *args, **kwargs)
            Read the element from bytes.

        tobytes(self, *args, **kwargs)
            Write the element to bytes.

        validate(self)
            Validate the attribute.

  EmptyElement

    class psd_tools.psd.base.EmptyElement
        Empty element that does not have a value.

  ValueElement

    class psd_tools.psd.base.ValueElement(value=None)
        Single value wrapper that has a value attribute.

        Pretty printing shows the internal value by default. Inherit with @attr.s(repr=False) decorator to keep this behavior.

        value
            Internal value.

  NumericElement

    class psd_tools.psd.base.NumericElement(value=0.0)
        Single value element that has a numeric value attribute.

  IntegerElement

    class psd_tools.psd.base.IntegerElement(value=0)
        Single integer value element that has a value attribute.

        Use with @attr.s(repr=False) decorator.

  ShortIntegerElement

    class psd_tools.psd.base.ShortIntegerElement(value=0)
        Single short integer element that has a value attribute.

        Use with @attr.s(repr=False) decorator.

  ByteElement

    class psd_tools.psd.base.ByteElement(value=0)
        Single 1-byte integer element that has a value attribute.

        Use with @attr.s(repr=False) decorator.

  BooleanElement

    class psd_tools.psd.base.BooleanElement(value=False)
        Single bool value element that has a value attribute.

        Use with @attr.s(repr=False) decorator.

  StringElement

    class psd_tools.psd.base.StringElement(value: str = '')
        Single unicode string.

        value
            str value

  ListElement

    class psd_tools.psd.base.ListElement(items=NOTHING)
        List-like element that has items list.

  DictElement

    class psd_tools.psd.base.DictElement(items=NOTHING)
        Dict-like element that has items OrderedDict.

  psd_tools.psd.color_mode_data

Color mode data structure.

  ColorModeData

    class psd_tools.psd.color_mode_data.ColorModeData(value: bytes = b'')
        Color mode data section of the PSD file.

        For indexed color images the data is the color table for the image in a non-interleaved order.

        Duotone images also have this data, but the data format is undocumented.

        interleave()
            Returns interleaved color table in bytes.

  psd_tools.psd.descriptor

Descriptor data structure.

Descriptors are basic data structure used throughout PSD files. Descriptor is one kind of serialization protocol for data objects, and enum classes in psd_tools.terminology or bytes indicates what kind of descriptor it is.

The class ID can be pre-defined enum if the tag is 4-byte length or plain bytes if the length is arbitrary. They depend on the internal version of Adobe Photoshop but the detail is unknown.

Pretty printing is the best approach to check the descriptor content:

            from IPython.pretty import pprint
            pprint(descriptor)

  Alias

    class psd_tools.psd.descriptor.Alias(value: bytes = b'\x00\x00\x00\x00')
        Alias structure equivalent to RawData.

  Bool

    class psd_tools.psd.descriptor.Bool(value=False)
        Bool structure.

        value
            bool value

  Class

    class psd_tools.psd.descriptor.Class(name: str = '', classID: bytes = b'\x00\x00\x00\x00')
        Class structure.

        name
            str value

        classID
            bytes in Klass

  Class1

    class psd_tools.psd.descriptor.Class1(name: str = '', classID: bytes = b'\x00\x00\x00\x00')
        Class structure equivalent to Class.

  Class2

    class psd_tools.psd.descriptor.Class2(name: str = '', classID: bytes = b'\x00\x00\x00\x00')
        Class structure equivalent to Class.

  Class3

    class psd_tools.psd.descriptor.Class3(name: str = '', classID: bytes = b'\x00\x00\x00\x00')
        Class structure equivalent to Class.

  Descriptor

    class psd_tools.psd.descriptor.Descriptor(items=NOTHING, name: str = '', classID=b'null')
        Dict-like descriptor structure.

        Key values can be 4-character bytes in Key or arbitrary length bytes. Supports direct access by Key.

        Example:

                from psd_tools.terminology import Key

                descriptor[Key.Enabled]

                for key in descriptor:
                    print(descriptor[key])

        name
            str

        classID
            bytes in Klass

  Double

    class psd_tools.psd.descriptor.Double(value=0.0)
        Double structure.

        value
            float value

  Enumerated

    class psd_tools.psd.descriptor.Enumerated(typeID: bytes = b'\x00\x00\x00\x00', enum: bytes = b'\x00\x00\x00\x00')
        Enum structure.

        typeID
            bytes in Type

        enum
            bytes in Enum

        get_name()
            Get enum name.

  EnumeratedReference

    class psd_tools.psd.descriptor.EnumeratedReference(name: str = '', classID: bytes = b'\x00\x00\x00\x00', typeID: bytes = b'\x00\x00\x00\x00', enum: bytes = b'\x00\x00\x00\x00')
        Enumerated reference structure.

        name
            str value

        classID
            bytes in Klass

        typeID
            bytes in Type

        enum
            bytes in Enum

  GlobalObject

    class psd_tools.psd.descriptor.GlobalObject(items=NOTHING, name: str = '', classID=b'null')
        Global object structure equivalent to Descriptor.

  Identifier

    class psd_tools.psd.descriptor.Identifier(value=0)
        Identifier equivalent to Integer.

  Index

    class psd_tools.psd.descriptor.Index(value=0)
        Index equivalent to Integer.

  Integer

    class psd_tools.psd.descriptor.Integer(value=0)
        Integer structure.

        value
            int value

  LargeInteger

    class psd_tools.psd.descriptor.LargeInteger(value=0)
        LargeInteger structure.

        value
            int value

  List

    class psd_tools.psd.descriptor.List(items=NOTHING)
        List structure.

        Example:

                for item in list_value:
                    print(item)

  Name

    class psd_tools.psd.descriptor.Name(name: str = '', classID: bytes = b'\x00\x00\x00\x00', value: str = '')
        Name structure (Undocumented).

        name
            str

        classID
            bytes in Klass

        value
            str

  ObjectArray

    class psd_tools.psd.descriptor.ObjectArray(items=NOTHING, items_count: int = 0, name: str = '', classID=b'null')
        Object array structure almost equivalent to Descriptor.

        items_count
            int value

        name
            str value

        classID
            bytes in Klass

  Property

    class psd_tools.psd.descriptor.Property(name: str = '', classID: bytes = b'\x00\x00\x00\x00', keyID: bytes = b'\x00\x00\x00\x00')
        Property structure.

        name
            str value

        classID
            bytes in Klass

        keyID
            bytes in Key

  Offset

    class psd_tools.psd.descriptor.Offset(name: str = '', classID: bytes = b'\x00\x00\x00\x00', value=0)
        Offset structure.

        name
            str value

        classID
            bytes in Klass

        value
            int value

  Path

    class psd_tools.psd.descriptor.Path(value: bytes = b'\x00\x00\x00\x00')
        Undocumented path structure equivalent to RawData.

  RawData

    class psd_tools.psd.descriptor.RawData(value: bytes = b'\x00\x00\x00\x00')
        RawData structure.

        value
            bytes value

  Reference

    class psd_tools.psd.descriptor.Reference(items=NOTHING)
        Reference structure equivalent to List.

  String

    class psd_tools.psd.descriptor.String(value: str = '')
        String structure.

        value
            str value

  UnitFloat

    class psd_tools.psd.descriptor.UnitFloat(value: float = 0.0, unit=Unit._None)
        Unit float structure.

        unit
            unit of the value in Unit or Enum

        value
            float value

  UnitFloats

    class psd_tools.psd.descriptor.UnitFloats(unit=Unit._None, values=NOTHING)
        Unit floats structure.

        unit
            unit of the value in Unit or Enum

        values
            List of float values

  psd_tools.psd.engine_data

EngineData structure.

PSD file embeds text formatting data in its own markup language referred EngineData. The format looks like the following:

            <<
              /EngineDict
              <<
                /Editor
                <<
                  /Text (˛ˇMake a change and save.)
                >>
              >>
              /Font
              <<
                /Name (˛ˇHelveticaNeue-Light)
                /FillColor
                <<
                  /Type 1
                  /Values [ 1.0 0.0 0.0 0.0 ]
                >>
                /StyleSheetSet [
                <<
                  /Name (˛ˇNormal RGB)
                >>
                ]
              >>
            >>

  EngineData

    class psd_tools.psd.engine_data.EngineData(items=NOTHING)
        Dict-like element.

        TYPE_TOOL_OBJECT_SETTING tagged block contains this object in its descriptor.

  EngineData2

    class psd_tools.psd.engine_data.EngineData2(items=NOTHING)
        Dict-like element.

        TEXT_ENGINE_DATA tagged block has this object.

  Bool

    class psd_tools.psd.engine_data.Bool(value=False)
        Bool element.

  Dict

    class psd_tools.psd.engine_data.Dict(items=NOTHING)
        Dict-like element.

  Float

    class psd_tools.psd.engine_data.Float(value=0.0)
        Float element.

  Integer

    class psd_tools.psd.engine_data.Integer(value=0)
        Integer element.

  List

    class psd_tools.psd.engine_data.List(items=NOTHING)
        List-like element.

  Property

    class psd_tools.psd.engine_data.Property(value=None)
        Property element.

  String

    class psd_tools.psd.engine_data.String(value=None)
        String element.

  psd_tools.psd.effects_layer

Effects layer structure.

Note the structures in this module is obsolete and object-based layer effects are stored in tagged blocks.

  EffectsLayer

    class psd_tools.psd.effects_layer.EffectsLayer(items=NOTHING, version: int = 0)
        Dict-like EffectsLayer structure. See psd_tools.constants.EffectOSType for available keys.

        version

  CommonStateInfo

    class psd_tools.psd.effects_layer.CommonStateInfo(version: int = 0, visible: int = 1)
        Effects layer common state info.

        version

        visible

  ShadowInfo

    class psd_tools.psd.effects_layer.ShadowInfo(version: int = 0, blur: int = 0, intensity: int = 0, angle: int = 0, distance: int = 0, color=NOTHING, blend_mode=BlendMode.NORMAL, enabled: int = 0, use_global_angle: int = 0, opacity: int = 0, native_color=NOTHING)
        Effects layer shadow info.

        version

        blur

        intensity

        angle

        distance

        color

        blend_mode

        enabled

        use_global_angle

        opacity

        native_color

  OuterGlowInfo

    class psd_tools.psd.effects_layer.OuterGlowInfo(version: int = 0, blur: int = 0, intensity: int = 0, color=NOTHING, blend_mode=BlendMode.NORMAL, enabled: int = 0, opacity: int = 0, native_color=None)
        Effects layer outer glow info.

        version

        blur

        intensity

        color

        blend_mode

        enabled

        opacity

        native_color

  InnerGlowInfo

    class psd_tools.psd.effects_layer.InnerGlowInfo(version: int = 0, blur: int = 0, intensity: int = 0, color=NOTHING, blend_mode=BlendMode.NORMAL, enabled: int = 0, opacity: int = 0, invert=None, native_color=None)
        Effects layer inner glow info.

        version

        blur

        intensity

        color

        blend_mode

        enabled

        opacity

        invert

        native_color

  BevelInfo

    class psd_tools.psd.effects_layer.BevelInfo(version: int = 0, angle: int = 0, depth: int = 0, blur: int = 0, highlight_blend_mode=BlendMode.NORMAL, shadow_blend_mode=BlendMode.NORMAL, highlight_color=NOTHING, shadow_color=NOTHING, bevel_style: int = 0, highlight_opacity: int = 0, shadow_opacity: int = 0, enabled: int = 0, use_global_angle: int = 0, direction: int = 0, real_highlight_color=None, real_shadow_color=None)
        Effects layer bevel info.

        version

        angle

        depth

        blur

        highlight_blend_mode

        shadow_blend_mode

        highlight_color

        shadow_color

        highlight_opacity

        shadow_opacity

        enabled

        use_global_angle

        direction

        real_hightlight_color

        real_shadow_color

  SolidFillInfo

    class psd_tools.psd.effects_layer.SolidFillInfo(version: int = 2, blend_mode=BlendMode.NORMAL, color=NOTHING, opacity: int = 0, enabled: int = 0, native_color=NOTHING)
        Effects layer inner glow info.

        version

        blend_mode

        color

        opacity

        enabled

        native_color

  psd_tools.psd.filter_effects

Filter effects structure.

  FilterEffects

    class psd_tools.psd.filter_effects.FilterEffects(items=NOTHING, version: int = 1)
        List-like FilterEffects structure. See FilterEffect.

        version

  FilterEffect

    class psd_tools.psd.filter_effects.FilterEffect(uuid=None, version=None, rectangle=None, depth=None, max_channels=None, channels=None, extra=None)
        FilterEffect structure.

        uuid

        version

        rectangle

        depth

        max_channels

        channels
            List of FilterEffectChannel.

        extra
            See FilterEffectExtra.

  FilterEffectChannel

    class psd_tools.psd.filter_effects.FilterEffectChannel(is_written=0, compression=None, data=b'')
        FilterEffectChannel structure.

        is_written

        compression

        data

  FilterEffectExtra

    class psd_tools.psd.filter_effects.FilterEffectExtra(is_written=0, rectangle=NOTHING, compression: int = 0, data: bytes = b'')
        FilterEffectExtra structure.

        is_written

        rectangle

        compression

        data

  psd_tools.psd.header

File header structure.

  FileHeader

    class psd_tools.psd.header.FileHeader(signature: bytes = b'8BPS', version: int = 1, channels: int = 4, height: int = 64, width: int = 64, depth: int = 8, color_mode=ColorMode.RGB)
        Header section of the PSD file.

        Example:

                from psd_tools.psd.header import FileHeader
                from psd_tools.constants import ColorMode

                header = FileHeader(channels=2, height=359, width=400, depth=8,
                                    color_mode=ColorMode.GRAYSCALE)

        signature
            Signature: always equal to b'8BPS'.

        version
            Version number. PSD is 1, and PSB is 2.

        channels
            The number of channels in the image, including any user-defined alpha channel.

        height
            The height of the image in pixels.

        width
            The width of the image in pixels.

        depth
            The number of bits per channel.

        color_mode
            The color mode of the file. See ColorMode

  psd_tools.psd.image_data

Image data section structure.

ImageData corresponds to the last section of the PSD/PSB file where a composited image is stored. When the file does not contain layers, this is the only place pixels are saved.

  ImageData

    class psd_tools.psd.image_data.ImageData(compression=Compression.RAW, data: bytes = b'')
        Merged channel image data.

        compression
            See Compression.

        data
            bytes as compressed in the compression flag.

        get_data(header, split=True)
            Get decompressed data.

            Parameters
                header -- See FileHeader.

            Returns
                list of bytes corresponding each channel.

        classmethod new(header, color=0, compression=Compression.RAW)
            Create a new image data object.

            Parameters

                •   header -- FileHeader.

                •   compression -- compression type.

                •   color -- default color. int or iterable for channel length.

        set_data(data, header)
            Set raw data and compress.

            Parameters

                •   data -- list of raw data bytes corresponding channels.

                •   compression -- compression type, see Compression.

                •   header -- See FileHeader.

            Returns
                length of compressed data.

  psd_tools.psd.image_resources

Image resources section structure. Image resources are used to store non-pixel data associated with images, such as pen tool paths or slices.

See Resource to check available resource names.

Example:

            from psd_tools.constants import Resource

            version_info = psd.image_resources.get_data(Resource.VERSION_INFO)

The following resources are plain bytes:

            Resource.OBSOLETE1: 1000
            Resource.MAC_PRINT_MANAGER_INFO: 1001
            Resource.MAC_PAGE_FORMAT_INFO: 1002
            Resource.OBSOLETE2: 1003
            Resource.DISPLAY_INFO_OBSOLETE: 1007
            Resource.BORDER_INFO: 1009
            Resource.DUOTONE_IMAGE_INFO: 1018
            Resource.EFFECTIVE_BW: 1019
            Resource.OBSOLETE3: 1020
            Resource.EPS_OPTIONS: 1021
            Resource.QUICK_MASK_INFO: 1022
            Resource.OBSOLETE4: 1023
            Resource.WORKING_PATH: 1025
            Resource.OBSOLETE5: 1027
            Resource.IPTC_NAA: 1028
            Resource.IMAGE_MODE_RAW: 1029
            Resource.JPEG_QUALITY: 1030
            Resource.URL: 1035
            Resource.COLOR_SAMPLERS_RESOURCE_OBSOLETE: 1038
            Resource.ICC_PROFILE: 1039
            Resource.SPOT_HALFTONE: 1043
            Resource.JUMP_TO_XPEP: 1052
            Resource.EXIF_DATA_1: 1058
            Resource.EXIF_DATA_3: 1059
            Resource.XMP_METADATA: 1060
            Resource.CAPTION_DIGEST: 1061
            Resource.ALTERNATE_DUOTONE_COLORS: 1066
            Resource.ALTERNATE_SPOT_COLORS: 1067
            Resource.HDR_TONING_INFO: 1070
            Resource.PRINT_INFO_CS2: 1071
            Resource.COLOR_SAMPLERS_RESOURCE: 1073
            Resource.DISPLAY_INFO: 1077
            Resource.MAC_NSPRINTINFO: 1084
            Resource.WINDOWS_DEVMODE: 1085
            Resource.PATH_INFO_N: 2000-2999
            Resource.PLUGIN_RESOURCES_N: 4000-4999
            Resource.IMAGE_READY_VARIABLES: 7000
            Resource.IMAGE_READY_DATA_SETS: 7001
            Resource.IMAGE_READY_DEFAULT_SELECTED_STATE: 7002
            Resource.IMAGE_READY_7_ROLLOVER_EXPANDED_STATE: 7003
            Resource.IMAGE_READY_ROLLOVER_EXPANDED_STATE: 7004
            Resource.IMAGE_READY_SAVE_LAYER_SETTINGS: 7005
            Resource.IMAGE_READY_VERSION: 7006
            Resource.LIGHTROOM_WORKFLOW: 8000

  ImageResources

    class psd_tools.psd.image_resources.ImageResources(items=NOTHING)
        Image resources section of the PSD file. Dict of ImageResource.

        get_data(key, default=None)
            Get data from the image resources.

            Shortcut for the following:

                    if key in image_resources:
                        value = tagged_blocks[key].data

        classmethod new(**kwargs)
            Create a new default image resouces.

            Returns
                ImageResources

  ImageResource

    class psd_tools.psd.image_resources.ImageResource(signature: bytes = b'8BIM', key: int = 1000, name: str = '', data: bytes = b'')
        Image resource block.

        signature
            Binary signature, always b'8BIM'.

        key Unique identifier for the resource. See Resource.

        name

        data
            The resource data.

  AlphaIdentifiers

    class psd_tools.psd.image_resources.AlphaIdentifiers(items=NOTHING)
        List of alpha identifiers.

  AlphaNamesPascal

    class psd_tools.psd.image_resources.AlphaNamesPascal(items=NOTHING)
        List of alpha names.

  AlphaNamesUnicode

    class psd_tools.psd.image_resources.AlphaNamesUnicode(items=NOTHING)
        List of alpha names.

  Byte

    class psd_tools.psd.image_resources.Byte(value=0)
        Byte element.

  GridGuidesInfo

    class psd_tools.psd.image_resources.GridGuidesInfo(version: int = 1, horizontal: int = 0, vertical: int = 0, data=NOTHING)
        Grid and guides info structure.

  HalftoneScreens

    class psd_tools.psd.image_resources.HalftoneScreens(items=NOTHING)
        Halftone screens.

  HalftoneScreen

    class psd_tools.psd.image_resources.HalftoneScreen(freq: int = 0, unit: int = 0, angle: int = 0, shape: int = 0, use_accurate: bool = False, use_printer: bool = False)
        Halftone screen.

        freq

        unit

        angle

        shape

        use_accurate

        use_printer

  Integer

    class psd_tools.psd.image_resources.Integer(value=0)
        Integer element.

  LayerGroupEnabledIDs

    class psd_tools.psd.image_resources.LayerGroupEnabledIDs(items=NOTHING)
        Layer group enabled ids.

  LayerGroupInfo

    class psd_tools.psd.image_resources.LayerGroupInfo(items=NOTHING)
        Layer group info list.

  LayerSelectionIDs

    class psd_tools.psd.image_resources.LayerSelectionIDs(items=NOTHING)
        Layer selection ids.

  ShortInteger

    class psd_tools.psd.image_resources.ShortInteger(value=0)
        Short integer element.

  PascalString

    class psd_tools.psd.image_resources.PascalString(value=None)
        Pascal string element.

  PixelAspectRatio

    class psd_tools.psd.image_resources.PixelAspectRatio(value=0.0, version: int = 1)
        Pixel aspect ratio.

  PrintFlags

    class psd_tools.psd.image_resources.PrintFlags(labels: bool = False, crop_marks: bool = False, colorbars: bool = False, registration_marks: bool = False, negative: bool = False, flip: bool = False, interpolate: bool = False, caption: bool = False, print_flags=None)
        Print flags.

  PrintFlagsInfo

    class psd_tools.psd.image_resources.PrintFlagsInfo(version: int = 0, center_crop: int = 0, bleed_width_value: int = 0, bleed_width_scale: int = 0)
        Print flags info structure.

        version

        center_crop

        bleed_width_value

        bleed_width_scale

  PrintScale

    class psd_tools.psd.image_resources.PrintScale(style=PrintScaleStyle.CENTERED, x: float = 0.0, y: float = 0.0, scale: float = 0.0)
        Print scale structure.

        style

        x

        y

        scale

  ResoulutionInfo

    class psd_tools.psd.image_resources.ResoulutionInfo(horizontal: int = 0, horizontal_unit: int = 0, width_unit: int = 0, vertical: int = 0, vertical_unit: int = 0, height_unit: int = 0)
        Resoulution info structure.

        horizontal

        horizontal_unit

        width_unit

        vertical

        vertical_unit

        height_unit

  Slices

    class psd_tools.psd.image_resources.Slices(version: int = 0, data=None)
        Slices resource.

        version

        data

  SlicesV6

    class psd_tools.psd.image_resources.SlicesV6(bbox=NOTHING, name: str = '', items=NOTHING)
        Slices resource version 6.

        bbox

        name

        items

  SliceV6

    class psd_tools.psd.image_resources.SliceV6(slice_id: int = 0, group_id: int = 0, origin: int = 0, associated_id=None, name: str = '', slice_type: int = 0, bbox=NOTHING, url: str = '', target: str = '', message: str = '', alt_tag: str = '', cell_is_html: bool = False, cell_text: str = '', horizontal_align: int = 0, vertical_align: int = 0, alpha: int = 0, red: int = 0, green: int = 0, blue: int = 0, data=None)
        Slice element for version 6.

        slice_id

        group_id

        origin

        associated_id

        name

        slice_type

        bbox

        url

        target

        message

        alt_tag

        cell_is_html

        cell_text

        horizontal

        vertical

        alpha

        red

        green

        blue

        data

  ThumbnailResource

    class psd_tools.psd.image_resources.ThumbnailResource(fmt: int = 0, width: int = 0, height: int = 0, row: int = 0, total_size: int = 0, bits: int = 0, planes: int = 0, data: bytes = b'')
        Thumbnail resource structure.

        fmt

        width

        height

        row

        total_size

        size

        bits

        planes

        data

        topil()
            Get PIL Image.

            Returns
                PIL Image object.

  ThumbnailResourceV4

    class psd_tools.psd.image_resources.ThumbnailResourceV4(fmt: int = 0, width: int = 0, height: int = 0, row: int = 0, total_size: int = 0, bits: int = 0, planes: int = 0, data: bytes = b'')

  TransferFunctions

    class psd_tools.psd.image_resources.TransferFunctions(items=NOTHING)
        Transfer functions.

  TransferFunction

    class psd_tools.psd.image_resources.TransferFunction(curve=NOTHING, override: bool = False)
        Transfer function

  URLList

    class psd_tools.psd.image_resources.URLList(items=NOTHING)
        URL list structure.

  URLItem

    class psd_tools.psd.image_resources.URLItem(number: int = 0, id: int = 0, name: str = '')
        URL item.

        number

        id

        name

  VersionInfo

    class psd_tools.psd.image_resources.VersionInfo(version: int = 1, has_composite: bool = False, writer: str = '', reader: str = '', file_version: int = 1)
        Version info structure.

        version

        has_composite

        writer

        reader

        file_version

  psd_tools.psd.layer_and_mask

Layer and mask data structure.

  LayerAndMaskInformation

    class psd_tools.psd.layer_and_mask.LayerAndMaskInformation(layer_info=None, global_layer_mask_info=None, tagged_blocks=None)
        Layer and mask information section.

        layer_info
            See LayerInfo.

        global_layer_mask_info
            See GlobalLayerMaskInfo.

        tagged_blocks
            See TaggedBlocks.

  LayerInfo

    class psd_tools.psd.layer_and_mask.LayerInfo(layer_count: int = 0, layer_records=None, channel_image_data=None)
        High-level organization of the layer information.

        layer_count
            Layer count. If it is a negative number, its absolute value is the number of layers and the first alpha channel contains the transparency data for the merged result.

        layer_records
            Information about each layer. See LayerRecords.

        channel_image_data
            Channel image data. See ChannelImageData.

  GlobalLayerMaskInfo

    class psd_tools.psd.layer_and_mask.GlobalLayerMaskInfo(overlay_color=None, opacity: int = 0, kind=GlobalLayerMaskKind.PER_LAYER)
        Global mask information.

        overlay_color
            Overlay color space (undocumented) and color components.

        opacity
            Opacity. 0 = transparent, 100 = opaque.

        kind
            Kind. 0 = Color selected--i.e. inverted; 1 = Color protected; 128 = use value stored per layer. This value is preferred. The others are for backward compatibility with beta versions.

  LayerRecords

    class psd_tools.psd.layer_and_mask.LayerRecords(items=NOTHING)
        List of layer records. See LayerRecord.

  LayerRecord

    class psd_tools.psd.layer_and_mask.LayerRecord(top: int = 0, left: int = 0, bottom: int = 0, right: int = 0, channel_info=NOTHING, signature: bytes = b'8BIM', blend_mode=BlendMode.NORMAL, opacity: int = 255, clipping=Clipping.BASE, flags=NOTHING, mask_data=None, blending_ranges=NOTHING, name: str = '', tagged_blocks=NOTHING)
        Layer record.

        top Top position.

        left
            Left position.

        bottom
            Bottom position.

        right
            Right position.

        channel_info
            List of ChannelInfo.

        signature
            Blend mode signature b'8BIM'.

        blend_mode
            Blend mode key. See BlendMode.

        opacity
            Opacity, 0 = transparent, 255 = opaque.

        clipping
            Clipping, 0 = base, 1 = non-base. See Clipping.

        flags
            See LayerFlags.

        mask_data
            MaskData or None.

        blending_ranges
            See LayerBlendingRanges.

        name
            Layer name.

        tagged_blocks
            See TaggedBlocks.

        property channel_sizes
            List of channel sizes: [(width, height)].

        property height
            Height of the layer.

        property width
            Width of the layer.

  LayerFlags

    class psd_tools.psd.layer_and_mask.LayerFlags(transparency_protected: bool = False, visible: bool = True, obsolete: bool = False, photoshop_v5_later: bool = True, pixel_data_irrelevant: bool = False, undocumented_1: bool = False, undocumented_2: bool = False, undocumented_3: bool = False)
        Layer flags.

        Note there are undocumented flags. Maybe photoshop version.

        transparency_protected

        visible

        pixel_data_irrelevant

  LayerBlendingRanges

    class psd_tools.psd.layer_and_mask.LayerBlendingRanges(composite_ranges=NOTHING, channel_ranges=NOTHING)
        Layer blending ranges.

        All ranges contain 2 black values followed by 2 white values.

        composite_ranges
            List of composite gray blend source and destination ranges.

        channel_ranges
            List of channel source and destination ranges.

  MaskData

    class psd_tools.psd.layer_and_mask.MaskData(top: int = 0, left: int = 0, bottom: int = 0, right: int = 0, background_color: int = 0, flags=NOTHING, parameters=None, real_flags=None, real_background_color=None, real_top=None, real_left=None, real_bottom=None, real_right=None)
        Mask data.

        Real user mask is a final composite mask of vector and pixel masks.

        top Top position.

        left
            Left position.

        bottom
            Bottom position.

        right
            Right position.

        background_color
            Default color. 0 or 255.

        flags
            See MaskFlags.

        parameters
            MaskParameters or None.

        real_flags
            Real user mask flags. See MaskFlags.

        real_background_color
            Real user mask background. 0 or 255.

        real_top
            Top position of real user mask.

        real_left
            Left position of real user mask.

        real_bottom
            Bottom position of real user mask.

        real_right
            Right position of real user mask.

        property height
            Height of the mask.

        property real_height
            Height of real user mask.

        property real_width
            Width of real user mask.

        property width
            Width of the mask.

  MaskFlags

    class psd_tools.psd.layer_and_mask.MaskFlags(pos_relative_to_layer: bool = False, mask_disabled: bool = False, invert_mask: bool = False, user_mask_from_render: bool = False, parameters_applied: bool = False, undocumented_1: bool = False, undocumented_2: bool = False, undocumented_3: bool = False)
        Mask flags.

        pos_relative_to_layer
            Position relative to layer.

        mask_disabled
            Layer mask disabled.

        invert_mask
            Invert layer mask when blending (Obsolete).

        user_mask_from_render
            The user mask actually came from rendering other data.

        parameters_applied
            The user and/or vector masks have parameters applied to them.

  MaskParameters

    class psd_tools.psd.layer_and_mask.MaskParameters(user_mask_density=None, user_mask_feather=None, vector_mask_density=None, vector_mask_feather=None)
        Mask parameters.

        user_mask_density

        user_mask_feather

        vector_mask_density

        vector_mask_feather

  ChannelInfo

    class psd_tools.psd.layer_and_mask.ChannelInfo(id=ChannelID.CHANNEL_0, length: int = 0)
        Channel information.

        id  Channel ID: 0 = red, 1 = green, etc.; -1 = transparency mask; -2 = user supplied layer mask, -3 real user supplied layer mask (when both a user mask and a vector mask are present). See ChannelID.

        length
            Length of the corresponding channel data.

  ChannelImageData

    class psd_tools.psd.layer_and_mask.ChannelImageData(items=NOTHING)
        List of channel data list.

        This size of this list corresponds to the size of LayerRecords. Each item corresponds to the channels of each layer.

        See ChannelDataList.

  ChannelDataList

    class psd_tools.psd.layer_and_mask.ChannelDataList(items=NOTHING)
        List of channel image data, corresponding to each color or alpha.

        See ChannelData.

  ChannelData

    class psd_tools.psd.layer_and_mask.ChannelData(compression=Compression.RAW, data: bytes = b'')
        Channel data.

        compression
            Compression type. See Compression.

        data
            Data.

        get_data(width, height, depth, version=1)
            Get decompressed channel data.

            Parameters

                •   width -- width.

                •   height -- height.

                •   depth -- bit depth of the pixel.

                •   version -- psd file version.

            Return type
                bytes

        set_data(data, width, height, depth, version=1)
            Set raw channel data and compress to store.

            Parameters

                •   data -- raw data bytes to write.

                •   compression -- compression type, see Compression.

                •   width -- width.

                •   height -- height.

                •   depth -- bit depth of the pixel.

                •   version -- psd file version.

  psd_tools.psd.linked_layer

Linked layer structure.

  LinkedLayers

    class psd_tools.psd.linked_layer.LinkedLayers(items=NOTHING)
        List of LinkedLayer structure. See LinkedLayer.

  LinkedLayer

    class psd_tools.psd.linked_layer.LinkedLayer(kind=LinkedLayerType.ALIAS, version=1, uuid: str = '', filename: str = '', filetype: bytes = b'\x00\x00\x00\x00', creator: bytes = b'\x00\x00\x00\x00', filesize=None, open_file=None, linked_file=None, timestamp=None, data=None, child_id=None, mod_time=None, lock_state=None)
        LinkedLayer structure.

        kind

        version

        uuid

        filename

        filetype

        creator

        filesize

        open_file

        linked_file

        timestamp

        data

        child_id

        mod_time

        lock_state

  psd_tools.psd.patterns

Patterns structure.

  Patterns

    class psd_tools.psd.patterns.Patterns(items=NOTHING)
        List of Pattern structure. See Pattern.

  Pattern

    class psd_tools.psd.patterns.Pattern(version: int = 1, image_mode=<enum 'ColorMode'>, point=None, name: str = '', pattern_id: str = '', color_table=None, data=None)
        Pattern structure.

        version

        image_mode
            See ColorMode

        point
            Size in tuple.

        name
            str name of the pattern.

        pattern_id
            ID of this pattern.

        color_table
            Color table if the mode is INDEXED.

        data
            See VirtualMemoryArrayList

  VirtualMemoryArrayList

    class psd_tools.psd.patterns.VirtualMemoryArrayList(version: int = 3, rectangle=None, channels=None)
        VirtualMemoryArrayList structure. Container of channels.

        version

        rectangle
            Tuple of int

        channels
            List of VirtualMemoryArray

  VirtualMemoryArray

    class psd_tools.psd.patterns.VirtualMemoryArray(is_written=0, depth=None, rectangle=None, pixel_depth=None, compression=Compression.RAW, data=b'')
        VirtualMemoryArrayList structure, corresponding to each channel.

        is_written

        depth

        rectangle

        pixel_depth

        compression

        data

        get_data()
            Get decompressed bytes.

        set_data(size, data, depth, compression=0)
            Set bytes.

  psd_tools.psd.tagged_blocks

Tagged block data structure.

  Todo

Support the following tagged blocks: Tag.PATTERN_DATA, Tag.TYPE_TOOL_INFO, Tag.LAYER, Tag.ALPHA

  TaggedBlocks

    class psd_tools.psd.tagged_blocks.TaggedBlocks(items=NOTHING)
        Dict of tagged block items.

        See Tag for available keys.

        Example:

                from psd_tools.constants import Tag

                # Iterate over fields
                for key in tagged_blocks:
                    print(key)

                # Get a field
                value = tagged_blocks.get_data(Tag.TYPE_TOOL_OBJECT_SETTING)

  TaggedBlock

    class psd_tools.psd.tagged_blocks.TaggedBlock(signature=b'8BIM', key=b'', data=b'')
        Layer tagged block with extra info.

        key 4-character code. See Tag

        data
            Data.

  Annotations

    class psd_tools.psd.tagged_blocks.Annotations(items=NOTHING, major_version: int = 2, minor_version: int = 1)
        List of Annotation, see :py:class: .Annotation.

        major_version

        minor_version

  Annotation

    class psd_tools.psd.tagged_blocks.Annotation(kind: bytes = b'txtA', is_open: int = 0, flags: int = 0, optional_blocks: int = 1, icon_location=NOTHING, popup_location=NOTHING, color=NOTHING, author: str = '', name: str = '', mod_date: str = '', marker: bytes = b'txtC', data: bytes = b'')
        Annotation structure.

        kind

        is_open

  Bytes

    class psd_tools.psd.tagged_blocks.Bytes(value: bytes = b'\x00\x00\x00\x00')
        Bytes structure.

        value

  ChannelBlendingRestrictionsSetting

    class psd_tools.psd.tagged_blocks.ChannelBlendingRestrictionsSetting(items=NOTHING)
        ChannelBlendingRestrictionsSetting structure.

        List of restricted channel numbers (int).

  FilterMask

    class psd_tools.psd.tagged_blocks.FilterMask(color=None, opacity: int = 0)
        FilterMask structure.

        color

        opacity

  MetadataSettings

    class psd_tools.psd.tagged_blocks.MetadataSettings(items=NOTHING)
        MetadataSettings structure.

  MetadataSetting

    class psd_tools.psd.tagged_blocks.MetadataSetting(signature: bytes = b'8BIM', key: bytes = b'', copy_on_sheet: bool = False, data: bytes = b'')
        MetadataSetting structure.

  PixelSourceData2

    class psd_tools.psd.tagged_blocks.PixelSourceData2(items=NOTHING)
        PixelSourceData2 structure.

  PlacedLayerData

    class psd_tools.psd.tagged_blocks.PlacedLayerData(kind: bytes = b'plcL', version: int = 3, uuid: bytes = b'', page: int = 0, total_pages: int = 0, anti_alias: int = 0, layer_type=PlacedLayerType.UNKNOWN, transform: tuple = (0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0), warp=None)
        PlacedLayerData structure.

  ProtectedSetting

    class psd_tools.psd.tagged_blocks.ProtectedSetting(value=0)
        ProtectedSetting structure.

  ReferencePoint

    class psd_tools.psd.tagged_blocks.ReferencePoint(items=NOTHING)
        ReferencePoint structure.

  SectionDividerSetting

    class psd_tools.psd.tagged_blocks.SectionDividerSetting(kind=SectionDivider.OTHER, signature=None, blend_mode=None, sub_type=None)
        SectionDividerSetting structure.

        kind

        blend_mode

        sub_type

  SheetColorSetting

    class psd_tools.psd.tagged_blocks.SheetColorSetting(value=0)
        SheetColorSetting value.

        This setting represents color label in the layers panel in Photoshop UI.

        value

  SmartObjectLayerData

    class psd_tools.psd.tagged_blocks.SmartObjectLayerData(kind: bytes = b'soLD', version: int = 5, data: DescriptorBlock = None)
        VersionedDescriptorBlock structure.

        kind

        version

        data

  TypeToolObjectSetting

    class psd_tools.psd.tagged_blocks.TypeToolObjectSetting(version: int = 1, transform: tuple = (0.0, 0.0, 0.0, 0.0, 0.0, 0.0), text_version: int = 1, text_data: DescriptorBlock = None, warp_version: int = 1, warp: DescriptorBlock = None, left: int = 0, top: int = 0, right: int = 0, bottom: int = 0)
        TypeToolObjectSetting structure.

        version

        transform
            Tuple of affine transform parameters (xx, xy, yx, yy, tx, ty).

        text_version

        text_data

        warp_version

        warp

        left

        top

        right

        bottom

  UserMask

    class psd_tools.psd.tagged_blocks.UserMask(color=None, opacity: int = 0, flag: int = 128)
        UserMask structure.

        color

        opacity

        flag

  psd_tools.psd.vector

Vector mask, path, and stroke structure.

  Path

    class psd_tools.psd.vector.Path(items=NOTHING)
        List-like Path structure. Elements are either PathFillRule, InitialFillRule, ClipboardRecord, ClosedPath, or OpenPath.

  Subpath

    class psd_tools.psd.vector.Subpath(items=NOTHING, operation: int = 1, unknown1: int = 1, unknown2: int = 0, index: int = 0, unknown3: bytes = b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')
        Subpath element. This is a list of Knot objects.

        NOTE:
            There are undocumented data associated with this structure.

        operation
            int value indicating how multiple subpath should be combined:

            1: Or (union), 2: Not-Or, 3: And (intersect), 0: Xor (exclude)

            The first path element is applied to the background surface. Intersection does not have strokes.

        index
            int index that specifies corresponding origination object.

        is_closed()
            Returns whether if the path is closed or not.

            Returns
                bool.

  Knot

    class psd_tools.psd.vector.Knot(preceding: tuple = (0.0, 0.0), anchor: tuple = (0.0, 0.0), leaving: tuple = (0.0, 0.0))
        Knot element consisting of 3 control points for Bezier curves.

        preceding
            (y, x) tuple of preceding control point in relative coordinates.

        anchor
            (y, x) tuple of anchor point in relative coordinates.

        leaving
            (y, x) tuple of leaving control point in relative coordinates.

  ClipboardRecord

    class psd_tools.psd.vector.ClipboardRecord(top: int = 0, left: int = 0, bottom: int = 0, right: int = 0, resolution: int = 0)
        Clipboard record.

        top Top position in int

        left
            Left position in int

        bottom
            Bottom position in int

        right
            Right position in int

        resolution
            Resolution in int

  PathFillRule

    class psd_tools.psd.vector.PathFillRule
        Path fill rule record, empty.

  InitialFillRule

    class psd_tools.psd.vector.InitialFillRule(value=0)
        Initial fill rule record.

        rule
            A value of 1 means that the fill starts with all pixels. The value will be either 0 or 1.

  VectorMaskSetting

    class psd_tools.psd.vector.VectorMaskSetting(version: int = 3, flags: int = 0, path=None)
        VectorMaskSetting structure.

        version

        path
            List of Subpath objects.

        property disable
            Flag to indicate that the vector mask is disabled.

        property invert
            Flag to indicate that the vector mask is inverted.

        property not_link
            Flag to indicate that the vector mask is not linked.

  VectorStrokeContentSetting

    class psd_tools.psd.vector.VectorStrokeContentSetting(items=NOTHING, name: str = '', classID=b'null', key: bytes = b'\x00\x00\x00\x00', version: int = 1)
        Dict-like Descriptor-based structure. See Descriptor.

        key

        version

  psd_tools.terminology

Constants for descriptor.

This file is automaticaly generated by tools/extract_terminology.py

  Klass

    class psd_tools.terminology.Klass(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None)
        Klass definitions extracted from PITerminology.h.

        See https://www.adobe.com/devnet/photoshop/sdk.html

        Action = b'Actn'

        ActionSet = b'ASet'

        Adjustment = b'Adjs'

        AdjustmentLayer = b'AdjL'

        AirbrushTool = b'AbTl'

        AlphaChannelOptions = b'AChl'

        AntiAliasedPICTAcquire = b'AntA'

        Application = b'capp'

        Arrowhead = b'cArw'

        ArtHistoryBrushTool = b'ABTl'

        Assert = b'Asrt'

        AssumedProfile = b'AssP'

        BMPFormat = b'BMPF'

        BackLight = b'BakL'

        BackgroundEraserTool = b'SETl'

        BackgroundLayer = b'BckL'

        BevelEmboss = b'ebbl'

        BitmapMode = b'BtmM'

        BlendRange = b'Blnd'

        BlurTool = b'BlTl'

        BookColor = b'BkCl'

        BrightnessContrast = b'BrgC'

        Brush = b'Brsh'

        BurnInTool = b'BrTl'

        CMYKColor = b'CMYC'

        CMYKColorMode = b'CMYM'

        CMYKSetup = b'CMYS'

        CachePrefs = b'CchP'

        Calculation = b'Clcl'

        Channel = b'Chnl'

        ChannelMatrix = b'ChMx'

        ChannelMixer = b'ChnM'

        ChromeFX = b'ChFX'

        CineonFormat = b'SDPX'

        ClippingInfo = b'Clpo'

        ClippingPath = b'ClpP'

        CloneStampTool = b'ClTl'

        Color = b'Clr '

        ColorBalance = b'ClrB'

        ColorCast = b'ColC'

        ColorCorrection = b'ClrC'

        ColorPickerPrefs = b'Clrk'

        ColorSampler = b'ClSm'

        ColorStop = b'Clrt'

        Command = b'Cmnd'

        Contour = b'FxSc'

        CurvePoint = b'CrPt'

        Curves = b'Crvs'

        CurvesAdjustment = b'CrvA'

        CustomPalette = b'Cstl'

        CustomPhosphors = b'CstP'

        CustomWhitePoint = b'CstW'

        DicomFormat = b'Dicm'

        DisplayPrefs = b'DspP'

        Document = b'Dcmn'

        DodgeTool = b'DdTl'

        DropShadow = b'DrSh'

        DuotoneInk = b'DtnI'

        DuotoneMode = b'DtnM'

        EPSGenericFormat = b'EPSG'

        EPSPICTPreview = b'EPSC'

        EPSTIFFPreview = b'EPST'

        EXRf = b'EXRf'

        Element = b'Elmn'

        Ellipse = b'Elps'

        EraserTool = b'ErTl'

        Export = b'Expr'

        FileInfo = b'FlIn'

        FileSavePrefs = b'FlSv'

        FillFlash = b'FilF'

        FlashPixFormat = b'FlsP'

        FontDesignAxes = b'FntD'

        Format = b'Fmt '

        FrameFX = b'FrFX'

        GIF89aExport = b'GF89'

        GIFFormat = b'GFFr'

        GeneralPrefs = b'GnrP'

        GlobalAngle = b'gblA'

        Gradient = b'Grdn'

        GradientFill = b'Grdf'

        GradientMap = b'GdMp'

        GradientTool = b'GrTl'

        GraySetup = b'GrSt'

        Grayscale = b'Grsc'

        GrayscaleMode = b'Grys'

        Guide = b'Gd '

        GuidesPrefs = b'GdPr'

        HSBColor = b'HSBC'

        HSBColorMode = b'HSBM'

        HalftoneScreen = b'HlfS'

        HalftoneSpec = b'Hlfp'

        HistoryBrushTool = b'HBTl'

        HistoryPrefs = b'CHsP'

        HistoryState = b'HstS'

        HueSatAdjustment = b'HStA'

        HueSatAdjustmentV2 = b'Hst2'

        HueSaturation = b'HStr'

        IFFFormat = b'IFFF'

        IllustratorPathsExport = b'IlsP'

        ImagePoint = b'ImgP'

        Import = b'Impr'

        IndexedColorMode = b'IndC'

        InkTransfer = b'InkT'

        InnerGlow = b'IrGl'

        InnerShadow = b'IrSh'

        InterfaceColor = b'IClr'

        Invert = b'Invr'

        JPEGFormat = b'JPEG'

        LabColor = b'LbCl'

        LabColorMode = b'LbCM'

        Layer = b'Lyr '

        LayerEffects = b'Lefx'

        LayerFXVisible = b'lfxv'

        Levels = b'Lvls'

        LevelsAdjustment = b'LvlA'

        LightSource = b'LghS'

        Line = b'Ln '

        MacPaintFormat = b'McPn'

        MagicEraserTool = b'MgEr'

        MagicPoint = b'Mgcp'

        Mask = b'Msk '

        MenuItem = b'Mn '

        Mode = b'Md '

        MultichannelMode = b'MltC'

        Null = b'null'

        ObsoleteTextLayer = b'TxLy'

        Offset = b'Ofst'

        Opacity = b'Opac'

        OuterGlow = b'OrGl'

        PDFGenericFormat = b'PDFG'

        PICTFileFormat = b'PICF'

        PICTResourceFormat = b'PICR'

        PNGFormat = b'PNGF'

        PageSetup = b'PgSt'

        PaintbrushTool = b'PbTl'

        Path = b'Path'

        PathComponent = b'PaCm'

        PathPoint = b'Pthp'

        Pattern = b'PttR'

        PatternStampTool = b'PaTl'

        PencilTool = b'PcTl'

        Photoshop20Format = b'Pht2'

        Photoshop35Format = b'Pht3'

        PhotoshopDCS2Format = b'PhD2'

        PhotoshopDCSFormat = b'PhD1'

        PhotoshopEPSFormat = b'PhtE'

        PhotoshopPDFFormat = b'PhtP'

        Pixel = b'Pxel'

        PixelPaintFormat = b'PxlP'

        PluginPrefs = b'PlgP'

        Point = b'Pnt '

        Point16 = b'Pnt1'

        Polygon = b'Plgn'

        Posterize = b'Pstr'

        Preferences = b'GnrP'

        ProfileSetup = b'PrfS'

        Property = b'Prpr'

        RGBColor = b'RGBC'

        RGBColorMode = b'RGBM'

        RGBSetup = b'RGBt'

        Range = b'Rang'

        RawFormat = b'Rw '

        Rect16 = b'Rct1'

        Rectangle = b'Rctn'

        SaturationTool = b'SrTl'

        ScitexCTFormat = b'Sctx'

        Selection = b'csel'

        SelectiveColor = b'SlcC'

        ShapingCurve = b'ShpC'

        SharpenTool = b'ShTl'

        SingleColumn = b'Sngc'

        SingleRow = b'Sngr'

        SmudgeTool = b'SmTl'

        Snapshot = b'SnpS'

        SolidFill = b'SoFi'

        SpotColorChannel = b'SCch'

        Style = b'StyC'

        SubPath = b'Sbpl'

        TIFFFormat = b'TIFF'

        TargaFormat = b'TrgF'

        TextLayer = b'TxLr'

        TextStyle = b'TxtS'

        TextStyleRange = b'Txtt'

        Threshold = b'Thrs'

        Tool = b'Tool'

        TransferPoint = b'DtnP'

        TransferSpec = b'Trfp'

        TransparencyPrefs = b'TrnP'

        TransparencyStop = b'TrnS'

        UnitsPrefs = b'UntP'

        UnspecifiedColor = b'UnsC'

        Version = b'Vrsn'

        WebdavPrefs = b'Wdbv'

        XYYColor = b'XYYC'

  Enum

    class psd_tools.terminology.Enum(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None)
        Enum definitions extracted from PITerminology.h.

        See https://www.adobe.com/devnet/photoshop/sdk.html

        A = b'A '

        ADSBottoms = b'AdBt'

        ADSCentersH = b'AdCH'

        ADSCentersV = b'AdCV'

        ADSHorizontal = b'AdHr'

        ADSLefts = b'AdLf'

        ADSRights = b'AdRg'

        ADSTops = b'AdTp'

        ADSVertical = b'AdVr'

        ASCII = b'ASCI'

        AboutApp = b'AbAp'

        AbsColorimetric = b'AClr'

        Absolute = b'Absl'

        ActualPixels = b'ActP'

        Adaptive = b'Adpt'

        Add = b'Add '

        AdjustmentOptions = b'AdjO'

        AdobeRGB1998 = b'SMPT'

        AirbrushEraser = b'Arbs'

        All = b'Al '

        Amiga = b'Amga'

        AmountHigh = b'amHi'

        AmountLow = b'amLo'

        AmountMedium = b'amMd'

        Angle = b'Angl'

        AntiAliasCrisp = b'AnCr'

        AntiAliasHigh = b'AnHi'

        AntiAliasLow = b'AnLo'

        AntiAliasMedium = b'AnMd'

        AntiAliasNone = b'Anno'

        AntiAliasSmooth = b'AnSm'

        AntiAliasStrong = b'AnSt'

        Any = b'Any '

        AppleRGB = b'AppR'

        ApplyImage = b'AplI'

        AroundCenter = b'ArnC'

        Arrange = b'Arng'

        Ask = b'Ask '

        AskWhenOpening = b'AskW'

        B = b'B '

        Back = b'Back'

        Background = b'Bckg'

        BackgroundColor = b'BckC'

        Backward = b'Bckw'

        Behind = b'Bhnd'

        Best = b'Bst '

        Better = b'Dthb'

        Bicubic = b'Bcbc'

        Bilinear = b'Blnr'

        Binary = b'Bnry'

        BitDepth1 = b'BD1 '

        BitDepth16 = b'BD16'

        BitDepth24 = b'BD24'

        BitDepth32 = b'BD32'

        BitDepth4 = b'BD4 '

        BitDepth8 = b'BD8 '

        BitDepthA1R5G5B5 = b'1565'

        BitDepthA4R4G4B4 = b'4444'

        BitDepthR5G6B5 = b'x565'

        BitDepthX4R4G4B4 = b'x444'

        BitDepthX8R8G8B8 = b'x888'

        Bitmap = b'Btmp'

        Black = b'Blck'

        BlackAndWhite = b'BanW'

        BlackBody = b'BlcB'

        Blacks = b'Blks'

        Blast = b'Blst'

        BlockEraser = b'Blk '

        Blocks = b'Blks'

        Blue = b'Bl '

        Blues = b'Bls '

        Bottom = b'Bttm'

        BrushDarkRough = b'BrDR'

        BrushLightRough = b'BrsL'

        BrushSimple = b'BrSm'

        BrushSize = b'BrsS'

        BrushSparkle = b'BrSp'

        BrushWideBlurry = b'BrbW'

        BrushWideSharp = b'BrsW'

        BrushesAppend = b'BrsA'

        BrushesDefine = b'BrsD'

        BrushesDelete = b'Brsf'

        BrushesLoad = b'Brsd'

        BrushesNew = b'BrsN'

        BrushesOptions = b'BrsO'

        BrushesReset = b'BrsR'

        BrushesSave = b'Brsv'

        Builtin = b'Bltn'

        BurnInH = b'BrnH'

        BurnInM = b'BrnM'

        BurnInS = b'BrnS'

        ButtonMode = b'BtnM'

        CIERGB = b'CRGB'

        CMYK = b'CMYK'

        CMYK64 = b'CMSF'

        CMYKColor = b'ECMY'

        Calculations = b'Clcl'

        Cascade = b'Cscd'

        Center = b'Cntr'

        CenterGlow = b'SrcC'

        CenteredFrame = b'CtrF'

        ChannelOptions = b'ChnO'

        ChannelsPaletteOptions = b'ChnP'

        CheckerboardLarge = b'ChcL'

        CheckerboardMedium = b'ChcM'

        CheckerboardNone = b'ChcN'

        CheckerboardSmall = b'ChcS'

        Clear = b'Clar'

        ClearGuides = b'ClrG'

        Clipboard = b'Clpb'

        ClippingPath = b'ClpP'

        CloseAll = b'ClsA'

        CoarseDots = b'CrsD'

        Color = b'Clr '

        ColorBurn = b'CBrn'

        ColorDodge = b'CDdg'

        ColorMatch = b'ClMt'

        ColorNoise = b'ClNs'

        Colorimetric = b'Clrm'

        Composite = b'Cmps'

        ContourCustom = b'sp06'

        ContourDouble = b'sp04'

        ContourGaussian = b'sp02'

        ContourLinear = b'sp01'

        ContourSingle = b'sp03'

        ContourTriple = b'sp05'

        ConvertToCMYK = b'CnvC'

        ConvertToGray = b'CnvG'

        ConvertToLab = b'CnvL'

        ConvertToRGB = b'CnvR'

        CreateDuplicate = b'CrtD'

        CreateInterpolation = b'CrtI'

        Cross = b'Crs '

        CurrentLayer = b'CrrL'

        Custom = b'Cst '

        CustomPattern = b'Cstm'

        CustomStops = b'CstS'

        Cyan = b'Cyn '

        Cyans = b'Cyns'

        Dark = b'Drk '

        Darken = b'Drkn'

        DarkenOnly = b'DrkO'

        DashedLines = b'DshL'

        Desaturate = b'Dstt'

        Diamond = b'Dmnd'

        Difference = b'Dfrn'

        Diffusion = b'Dfsn'

        DiffusionDither = b'DfnD'

        DisplayCursorsPreferences = b'DspC'

        Dissolve = b'Dslv'

        Distort = b'Dstr'

        DodgeH = b'DdgH'

        DodgeM = b'DdgM'

        DodgeS = b'DdgS'

        Dots = b'Dts '

        Draft = b'Drft'

        Duotone = b'Dtn '

        EBUITU = b'EBT '

        EdgeGlow = b'SrcE'

        EliminateEvenFields = b'ElmE'

        EliminateOddFields = b'ElmO'

        Ellipse = b'Elps'

        Emboss = b'Embs'

        Exact = b'Exct'

        Exclusion = b'Xclu'

        FPXCompressLossyJPEG = b'FxJP'

        FPXCompressNone = b'FxNo'

        Faster = b'Dthf'

        File = b'Fle '

        FileInfo = b'FlIn'

        FillBack = b'FlBc'

        FillFore = b'FlFr'

        FillInverse = b'FlIn'

        FillSame = b'FlSm'

        FineDots = b'FnDt'

        First = b'Frst'

        FirstIdle = b'FrId'

        FitOnScreen = b'FtOn'

        ForegroundColor = b'FrgC'

        Forward = b'Frwr'

        FreeTransform = b'FrTr'

        Front = b'Frnt'

        FullDocument = b'FllD'

        FullSize = b'FlSz'

        GIFColorFileColorTable = b'GFCT'

        GIFColorFileColors = b'GFCF'

        GIFColorFileMicrosoftPalette = b'GFMS'

        GIFPaletteAdaptive = b'GFPA'

        GIFPaletteExact = b'GFPE'

        GIFPaletteOther = b'GFPO'

        GIFPaletteSystem = b'GFPS'

        GIFRequiredColorSpaceIndexed = b'GFCI'

        GIFRequiredColorSpaceRGB = b'GFRG'

        GIFRowOrderInterlaced = b'GFIN'

        GIFRowOrderNormal = b'GFNI'

        GaussianDistribution = b'Gsn '

        GeneralPreferences = b'GnrP'

        Good = b'Gd '

        GradientFill = b'GrFl'

        GrainClumped = b'GrnC'

        GrainContrasty = b'GrCn'

        GrainEnlarged = b'GrnE'

        GrainHorizontal = b'GrnH'

        GrainRegular = b'GrnR'

        GrainSoft = b'GrSf'

        GrainSpeckle = b'GrSp'

        GrainSprinkles = b'GrSr'

        GrainStippled = b'GrSt'

        GrainVertical = b'GrnV'

        GrainyDots = b'GrnD'

        Graphics = b'Grp '

        Gray = b'Gry '

        Gray16 = b'GryX'

        Gray18 = b'Gr18'

        Gray22 = b'Gr22'

        Gray50 = b'Gr50'

        GrayScale = b'Gryc'

        Grayscale = b'Grys'

        Green = b'Grn '

        Greens = b'Grns'

        GuidesGridPreferences = b'GudG'

        HDTV = b'HDTV'

        HSBColor = b'HSBl'

        HSLColor = b'HSLC'

        HalftoneFile = b'HlfF'

        HalftoneScreen = b'HlfS'

        HardLight = b'HrdL'

        Heavy = b'Hvy '

        HideAll = b'HdAl'

        HideSelection = b'HdSl'

        High = b'High'

        HighQuality = b'Hgh '

        Highlights = b'Hghl'

        Histogram = b'Hstg'

        History = b'Hsty'

        HistoryPaletteOptions = b'HstO'

        HistoryPreferences = b'HstP'

        Horizontal = b'Hrzn'

        HorizontalOnly = b'HrzO'

        Hue = b'H '

        IBMPC = b'IBMP'

        ICC = b'ICC '

        Icon = b'Icn '

        IdleVM = b'IdVM'

        Ignore = b'Ignr'

        Image = b'Img '

        ImageCachePreferences = b'ImgP'

        IndexedColor = b'Indl'

        InfoPaletteOptions = b'InfP'

        InfoPaletteToggleSamplers = b'InfT'

        InnerBevel = b'InrB'

        InsetFrame = b'InsF'

        Inside = b'Insd'

        JPEG = b'JPEG'

        JustifyAll = b'JstA'

        JustifyFull = b'JstF'

        KeepProfile = b'KPro'

        KeyboardPreferences = b'KybP'

        Lab = b'Lab '

        Lab48 = b'LbCF'

        LabColor = b'LbCl'

        Large = b'Lrg '

        Last = b'Lst '

        LastFilter = b'LstF'

        LayerOptions = b'LyrO'

        LayersPaletteOptions = b'LyrP'

        Left = b'Left'

        Left_PLUGIN = b'Lft '

        LevelBased = b'LvlB'

        Light = b'Lgt '

        LightBlue = b'LgtB'

        LightDirBottom = b'LDBt'

        LightDirBottomLeft = b'LDBL'

        LightDirBottomRight = b'LDBR'

        LightDirLeft = b'LDLf'

        LightDirRight = b'LDRg'

        LightDirTop = b'LDTp'

        LightDirTopLeft = b'LDTL'

        LightDirTopRight = b'LDTR'

        LightDirectional = b'LghD'

        LightGray = b'LgtG'

        LightOmni = b'LghO'

        LightPosBottom = b'LPBt'

        LightPosBottomLeft = b'LPBL'

        LightPosBottomRight = b'LPBr'

        LightPosLeft = b'LPLf'

        LightPosRight = b'LPRg'

        LightPosTop = b'LPTp'

        LightPosTopLeft = b'LPTL'

        LightPosTopRight = b'LPTR'

        LightRed = b'LgtR'

        LightSpot = b'LghS'

        Lighten = b'Lghn'

        LightenOnly = b'LghO'

        Lightness = b'Lght'

        Line = b'Ln '

        Linear = b'Lnr '

        Lines = b'Lns '

        Linked = b'Lnkd'

        LongLines = b'LngL'

        LongStrokes = b'LngS'

        Low = b'Low '

        LowQuality = b'Lw '

        Lower = b'Lwr '

        Luminosity = b'Lmns'

        MacThumbnail = b'McTh'

        Macintosh = b'Mcnt'

        MacintoshSystem = b'McnS'

        Magenta = b'Mgnt'

        Magentas = b'Mgnt'

        Mask = b'Msk '

        MaskedAreas = b'MskA'

        MasterAdaptive = b'MAdp'

        MasterPerceptual = b'MPer'

        MasterSelective = b'MSel'

        Maximum = b'Mxmm'

        MaximumQuality = b'Mxm '

        Maya = b'Maya'

        Medium = b'Mdim'

        MediumBlue = b'MdmB'

        MediumDots = b'MdmD'

        MediumLines = b'MdmL'

        MediumQuality = b'Mdm '

        MediumStrokes = b'MdmS'

        MemoryPreferences = b'MmrP'

        MergeChannels = b'MrgC'

        Merged = b'Mrgd'

        MergedLayers = b'Mrg2'

        MergedLayersOld = b'MrgL'

        Middle = b'Mddl'

        Midtones = b'Mdtn'

        ModeGray = b'MdGr'

        ModeRGB = b'MdRG'

        Monitor = b'Moni'

        MonitorSetup = b'MntS'

        Monotone = b'Mntn'

        Multi72Color = b'72CM'

        Multi72Gray = b'72GM'

        MultiNoCompositePS = b'NCmM'

        Multichannel = b'Mlth'

        Multiply = b'Mltp'

        NTSC = b'NTSC'

        NavigatorPaletteOptions = b'NvgP'

        NearestNeighbor = b'Nrst'

        NetscapeGray = b'NsGr'

        Neutrals = b'Ntrl'

        NewView = b'NwVw'

        Next = b'Nxt '

        Nikon = b'Nkn '

        Nikon105 = b'Nkn1'

        No = b'N '

        NoCompositePS = b'NCmp'

        Normal = b'Nrml'

        NormalPath = b'NrmP'

        Null = b'null'

        OS2 = b'OS2 '

        Off = b'Off '

        On = b'On '

        OpenAs = b'OpAs'

        Orange = b'Orng'

        OutFromCenter = b'OtFr'

        OutOfGamut = b'OtOf'

        OuterBevel = b'OtrB'

        OutsetFrame = b'OutF'

        Outside = b'Otsd'

        Overlay = b'Ovrl'

        P22EBU = b'P22B'

        PNGFilterAdaptive = b'PGAd'

        PNGFilterAverage = b'PGAv'

        PNGFilterNone = b'PGNo'

        PNGFilterPaeth = b'PGPt'

        PNGFilterSub = b'PGSb'

        PNGFilterUp = b'PGUp'

        PNGInterlaceAdam7 = b'PGIA'

        PNGInterlaceNone = b'PGIN'

        PagePosCentered = b'PgPC'

        PagePosTopLeft = b'PgTL'

        PageSetup = b'PgSt'

        PaintbrushEraser = b'Pntb'

        PalSecam = b'PlSc'

        PanaVision = b'PnVs'

        PathsPaletteOptions = b'PthP'

        Pattern = b'Ptrn'

        PatternDither = b'PtnD'

        PencilEraser = b'Pncl'

        Perceptual = b'Perc'

        Perspective = b'Prsp'

        PhotoshopPicker = b'Phtk'

        PickCMYK = b'PckC'

        PickGray = b'PckG'

        PickHSB = b'PckH'

        PickLab = b'PckL'

        PickOptions = b'PckO'

        PickRGB = b'PckR'

        PillowEmboss = b'PlEb'

        PixelPaintSize1 = b'PxS1'

        PixelPaintSize2 = b'PxS2'

        PixelPaintSize3 = b'PxS3'

        PixelPaintSize4 = b'PxS4'

        Place = b'Plce'

        PlaybackOptions = b'PbkO'

        PluginPicker = b'PlgP'

        PluginsScratchDiskPreferences = b'PlgS'

        PolarToRect = b'PlrR'

        PondRipples = b'PndR'

        Precise = b'Prc '

        PreciseMatte = b'PrBL'

        PreviewBlack = b'PrvB'

        PreviewCMY = b'PrvN'

        PreviewCMYK = b'PrvC'

        PreviewCyan = b'Prvy'

        PreviewMagenta = b'PrvM'

        PreviewOff = b'PrvO'

        PreviewYellow = b'PrvY'

        Previous = b'Prvs'

        Primaries = b'Prim'

        PrintSize = b'PrnS'

        PrintingInksSetup = b'PrnI'

        Purple = b'Prp '

        Pyramids = b'Pyrm'

        QCSAverage = b'Qcsa'

        QCSCorner0 = b'Qcs0'

        QCSCorner1 = b'Qcs1'

        QCSCorner2 = b'Qcs2'

        QCSCorner3 = b'Qcs3'

        QCSIndependent = b'Qcsi'

        QCSSide0 = b'Qcs4'

        QCSSide1 = b'Qcs5'

        QCSSide2 = b'Qcs6'

        QCSSide3 = b'Qcs7'

        Quadtone = b'Qdtn'

        QueryAlways = b'QurA'

        QueryAsk = b'Qurl'

        QueryNever = b'QurN'

        RGB = b'RGB '

        RGB48 = b'RGBF'

        RGBColor = b'RGBC'

        Radial = b'Rdl '

        Random = b'Rndm'

        RectToPolar = b'RctP'

        Red = b'Rd '

        RedrawComplete = b'RdCm'

        Reds = b'Rds '

        Reflected = b'Rflc'

        Relative = b'Rltv'

        Repeat = b'Rpt '

        RepeatEdgePixels = b'RptE'

        RevealAll = b'RvlA'

        RevealSelection = b'RvlS'

        Revert = b'Rvrt'

        Right = b'Rght'

        Rotate = b'Rtte'

        RotoscopingPreferences = b'RtsP'

        Round = b'Rnd '

        RulerCm = b'RrCm'

        RulerInches = b'RrIn'

        RulerPercent = b'RrPr'

        RulerPicas = b'RrPi'

        RulerPixels = b'RrPx'

        RulerPoints = b'RrPt'

        SMPTEC = b'SMPC'

        SRGB = b'SRGB'

        Sample3x3 = b'Smp3'

        Sample5x5 = b'Smp5'

        SamplePoint = b'SmpP'

        Saturate = b'Str '

        Saturation = b'Strt'

        SaveForWeb = b'Svfw'

        Saved = b'Sved'

        SavingFilesPreferences = b'SvnF'

        Scale = b'Scl '

        Screen = b'Scrn'

        ScreenCircle = b'ScrC'

        ScreenDot = b'ScrD'

        ScreenLine = b'ScrL'

        SelectedAreas = b'SlcA'

        Selection = b'Slct'

        Selective = b'Sele'

        SeparationSetup = b'SprS'

        SeparationTables = b'SprT'

        Shadows = b'Shdw'

        ShortLines = b'ShrL'

        ShortStrokes = b'ShSt'

        Single72Color = b'72CS'

        Single72Gray = b'72GS'

        SingleNoCompositePS = b'NCmS'

        Skew = b'Skew'

        SlopeLimitMatte = b'Slmt'

        Small = b'Sml '

        SmartBlurModeEdgeOnly = b'SBME'

        SmartBlurModeNormal = b'SBMN'

        SmartBlurModeOverlayEdge = b'SBMO'

        SmartBlurQualityHigh = b'SBQH'

        SmartBlurQualityLow = b'SBQL'

        SmartBlurQualityMedium = b'SBQM'

        Snapshot = b'Snps'

        SoftLight = b'SftL'

        SoftMatte = b'SfBL'

        SolidColor = b'SClr'

        Spectrum = b'Spct'

        Spin = b'Spn '

        SpotColor = b'Spot'

        Square = b'Sqr '

        Stagger = b'Stgr'

        StampIn = b'In '

        StampOut = b'Out '

        Standard = b'Std '

        StdA = b'StdA'

        StdB = b'StdB'

        StdC = b'StdC'

        StdE = b'StdE'

        StretchToFit = b'StrF'

        StrokeDirHorizontal = b'SDHz'

        StrokeDirLeftDiag = b'SDLD'

        StrokeDirRightDiag = b'SDRD'

        StrokeDirVertical = b'SDVt'

        StylesAppend = b'SlsA'

        StylesDelete = b'Slsf'

        StylesLoad = b'Slsd'

        StylesNew = b'SlsN'

        StylesReset = b'SlsR'

        StylesSave = b'Slsv'

        Subtract = b'Sbtr'

        SwatchesAppend = b'SwtA'

        SwatchesReplace = b'Swtp'

        SwatchesReset = b'SwtR'

        SwatchesSave = b'SwtS'

        SystemPicker = b'SysP'

        TIFF = b'TIFF'

        Tables = b'Tbl '

        Target = b'Trgt'

        TargetPath = b'Trgp'

        TexTypeBlocks = b'TxBl'

        TexTypeBrick = b'TxBr'

        TexTypeBurlap = b'TxBu'

        TexTypeCanvas = b'TxCa'

        TexTypeFrosted = b'TxFr'

        TexTypeSandstone = b'TxSt'

        TexTypeTinyLens = b'TxTL'

        Threshold = b'Thrh'

        Thumbnail = b'Thmb'

        Tile = b'Tile'

        Tile_PLUGIN = b'Tl '

        ToggleActionsPalette = b'TglA'

        ToggleBlackPreview = b'TgBP'

        ToggleBrushesPalette = b'TglB'

        ToggleCMYKPreview = b'TglC'

        ToggleCMYPreview = b'TgCM'

        ToggleChannelsPalette = b'Tglh'

        ToggleColorPalette = b'Tglc'

        ToggleCyanPreview = b'TgCP'

        ToggleDocumentPalette = b'TgDc'

        ToggleEdges = b'TglE'

        ToggleGamutWarning = b'TglG'

        ToggleGrid = b'TgGr'

        ToggleGuides = b'Tgld'

        ToggleHistoryPalette = b'TglH'

        ToggleInfoPalette = b'TglI'

        ToggleLayerMask = b'TglM'

        ToggleLayersPalette = b'Tgly'

        ToggleLockGuides = b'TglL'

        ToggleMagentaPreview = b'TgMP'

        ToggleNavigatorPalette = b'TglN'

        ToggleOptionsPalette = b'TglO'

        TogglePaths = b'TglP'

        TogglePathsPalette = b'Tglt'

        ToggleRGBMacPreview = b'TrMp'

        ToggleRGBUncompensatedPreview = b'TrUp'

        ToggleRGBWindowsPreview = b'TrWp'

        ToggleRulers = b'TglR'

        ToggleSnapToGrid = b'TgSn'

        ToggleSnapToGuides = b'TglS'

        ToggleStatusBar = b'Tgls'

        ToggleStylesPalette = b'TgSl'

        ToggleSwatchesPalette = b'Tglw'

        ToggleToolsPalette = b'TglT'

        ToggleYellowPreview = b'TgYP'

        Top = b'Top '

        Transparency = b'Trsp'

        TransparencyGamutPreferences = b'TrnG'

        Transparent = b'Trns'

        Trinitron = b'Trnt'

        Tritone = b'Trtn'

        UIBitmap = b'UBtm'

        UICMYK = b'UCMY'

        UIDuotone = b'UDtn'

        UIGrayscale = b'UGry'

        UIIndexed = b'UInd'

        UILab = b'ULab'

        UIMultichannel = b'UMlt'

        UIRGB = b'URGB'

        Undo = b'Und '

        Uniform = b'Unfm'

        UniformDistribution = b'Unfr'

        UnitsRulersPreferences = b'UntR'

        Upper = b'Upr '

        UserStop = b'UsrS'

        VMPreferences = b'VMPr'

        Vertical = b'Vrtc'

        VerticalOnly = b'VrtO'

        Violet = b'Vlt '

        WaveSine = b'WvSn'

        WaveSquare = b'WvSq'

        WaveTriangle = b'WvTr'

        Web = b'Web '

        White = b'Wht '

        Whites = b'Whts'

        WideGamutRGB = b'WRGB'

        WidePhosphors = b'Wide'

        WinThumbnail = b'WnTh'

        Wind = b'Wnd '

        Windows = b'Win '

        WindowsSystem = b'WndS'

        WorkPath = b'WrkP'

        Wrap = b'Wrp '

        WrapAround = b'WrpA'

        Yellow = b'Yllw'

        YellowColor = b'Ylw '

        Yellows = b'Ylws'

        Yes = b'Ys '

        Zip = b'ZpEn'

        Zoom = b'Zm '

        ZoomIn = b'ZmIn'

        ZoomOut = b'ZmOt'

        _16BitsPerPixel = b'16Bt'

        _1BitPerPixel = b'OnBt'

        _2BitsPerPixel = b'2Bts'

        _32BitsPerPixel = b'32Bt'

        _4BitsPerPixel = b'4Bts'

        _5000 = b'5000'

        _5500 = b'5500'

        _6500 = b'6500'

        _72Color = b'72Cl'

        _72Gray = b'72Gr'

        _7500 = b'7500'

        _8BitsPerPixel = b'EghB'

        _9300 = b'9300'

        _None = b'None'

  Event

    class psd_tools.terminology.Event(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None)
        Event definitions extracted from PITerminology.h.

        See https://www.adobe.com/devnet/photoshop/sdk.html

        AccentedEdges = b'AccE'

        Add = b'Add '

        AddNoise = b'AdNs'

        AddTo = b'AddT'

        Align = b'Algn'

        All = b'All '

        AngledStrokes = b'AngS'

        ApplyImage = b'AppI'

        ApplyStyle = b'ASty'

        Assert = b'Asrt'

        Average = b'Avrg'

        BackLight = b'BacL'

        BasRelief = b'BsRl'

        Batch = b'Btch'

        BatchFromDroplet = b'BtcF'

        Blur = b'Blr '

        BlurMore = b'BlrM'

        Border = b'Brdr'

        Brightness = b'BrgC'

        CanvasSize = b'CnvS'

        ChalkCharcoal = b'ChlC'

        ChannelMixer = b'ChnM'

        Charcoal = b'Chrc'

        Chrome = b'Chrm'

        Clear = b'Cler'

        Close = b'Cls '

        Clouds = b'Clds'

        ColorBalance = b'ClrB'

        ColorCast = b'ColE'

        ColorHalftone = b'ClrH'

        ColorRange = b'ClrR'

        ColoredPencil = b'ClrP'

        ConteCrayon = b'CntC'

        Contract = b'Cntc'

        ConvertMode = b'CnvM'

        Copy = b'copy'

        CopyEffects = b'CpFX'

        CopyMerged = b'CpyM'

        CopyToLayer = b'CpTL'

        Craquelure = b'Crql'

        CreateDroplet = b'CrtD'

        Crop = b'Crop'

        Crosshatch = b'Crsh'

        Crystallize = b'Crst'

        Curves = b'Crvs'

        Custom = b'Cstm'

        Cut = b'cut '

        CutToLayer = b'CtTL'

        Cutout = b'Ct '

        DarkStrokes = b'DrkS'

        DeInterlace = b'Dntr'

        DefinePattern = b'DfnP'

        Defringe = b'Dfrg'

        Delete = b'Dlt '

        Desaturate = b'Dstt'

        Deselect = b'Dslc'

        Despeckle = b'Dspc'

        DifferenceClouds = b'DfrC'

        Diffuse = b'Dfs '

        DiffuseGlow = b'DfsG'

        DisableLayerFX = b'dlfx'

        Displace = b'Dspl'

        Distribute = b'Dstr'

        Draw = b'Draw'

        DryBrush = b'DryB'

        Duplicate = b'Dplc'

        DustAndScratches = b'DstS'

        Emboss = b'Embs'

        Equalize = b'Eqlz'

        Exchange = b'Exch'

        Expand = b'Expn'

        Export = b'Expr'

        Extrude = b'Extr'

        Facet = b'Fct '

        Fade = b'Fade'

        Feather = b'Fthr'

        Fibers = b'Fbrs'

        Fill = b'Fl '

        FilmGrain = b'FlmG'

        Filter = b'Fltr'

        FindEdges = b'FndE'

        FlattenImage = b'FltI'

        Flip = b'Flip'

        Fragment = b'Frgm'

        Fresco = b'Frsc'

        GaussianBlur = b'GsnB'

        Get = b'getd'

        Glass = b'Gls '

        GlowingEdges = b'GlwE'

        Gradient = b'Grdn'

        GradientMap = b'GrMp'

        Grain = b'Grn '

        GraphicPen = b'GraP'

        Group = b'GrpL'

        Grow = b'Grow'

        HSBHSL = b'HsbP'

        HalftoneScreen = b'HlfS'

        Hide = b'Hd '

        HighPass = b'HghP'

        HueSaturation = b'HStr'

        ImageSize = b'ImgS'

        Import = b'Impr'

        InkOutlines = b'InkO'

        Intersect = b'Intr'

        IntersectWith = b'IntW'

        Inverse = b'Invs'

        Invert = b'Invr'

        LensFlare = b'LnsF'

        Levels = b'Lvls'

        LightingEffects = b'LghE'

        Link = b'Lnk '

        Make = b'Mk '

        Maximum = b'Mxm '

        Median = b'Mdn '

        MergeLayers = b'Mrg2'

        MergeLayersOld = b'MrgL'

        MergeSpotChannel = b'MSpt'

        MergeVisible = b'MrgV'

        Mezzotint = b'Mztn'

        Minimum = b'Mnm '

        Mosaic = b'Msc '

        Mosaic_PLUGIN = b'MscT'

        MotionBlur = b'MtnB'

        Move = b'move'

        NTSCColors = b'NTSC'

        NeonGlow = b'NGlw'

        Next = b'Nxt '

        NotePaper = b'NtPr'

        Notify = b'Ntfy'

        Null = b'null'

        OceanRipple = b'OcnR'

        Offset = b'Ofst'

        Open = b'Opn '

        OpenUntitled = b'OpnU'

        PaintDaubs = b'PntD'

        PaletteKnife = b'PltK'

        Paste = b'past'

        PasteEffects = b'PaFX'

        PasteInto = b'PstI'

        PasteOutside = b'PstO'

        Patchwork = b'Ptch'

        Photocopy = b'Phtc'

        Pinch = b'Pnch'

        Place = b'Plc '

        Plaster = b'Plst'

        PlasticWrap = b'PlsW'

        Play = b'Ply '

        Pointillize = b'Pntl'

        Polar = b'Plr '

        PosterEdges = b'PstE'

        Posterize = b'Pstr'

        Previous = b'Prvs'

        Print = b'Prnt'

        ProfileToProfile = b'PrfT'

        Purge = b'Prge'

        Quit = b'quit'

        RadialBlur = b'RdlB'

        Rasterize = b'Rstr'

        RasterizeTypeSheet = b'RstT'

        RemoveBlackMatte = b'RmvB'

        RemoveLayerMask = b'RmvL'

        RemoveWhiteMatte = b'RmvW'

        Rename = b'Rnm '

        ReplaceColor = b'RplC'

        Reset = b'Rset'

        Reticulation = b'Rtcl'

        Revert = b'Rvrt'

        Ripple = b'Rple'

        Rotate = b'Rtte'

        RoughPastels = b'RghP'

        Save = b'save'

        Select = b'slct'

        SelectiveColor = b'SlcC'

        Set = b'setd'

        Sharpen = b'Shrp'

        SharpenEdges = b'ShrE'

        SharpenMore = b'ShrM'

        Shear = b'Shr '

        Show = b'Shw '

        Similar = b'Smlr'

        SmartBlur = b'SmrB'

        Smooth = b'Smth'

        SmudgeStick = b'SmdS'

        Solarize = b'Slrz'

        Spatter = b'Spt '

        Spherize = b'Sphr'

        SplitChannels = b'SplC'

        Sponge = b'Spng'

        SprayedStrokes = b'SprS'

        StainedGlass = b'StnG'

        Stamp = b'Stmp'

        Stop = b'Stop'

        Stroke = b'Strk'

        Subtract = b'Sbtr'

        SubtractFrom = b'SbtF'

        Sumie = b'Smie'

        TakeMergedSnapshot = b'TkMr'

        TakeSnapshot = b'TkSn'

        TextureFill = b'TxtF'

        Texturizer = b'Txtz'

        Threshold = b'Thrs'

        Tiles = b'Tls '

        TornEdges = b'TrnE'

        TraceContour = b'TrcC'

        Transform = b'Trnf'

        Trap = b'Trap'

        Twirl = b'Twrl'

        Underpainting = b'Undr'

        Undo = b'undo'

        Ungroup = b'Ungr'

        Unlink = b'Unlk'

        UnsharpMask = b'UnsM'

        Variations = b'Vrtn'

        Wait = b'Wait'

        WaterPaper = b'WtrP'

        Watercolor = b'Wtrc'

        Wave = b'Wave'

        Wind = b'Wnd '

        ZigZag = b'ZgZg'

        _3DTransform = b'TdT '

  Form

    class psd_tools.terminology.Form(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None)
        Form definitions extracted from PITerminology.h.

        See https://www.adobe.com/devnet/photoshop/sdk.html

        Class = b'Clss'

        Enumerated = b'Enmr'

        Identifier = b'Idnt'

        Index = b'indx'

        Offset = b'rele'

        Property = b'prop'

  Key

    class psd_tools.terminology.Key(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None)
        Key definitions extracted from PITerminology.h.

        See https://www.adobe.com/devnet/photoshop/sdk.html

        A = b'A '

        Adjustment = b'Adjs'

        Aligned = b'Algd'

        Alignment = b'Algn'

        AllExcept = b'AllE'

        AllPS = b'All '

        AllToolOptions = b'AlTl'

        AlphaChannelOptions = b'AChn'

        AlphaChannels = b'AlpC'

        AmbientBrightness = b'AmbB'

        AmbientColor = b'AmbC'

        Amount = b'Amnt'

        AmplitudeMax = b'AmMx'

        AmplitudeMin = b'AmMn'

        Anchor = b'Anch'

        Angle = b'Angl'

        Angle1 = b'Ang1'

        Angle2 = b'Ang2'

        Angle3 = b'Ang3'

        Angle4 = b'Ang4'

        AntiAlias = b'AntA'

        Append = b'Appe'

        Apply = b'Aply'

        Area = b'Ar '

        Arrowhead = b'Arrw'

        As = b'As '

        AssetBin = b'Asst'

        AssumedCMYK = b'AssC'

        AssumedGray = b'AssG'

        AssumedRGB = b'AssR'

        At = b'At '

        Auto = b'Auto'

        AutoContrast = b'AuCo'

        AutoErase = b'Atrs'

        AutoKern = b'AtKr'

        AutoUpdate = b'AtUp'

        Axis = b'Axis'

        B = b'B '

        Background = b'Bckg'

        BackgroundColor = b'BckC'

        BackgroundLevel = b'BckL'

        Backward = b'Bwd '

        Balance = b'Blnc'

        BaselineShift = b'Bsln'

        BeepWhenDone = b'BpWh'

        BeginRamp = b'BgnR'

        BeginSustain = b'BgnS'

        BevelDirection = b'bvlD'

        BevelEmboss = b'ebbl'

        BevelStyle = b'bvlS'

        BevelTechnique = b'bvlT'

        BigNudgeH = b'BgNH'

        BigNudgeV = b'BgNV'

        BitDepth = b'BtDp'

        Black = b'Blck'

        BlackClip = b'BlcC'

        BlackGeneration = b'Blcn'

        BlackGenerationCurve = b'BlcG'

        BlackIntensity = b'BlcI'

        BlackLevel = b'BlcL'

        BlackLimit = b'BlcL'

        Bleed = b'Bld '

        BlendRange = b'Blnd'

        Blue = b'Bl '

        BlueBlackPoint = b'BlBl'

        BlueFloat = b'blueFloat'

        BlueGamma = b'BlGm'

        BlueWhitePoint = b'BlWh'

        BlueX = b'BlX '

        BlueY = b'BlY '

        Blur = b'blur'

        BlurMethod = b'BlrM'

        BlurQuality = b'BlrQ'

        Book = b'Bk '

        BorderThickness = b'BrdT'

        Bottom = b'Btom'

        Brightness = b'Brgh'

        BrushDetail = b'BrsD'

        BrushSize = b'BrsS'

        BrushType = b'BrsT'

        Brushes = b'Brsh'

        BumpAmplitude = b'BmpA'

        BumpChannel = b'BmpC'

        By = b'By '

        Byline = b'Byln'

        BylineTitle = b'BylT'

        ByteOrder = b'BytO'

        CMYKSetup = b'CMYS'

        CachePrefs = b'CchP'

        Calculation = b'Clcl'

        CalibrationBars = b'Clbr'

        Caption = b'Cptn'

        CaptionWriter = b'CptW'

        Category = b'Ctgr'

        CellSize = b'ClSz'

        Center = b'Cntr'

        CenterCropMarks = b'CntC'

        ChalkArea = b'ChlA'

        Channel = b'Chnl'

        ChannelMatrix = b'ChMx'

        ChannelName = b'ChnN'

        Channels = b'Chns'

        ChannelsInterleaved = b'ChnI'

        CharcoalAmount = b'ChAm'

        CharcoalArea = b'ChrA'

        ChokeMatte = b'Ckmt'

        ChromeFX = b'ChFX'

        City = b'City'

        ClearAmount = b'ClrA'

        ClippingPath = b'ClPt'

        ClippingPathEPS = b'ClpP'

        ClippingPathFlatness = b'ClpF'

        ClippingPathIndex = b'ClpI'

        ClippingPathInfo = b'Clpg'

        CloneSource = b'ClnS'

        ClosedSubpath = b'Clsp'

        Color = b'Clr '

        ColorChannels = b'Clrh'

        ColorCorrection = b'ClrC'

        ColorIndicates = b'ClrI'

        ColorManagement = b'ClMg'

        ColorPickerPrefs = b'Clrr'

        ColorSpace = b'ClrS'

        ColorTable = b'ClrT'

        Colorize = b'Clrz'

        Colors = b'Clrs'

        ColorsList = b'ClrL'

        ColumnWidth = b'ClmW'

        CommandKey = b'CmdK'

        Compensation = b'Cmpn'

        Compression = b'Cmpr'

        Concavity = b'Cncv'

        Condition = b'Cndt'

        Constant = b'Cnst'

        Constrain = b'Cnst'

        ConstrainProportions = b'CnsP'

        ConstructionFOV = b'Cfov'

        Contiguous = b'Cntg'

        Continue = b'Cntn'

        Continuity = b'Cnty'

        ContourType = b'ShpC'

        Contrast = b'Cntr'

        Convert = b'Cnvr'

        Copy = b'Cpy '

        Copyright = b'Cpyr'

        CopyrightNotice = b'CprN'

        CornerCropMarks = b'CrnC'

        Count = b'Cnt '

        CountryName = b'CntN'

        CrackBrightness = b'CrcB'

        CrackDepth = b'CrcD'

        CrackSpacing = b'CrcS'

        CreateLayersFromLayerFX = b'blfl'

        Credit = b'Crdt'

        Crossover = b'Crss'

        Current = b'Crnt'

        CurrentHistoryState = b'CrnH'

        CurrentLight = b'CrnL'

        CurrentToolOptions = b'CrnT'

        Curve = b'Crv '

        CurveFile = b'CrvF'

        Custom = b'Cstm'

        CustomForced = b'CstF'

        CustomMatte = b'CstM'

        CustomPalette = b'CstP'

        Cyan = b'Cyn '

        DCS = b'DCS '

        DPXFormat = b'DPXf'

        DarkIntensity = b'DrkI'

        Darkness = b'Drkn'

        DateCreated = b'DtCr'

        Datum = b'Dt '

        Definition = b'Dfnt'

        Density = b'Dnst'

        Depth = b'Dpth'

        DestBlackMax = b'Dstl'

        DestBlackMin = b'DstB'

        DestWhiteMax = b'Dstt'

        DestWhiteMin = b'DstW'

        DestinationMode = b'DstM'

        Detail = b'Dtl '

        Diameter = b'Dmtr'

        DiffusionDither = b'DffD'

        Direction = b'Drct'

        DirectionBalance = b'DrcB'

        DisplaceFile = b'DspF'

        DisplacementMap = b'DspM'

        DisplayPrefs = b'DspP'

        Distance = b'Dstn'

        Distortion = b'Dstr'

        Distribution = b'Dstr'

        Dither = b'Dthr'

        DitherAmount = b'DthA'

        DitherPreserve = b'Dthp'

        DitherQuality = b'Dthq'

        DocumentID = b'DocI'

        DotGain = b'DtGn'

        DotGainCurves = b'DtGC'

        DropShadow = b'DrSh'

        Duplicate = b'Dplc'

        DynamicColorSliders = b'DnmC'

        Edge = b'Edg '

        EdgeBrightness = b'EdgB'

        EdgeFidelity = b'EdgF'

        EdgeIntensity = b'EdgI'

        EdgeSimplicity = b'EdgS'

        EdgeThickness = b'EdgT'

        EdgeWidth = b'EdgW'

        Effect = b'Effc'

        EmbedCMYK = b'EmbC'

        EmbedGray = b'EmbG'

        EmbedLab = b'EmbL'

        EmbedProfiles = b'EmbP'

        EmbedRGB = b'EmbR'

        EmulsionDown = b'EmlD'

        EnableGestures = b'EGst'

        Enabled = b'enab'

        Encoding = b'Encd'

        End = b'End '

        EndArrowhead = b'EndA'

        EndRamp = b'EndR'

        EndSustain = b'EndS'

        Engine = b'Engn'

        EraseToHistory = b'ErsT'

        EraserKind = b'ErsK'

        ExactPoints = b'ExcP'

        Export = b'Expr'

        ExportClipboard = b'ExpC'

        Exposure = b'Exps'

        Extend = b'Extd'

        ExtendedQuality = b'EQlt'

        Extension = b'Extn'

        ExtensionsQuery = b'ExtQ'

        ExtrudeDepth = b'ExtD'

        ExtrudeMaskIncomplete = b'ExtM'

        ExtrudeRandom = b'ExtR'

        ExtrudeSize = b'ExtS'

        ExtrudeSolidFace = b'ExtF'

        ExtrudeType = b'ExtT'

        EyeDropperSample = b'EyDr'

        FPXCompress = b'FxCm'

        FPXQuality = b'FxQl'

        FPXSize = b'FxSz'

        FPXView = b'FxVw'

        FadeTo = b'FdT '

        FadeoutSteps = b'FdtS'

        Falloff = b'FlOf'

        Feather = b'Fthr'

        FiberLength = b'FbrL'

        File = b'File'

        FileCreator = b'FlCr'

        FileInfo = b'FlIn'

        FileReference = b'FilR'

        FileSavePrefs = b'FlSP'

        FileType = b'FlTy'

        FilesList = b'flst'

        Fill = b'Fl '

        FillColor = b'FlCl'

        FillNeutral = b'FlNt'

        FilterLayerPersistentData = b'FlPd'

        FilterLayerRandomSeed = b'FlRs'

        Fingerpainting = b'Fngr'

        FlareCenter = b'FlrC'

        Flatness = b'Fltn'

        Flatten = b'Fltt'

        FlipVertical = b'FlpV'

        Focus = b'Fcs '

        Folders = b'Fldr'

        FontDesignAxes = b'FntD'

        FontDesignAxesVectors = b'FntV'

        FontName = b'FntN'

        FontScript = b'Scrp'

        FontStyleName = b'FntS'

        FontTechnology = b'FntT'

        ForcedColors = b'FrcC'

        ForegroundColor = b'FrgC'

        ForegroundLevel = b'FrgL'

        Format = b'Fmt '

        Forward = b'Fwd '

        FrameFX = b'FrFX'

        FrameWidth = b'FrmW'

        FreeTransformCenterState = b'FTcs'

        Frequency = b'Frqn'

        From = b'From'

        FromBuiltin = b'FrmB'

        FromMode = b'FrmM'

        FunctionKey = b'FncK'

        Fuzziness = b'Fzns'

        GCR = b'GCR '

        GIFColorFileType = b'GFPT'

        GIFColorLimit = b'GFCL'

        GIFExportCaption = b'GFEC'

        GIFMaskChannelIndex = b'GFMI'

        GIFMaskChannelInverted = b'GFMV'

        GIFPaletteFile = b'GFPF'

        GIFPaletteType = b'GFPL'

        GIFRequiredColorSpaceType = b'GFCS'

        GIFRowOrderType = b'GFIT'

        GIFTransparentColor = b'GFTC'

        GIFTransparentIndexBlue = b'GFTB'

        GIFTransparentIndexGreen = b'GFTG'

        GIFTransparentIndexRed = b'GFTR'

        GIFUseBestMatch = b'GFBM'

        Gamma = b'Gmm '

        GamutWarning = b'GmtW'

        GeneralPrefs = b'GnrP'

        GlobalAngle = b'gblA'

        GlobalLightingAngle = b'gagl'

        Gloss = b'Glos'

        GlowAmount = b'GlwA'

        GlowTechnique = b'GlwT'

        Gradient = b'Grad'

        GradientFill = b'Grdf'

        Grain = b'Grn '

        GrainType = b'Grnt'

        Graininess = b'Grns'

        Gray = b'Gry '

        GrayBehavior = b'GrBh'

        GraySetup = b'GrSt'

        Green = b'Grn '

        GreenBlackPoint = b'GrnB'

        GreenFloat = b'greenFloat'

        GreenGamma = b'GrnG'

        GreenWhitePoint = b'GrnW'

        GreenX = b'GrnX'

        GreenY = b'GrnY'

        GridColor = b'GrdC'

        GridCustomColor = b'Grds'

        GridMajor = b'GrdM'

        GridMinor = b'Grdn'

        GridStyle = b'GrdS'

        GridUnits = b'Grdt'

        Group = b'Grup'

        GroutWidth = b'GrtW'

        GrowSelection = b'GrwS'

        Guides = b'Gdes'

        GuidesColor = b'GdsC'

        GuidesCustomColor = b'Gdss'

        GuidesPrefs = b'GdPr'

        GuidesStyle = b'GdsS'

        GutterWidth = b'GttW'

        HalftoneFile = b'HlfF'

        HalftoneScreen = b'HlfS'

        HalftoneSize = b'HlSz'

        HalftoneSpec = b'Hlfp'

        Hardness = b'Hrdn'

        HasCmdHPreference = b'HCdH'

        Header = b'Hdr '

        Headline = b'Hdln'

        Height = b'Hght'

        HighlightArea = b'HghA'

        HighlightColor = b'hglC'

        HighlightLevels = b'HghL'

        HighlightMode = b'hglM'

        HighlightOpacity = b'hglO'

        HighlightStrength = b'HghS'

        HistoryBrushSource = b'HstB'

        HistoryPrefs = b'HstP'

        HistoryStateSource = b'HsSS'

        HistoryStates = b'HsSt'

        Horizontal = b'Hrzn'

        HorizontalScale = b'HrzS'

        HostName = b'HstN'

        HostVersion = b'HstV'

        Hue = b'H '

        ICCEngine = b'ICCE'

        ICCSetupName = b'ICCt'

        ID = b'Idnt'

        Idle = b'Idle'

        ImageBalance = b'ImgB'

        Import = b'Impr'

        Impressionist = b'Imps'

        In = b'In '

        Inherits = b'c@#^'

        InkColors = b'InkC'

        Inks = b'Inks'

        InnerGlow = b'IrGl'

        InnerGlowSource = b'glwS'

        InnerShadow = b'IrSh'

        Input = b'Inpt'

        InputBlackPoint = b'kIBP'

        InputMapRange = b'Inmr'

        InputRange = b'Inpr'

        InputWhitePoint = b'kIWP'

        Intensity = b'Intn'

        Intent = b'Inte'

        InterfaceBevelHighlight = b'IntH'

        InterfaceBevelShadow = b'Intv'

        InterfaceBlack = b'IntB'

        InterfaceBorder = b'Intd'

        InterfaceButtonDarkShadow = b'Intk'

        InterfaceButtonDownFill = b'Intt'

        InterfaceButtonUpFill = b'InBF'

        InterfaceColorBlue2 = b'ICBL'

        InterfaceColorBlue32 = b'ICBH'

        InterfaceColorGreen2 = b'ICGL'

        InterfaceColorGreen32 = b'ICGH'

        InterfaceColorRed2 = b'ICRL'

        InterfaceColorRed32 = b'ICRH'

        InterfaceIconFillActive = b'IntI'

        InterfaceIconFillDimmed = b'IntF'

        InterfaceIconFillSelected = b'Intc'

        InterfaceIconFrameActive = b'Intm'

        InterfaceIconFrameDimmed = b'Intr'

        InterfaceIconFrameSelected = b'IntS'

        InterfacePaletteFill = b'IntP'

        InterfaceRed = b'IntR'

        InterfaceToolTipBackground = b'IntT'

        InterfaceToolTipText = b'ITTT'

        InterfaceTransparencyBackground = b'ITBg'

        InterfaceTransparencyForeground = b'ITFg'

        InterfaceWhite = b'IntW'

        Interlace = b'Intr'

        InterlaceCreateType = b'IntC'

        InterlaceEliminateType = b'IntE'

        Interpolation = b'Intr'

        InterpolationMethod = b'IntM'

        Invert = b'Invr'

        InvertMask = b'InvM'

        InvertSource2 = b'InvS'

        InvertTexture = b'InvT'

        IsDirty = b'IsDr'

        ItemIndex = b'ItmI'

        JPEGQuality = b'JPEQ'

        Kerning = b'Krng'

        Keywords = b'Kywd'

        Kind = b'Knd '

        LUTAnimation = b'LTnm'

        LZWCompression = b'LZWC'

        Labels = b'Lbls'

        Landscape = b'Lnds'

        LastTransform = b'LstT'

        Layer = b'Lyr '

        LayerEffects = b'Lefx'

        LayerFXVisible = b'lfxv'

        LayerID = b'LyrI'

        LayerName = b'LyrN'

        Layers = b'Lyrs'

        Leading = b'Ldng'

        Left = b'Left'

        LegacySerialString = b'lSNs'

        Length = b'Lngt'

        Lens = b'Lns '

        Level = b'Lvl '

        Levels = b'Lvls'

        LightDark = b'LgDr'

        LightDirection = b'LghD'

        LightIntensity = b'LghI'

        LightPosition = b'LghP'

        LightSource = b'LghS'

        LightType = b'LghT'

        LightenGrout = b'LghG'

        Lightness = b'Lght'

        Line = b'Line'

        LinkEnable = b'lnkE'

        LinkedLayerIDs = b'LnkL'

        LocalLightingAltitude = b'Lald'

        LocalLightingAngle = b'lagl'

        LocalRange = b'LclR'

        Location = b'Lctn'

        Log = b'Log '

        Logarithmic = b'kLog'

        LowerCase = b'LwCs'

        Luminance = b'Lmnc'

        Magenta = b'Mgnt'

        MakeVisible = b'MkVs'

        ManipulationFOV = b'Mfov'

        MapBlack = b'MpBl'

        Mapping = b'Mpng'

        MappingShape = b'MpgS'

        Material = b'Mtrl'

        Matrix = b'Mtrx'

        MatteColor = b'MttC'

        Maximum = b'Mxm '

        MaximumStates = b'MxmS'

        MemoryUsagePercent = b'MmrU'

        Merge = b'Mrge'

        Merged = b'Mrgd'

        Message = b'Msge'

        Method = b'Mthd'

        MezzotintType = b'MztT'

        Midpoint = b'Mdpn'

        MidtoneLevels = b'MdtL'

        Minimum = b'Mnm '

        MismatchCMYK = b'MsmC'

        MismatchGray = b'MsmG'

        MismatchRGB = b'MsmR'

        Mode = b'Md '

        Monochromatic = b'Mnch'

        MoveTo = b'MvT '

        Name = b'Nm '

        Negative = b'Ngtv'

        New = b'Nw '

        Noise = b'Nose'

        NonImageData = b'NnIm'

        NonLinear = b'NnLn'

        Null = b'null'

        NumLights = b'Nm L'

        Number = b'Nmbr'

        NumberOfCacheLevels = b'NCch'

        NumberOfCacheLevels64 = b'NC64'

        NumberOfChannels = b'NmbO'

        NumberOfChildren = b'NmbC'

        NumberOfDocuments = b'NmbD'

        NumberOfGenerators = b'NmbG'

        NumberOfLayers = b'NmbL'

        NumberOfLevels = b'NmbL'

        NumberOfPaths = b'NmbP'

        NumberOfRipples = b'NmbR'

        NumberOfSiblings = b'NmbS'

        ObjectName = b'ObjN'

        Offset = b'Ofst'

        OldSmallFontType = b'Sftt'

        On = b'On '

        Opacity = b'Opct'

        Optimized = b'Optm'

        Orientation = b'Ornt'

        OriginalHeader = b'OrgH'

        OriginalTransmissionReference = b'OrgT'

        OtherCursors = b'OthC'

        OuterGlow = b'OrGl'

        Output = b'Otpt'

        OutputBlackPoint = b'kOBP'

        OutputWhitePoint = b'kOWP'

        OverprintColors = b'OvrC'

        OverrideOpen = b'OvrO'

        OverridePrinter = b'ObrP'

        OverrideSave = b'Ovrd'

        PNGFilter = b'PNGf'

        PNGInterlaceType = b'PGIT'

        PageFormat = b'PMpf'

        PageNumber = b'PgNm'

        PagePosition = b'PgPs'

        PageSetup = b'PgSt'

        PaintCursorKind = b'PnCK'

        PaintType = b'PntT'

        PaintingCursors = b'PntC'

        Palette = b'Plt '

        PaletteFile = b'PltF'

        PaperBrightness = b'PprB'

        ParentIndex = b'PrIn'

        ParentName = b'PrNm'

        Path = b'Path'

        PathContents = b'PthC'

        PathName = b'PthN'

        Pattern = b'Pttn'

        PencilWidth = b'Pncl'

        PerspectiveIndex = b'Prsp'

        Phosphors = b'Phsp'

        PickerID = b'PckI'

        PickerKind = b'Pckr'

        PixelPaintSize = b'PPSz'

        Platform = b'Pltf'

        PluginFolder = b'PlgF'

        PluginPrefs = b'PlgP'

        Points = b'Pts '

        Position = b'Pstn'

        PostScriptColor = b'PstS'

        Posterization = b'Pstr'

        PredefinedColors = b'PrdC'

        PreferBuiltin = b'PrfB'

        Preferences = b'Prfr'

        PreserveAdditional = b'PrsA'

        PreserveLuminosity = b'PrsL'

        PreserveTransparency = b'PrsT'

        Pressure = b'Prs '

        Preview = b'Prvw'

        PreviewCMYK = b'PrvK'

        PreviewFullSize = b'PrvF'

        PreviewIcon = b'PrvI'

        PreviewMacThumbnail = b'PrvM'

        PreviewWinThumbnail = b'PrvW'

        PreviewsQuery = b'PrvQ'

        PrintSettings = b'PMps'

        ProfileSetup = b'PrfS'

        ProvinceState = b'PrvS'

        Quality = b'Qlty'

        QuickMask = b'QucM'

        RGBSetup = b'RGBS'

        Radius = b'Rds '

        RandomSeed = b'RndS'

        Ratio = b'Rt '

        RecentFiles = b'Rcnf'

        Red = b'Rd '

        RedBlackPoint = b'RdBl'

        RedFloat = b'redFloat'

        RedGamma = b'RdGm'

        RedWhitePoint = b'RdWh'

        RedX = b'RdX '

        RedY = b'RdY '

        RegistrationMarks = b'RgsM'

        Relative = b'Rltv'

        Relief = b'Rlf '

        RenderFidelity = b'Rfid'

        Resample = b'Rsmp'

        ResizeWindowsOnZoom = b'RWOZ'

        Resolution = b'Rslt'

        ResourceID = b'RsrI'

        Response = b'Rspn'

        RetainHeader = b'RtnH'

        Reverse = b'Rvrs'

        Right = b'Rght'

        RippleMagnitude = b'RplM'

        RippleSize = b'RplS'

        Rotate = b'Rtt '

        Roundness = b'Rndn'

        RulerOriginH = b'RlrH'

        RulerOriginV = b'RlrV'

        RulerUnits = b'RlrU'

        Saturation = b'Strt'

        SaveAndClose = b'SvAn'

        SaveComposite = b'SvCm'

        SavePaletteLocations = b'PltL'

        SavePaths = b'SvPt'

        SavePyramids = b'SvPy'

        Saving = b'Svng'

        Scale = b'Scl '

        ScaleHorizontal = b'SclH'

        ScaleVertical = b'SclV'

        Scaling = b'Scln'

        Scans = b'Scns'

        ScratchDisks = b'ScrD'

        ScreenFile = b'ScrF'

        ScreenType = b'ScrT'

        Separations = b'Sprt'

        SerialString = b'SrlS'

        ShadingIntensity = b'ShdI'

        ShadingNoise = b'ShdN'

        ShadingShape = b'ShdS'

        ShadowColor = b'sdwC'

        ShadowIntensity = b'ShdI'

        ShadowLevels = b'ShdL'

        ShadowMode = b'sdwM'

        ShadowOpacity = b'sdwO'

        Shape = b'Shp '

        Sharpness = b'Shrp'

        ShearEd = b'ShrE'

        ShearPoints = b'ShrP'

        ShearSt = b'ShrS'

        ShiftKey = b'ShfK'

        ShiftKeyToolSwitch = b'ShKT'

        ShortNames = b'ShrN'

        ShowEnglishFontNames = b'ShwE'

        ShowMenuColors = b'SwMC'

        ShowToolTips = b'ShwT'

        ShowTransparency = b'ShTr'

        SizeKey = b'Sz '

        Skew = b'Skew'

        SmallFontType = b'Sfts'

        SmartBlurMode = b'SmBM'

        SmartBlurQuality = b'SmBQ'

        Smooth = b'Smoo'

        Smoothness = b'Smth'

        SnapshotInitial = b'SnpI'

        SoftClip = b'SfCl'

        Softness = b'Sftn'

        SolidFill = b'SoFi'

        Source = b'Srce'

        Source2 = b'Src2'

        SourceMode = b'SrcM'

        Spacing = b'Spcn'

        SpecialInstructions = b'SpcI'

        SpherizeMode = b'SphM'

        Spot = b'Spot'

        SprayRadius = b'SprR'

        SquareSize = b'SqrS'

        SrcBlackMax = b'Srcl'

        SrcBlackMin = b'SrcB'

        SrcWhiteMax = b'Srcm'

        SrcWhiteMin = b'SrcW'

        Start = b'Strt'

        StartArrowhead = b'StrA'

        State = b'Stte'

        Strength = b'srgh'

        StrengthRatio = b'srgR'

        Strength_PLUGIN = b'Strg'

        StrokeDetail = b'StDt'

        StrokeDirection = b'SDir'

        StrokeLength = b'StrL'

        StrokePressure = b'StrP'

        StrokeSize = b'StrS'

        StrokeWidth = b'StrW'

        Style = b'Styl'

        Styles = b'Stys'

        StylusIsColor = b'StlC'

        StylusIsOpacity = b'StlO'

        StylusIsPressure = b'StlP'

        StylusIsSize = b'StlS'

        SubPathList = b'SbpL'

        SupplementalCategories = b'SplC'

        SystemInfo = b'SstI'

        SystemPalette = b'SstP'

        Target = b'null'

        TargetPath = b'Trgp'

        TargetPathIndex = b'TrgP'

        TermLength = b'Lngt'

        Text = b'Txt '

        TextClickPoint = b'TxtC'

        TextData = b'TxtD'

        TextStyle = b'TxtS'

        TextStyleRange = b'Txtt'

        Texture = b'Txtr'

        TextureCoverage = b'TxtC'

        TextureFile = b'TxtF'

        TextureType = b'TxtT'

        Threshold = b'Thsh'

        TileNumber = b'TlNm'

        TileOffset = b'TlOf'

        TileSize = b'TlSz'

        Title = b'Ttl '

        To = b'T '

        ToBuiltin = b'TBl '

        ToLinked = b'ToLk'

        ToMode = b'TMd '

        ToggleOthers = b'TglO'

        Tolerance = b'Tlrn'

        Top = b'Top '

        TotalLimit = b'TtlL'

        Tracking = b'Trck'

        TransferFunction = b'TrnF'

        TransferSpec = b'TrnS'

        Transparency = b'Trns'

        TransparencyGrid = b'TrnG'

        TransparencyGridColors = b'TrnC'

        TransparencyGridSize = b'TrnG'

        TransparencyPrefs = b'TrnP'

        TransparencyShape = b'TrnS'

        TransparentIndex = b'TrnI'

        TransparentWhites = b'TrnW'

        Twist = b'Twst'

        Type = b'Type'

        UCA = b'UC '

        URL = b'URL '

        UndefinedArea = b'UndA'

        Underline = b'Undl'

        UnitsPrefs = b'UntP'

        Untitled = b'Untl'

        UpperY = b'UppY'

        Urgency = b'Urgn'

        UseAccurateScreens = b'AcrS'

        UseAdditionalPlugins = b'AdPl'

        UseCacheForHistograms = b'UsCc'

        UseCurves = b'UsCr'

        UseDefault = b'UsDf'

        UseGlobalAngle = b'uglg'

        UseICCProfile = b'UsIC'

        UseMask = b'UsMs'

        UserMaskEnabled = b'UsrM'

        UserMaskLinked = b'Usrs'

        Using = b'Usng'

        Value = b'Vl '

        Variance = b'Vrnc'

        Vector0 = b'Vct0'

        Vector1 = b'Vct1'

        VectorColor = b'VctC'

        VersionFix = b'VrsF'

        VersionMajor = b'VrsM'

        VersionMinor = b'VrsN'

        Vertical = b'Vrtc'

        VerticalScale = b'VrtS'

        VideoAlpha = b'Vdlp'

        Visible = b'Vsbl'

        WatchSuspension = b'WtcS'

        Watermark = b'watr'

        WaveType = b'Wvtp'

        WavelengthMax = b'WLMx'

        WavelengthMin = b'WLMn'

        WebdavPrefs = b'WbdP'

        WetEdges = b'Wtdg'

        What = b'What'

        WhiteClip = b'WhtC'

        WhiteIntensity = b'WhtI'

        WhiteIsHigh = b'WhHi'

        WhiteLevel = b'WhtL'

        WhitePoint = b'WhtP'

        WholePath = b'WhPt'

        Width = b'Wdth'

        WindMethod = b'WndM'

        With = b'With'

        WorkPath = b'WrPt'

        WorkPathIndex = b'WrkP'

        X = b'X '

        Y = b'Y '

        Yellow = b'Ylw '

        ZigZagType = b'ZZTy'

        _3DAntiAlias = b'Alis'

        comp = b'comp'

  Type

    class psd_tools.terminology.Type(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None)
        Type definitions extracted from PITerminology.h.

        See https://www.adobe.com/devnet/photoshop/sdk.html

        ActionData = b'ActD'

        ActionReference = b'#Act'

        AlignDistributeSelector = b'ADSt'

        Alignment = b'Alg '

        Amount = b'Amnt'

        AntiAlias = b'Annt'

        AreaSelector = b'ArSl'

        AssumeOptions = b'AssO'

        BevelEmbossStampStyle = b'BESs'

        BevelEmbossStyle = b'BESl'

        BitDepth = b'BtDp'

        BlackGeneration = b'BlcG'

        BlendMode = b'BlnM'

        BlurMethod = b'BlrM'

        BlurQuality = b'BlrQ'

        BrushType = b'BrsT'

        BuiltInContour = b'BltC'

        BuiltinProfile = b'BltP'

        CMYKSetupEngine = b'CMYE'

        Calculation = b'Clcn'

        Channel = b'Chnl'

        ChannelReference = b'#ChR'

        CheckerboardSize = b'Chck'

        ClassColor = b'#Clr'

        ClassElement = b'#ClE'

        ClassExport = b'#Cle'

        ClassFormat = b'#ClF'

        ClassHueSatHueSatV2 = b'#HsV'

        ClassImport = b'#ClI'

        ClassMode = b'#ClM'

        ClassStringFormat = b'#ClS'

        ClassTextExport = b'#CTE'

        ClassTextImport = b'#ClT'

        Color = b'Clr '

        ColorChannel = b'#ClC'

        ColorPalette = b'ClrP'

        ColorSpace = b'ClrS'

        ColorStopType = b'Clry'

        Colors = b'Clrs'

        Compensation = b'Cmpn'

        ContourEdge = b'CntE'

        Convert = b'Cnvr'

        CorrectionMethod = b'CrcM'

        CursorKind = b'CrsK'

        DCS = b'DCS '

        DeepDepth = b'DpDp'

        Depth = b'Dpth'

        DiffuseMode = b'DfsM'

        Direction = b'Drct'

        DisplacementMap = b'DspM'

        Distribution = b'Dstr'

        Dither = b'Dthr'

        DitherQuality = b'Dthq'

        DocumentReference = b'#DcR'

        EPSPreview = b'EPSP'

        ElementReference = b'#ElR'

        Encoding = b'Encd'

        EraserKind = b'ErsK'

        ExtrudeRandom = b'ExtR'

        ExtrudeType = b'ExtT'

        EyeDropperSample = b'EyDp'

        FPXCompress = b'FxCm'

        Fill = b'Fl '

        FillColor = b'FlCl'

        FillContents = b'FlCn'

        FillMode = b'FlMd'

        ForcedColors = b'FrcC'

        FrameFill = b'FrFl'

        FrameStyle = b'FStl'

        GIFColorFileType = b'GFPT'

        GIFPaletteType = b'GFPL'

        GIFRequiredColorSpaceType = b'GFCS'

        GIFRowOrderType = b'GFIT'

        GlobalClass = b'GlbC'

        GlobalObject = b'GlbO'

        GradientForm = b'GrdF'

        GradientType = b'GrdT'

        GrainType = b'Grnt'

        GrayBehavior = b'GrBh'

        GuideGridColor = b'GdGr'

        GuideGridStyle = b'GdGS'

        HistoryStateSource = b'HstS'

        HorizontalLocation = b'HrzL'

        ImageReference = b'#ImR'

        InnerGlowSource = b'IGSr'

        IntegerChannel = b'#inC'

        Intent = b'Inte'

        InterlaceCreateType = b'IntC'

        InterlaceEliminateType = b'IntE'

        Interpolation = b'Intp'

        Kelvin = b'Klvn'

        KelvinCustomWhitePoint = b'#Klv'

        Lens = b'Lns '

        LightDirection = b'LghD'

        LightPosition = b'LghP'

        LightType = b'LghT'

        LocationReference = b'#Lct'

        MaskIndicator = b'MskI'

        MatteColor = b'MttC'

        MatteTechnique = b'BETE'

        MenuItem = b'MnIt'

        Method = b'Mthd'

        MezzotintType = b'MztT'

        Mode = b'Md '

        Notify = b'Ntfy'

        Object = b'Objc'

        ObjectReference = b'obj '

        OnOff = b'OnOf'

        Ordinal = b'Ordn'

        Orientation = b'Ornt'

        PNGFilter = b'PNGf'

        PNGInterlaceType = b'PGIT'

        PagePosition = b'PgPs'

        PathKind = b'PthK'

        PathReference = b'#PtR'

        Phosphors = b'Phsp'

        PhosphorsCustomPhosphors = b'#Phs'

        PickerKind = b'PckK'

        PixelPaintSize = b'PPSz'

        Platform = b'Pltf'

        Preview = b'Prvw'

        PreviewCMYK = b'Prvt'

        ProfileMismatch = b'PrfM'

        PurgeItem = b'PrgI'

        QuadCenterState = b'QCSt'

        Quality = b'Qlty'

        QueryState = b'QurS'

        RGBSetupSource = b'RGBS'

        RawData = b'tdta'

        RippleSize = b'RplS'

        RulerUnits = b'RlrU'

        ScreenType = b'ScrT'

        Shape = b'Shp '

        SmartBlurMode = b'SmBM'

        SmartBlurQuality = b'SmBQ'

        SourceMode = b'Cndn'

        SpherizeMode = b'SphM'

        State = b'Stte'

        StringChannel = b'#sth'

        StringClassFormat = b'#StC'

        StringCompensation = b'#Stm'

        StringFSS = b'#Stf'

        StringInteger = b'#StI'

        StrokeDirection = b'StrD'

        StrokeLocation = b'StrL'

        TextureType = b'TxtT'

        TransparencyGridColors = b'Trnl'

        TransparencyGridSize = b'TrnG'

        TypeClassModeOrClassMode = b'#TyM'

        UndefinedArea = b'UndA'

        UnitFloat = b'UntF'

        Urgency = b'Urgn'

        UserMaskOptions = b'UsrM'

        ValueList = b'VlLs'

        VerticalLocation = b'VrtL'

        WaveType = b'Wvtp'

        WindMethod = b'WndM'

        YesNo = b'YsN '

        ZigZagType = b'ZZTy'

  Unit

    class psd_tools.terminology.Unit(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None)
        Unit definitions extracted from PITerminology.h.

        See https://www.adobe.com/devnet/photoshop/sdk.html

        Angle = b'#Ang'

        Density = b'#Rsl'

        Distance = b'#Rlt'

        Millimeters = b'#Mlm'

        Percent = b'#Prc'

        Pixels = b'#Pxl'

        Points = b'#Pnt'

        _None = b'#Nne'

INDICES AND TABLES

    •   Index

    •   Module Index

    •   Search Page

AUTHOR
Kota Yamaguchi

COPYRIGHT
2019, Kota Yamaguchi