Provided by: python3-psd-tools_1.9.34+dfsg.1-1build2_amd64 
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
1.9.34 Mar 04, 2025 SRC(1)