aspose-com-gists/Aspose.PSD for Python via .NET

## 12 changes: 12 additions & 0 deletions Documentation-Python-Aspose-Psd-Convert-Ai-To-Jpeg.py
@@ -0,0 +1,12 @@

    from aspose.psd import Image
from aspose.psd import Image

    from aspose.psd.imageoptions import JpegOptions
from aspose.psd.imageoptions import JpegOptions


    # Converting of AI Image to Jpeg
# Converting of AI Image to Jpeg

    def Convert_AI_to_JPEG():
def Convert_AI_to_JPEG():

        sourceFile = "raster.ai"
    sourceFile = "raster.ai"

        outputFile = "raster_output.jpg"
    outputFile = "raster_output.jpg"


        jpegOptions = JpegOptions()
    jpegOptions = JpegOptions()

        jpegOptions.quality = 95
    jpegOptions.quality = 95

        with Image.load(sourceFile) as image:
    with Image.load(sourceFile) as image:

            image.save(outputFile, jpegOptions)
        image.save(outputFile, jpegOptions)

## 7 changes: 7 additions & 0 deletions Documentation-Python-Aspose-Psd-Convert-Ai-To-Pdf.py
@@ -0,0 +1,7 @@

    # Converting of AI Image to PDF
# Converting of AI Image to PDF

    def Convert_AI_to_PDF():
def Convert_AI_to_PDF():

        sourceFile = "raster.ai"
    sourceFile = "raster.ai"

        outputFile = "output.pdf"
    outputFile = "output.pdf"


        with Image.load(sourceFile) as image:
    with Image.load(sourceFile) as image:

            image.save(outputFile, PdfOptions())
        image.save(outputFile, PdfOptions())

## 10 changes: 10 additions & 0 deletions Documentation-Python-Aspose-Psd-Convert-Ai-To-Png.py
@@ -0,0 +1,10 @@

    from aspose.psd import Image
from aspose.psd import Image

    from aspose.psd.imageoptions import PngOptions
from aspose.psd.imageoptions import PngOptions


    # Converting of AI Image to PNG
# Converting of AI Image to PNG

    def Convert_AI_to_PNG():
def Convert_AI_to_PNG():

        sourceFile = "raster.ai"
    sourceFile = "raster.ai"

        outputFile = "raster_output.png"
    outputFile = "raster_output.png"


        with Image.load(sourceFile) as image:
    with Image.load(sourceFile) as image:

            image.save(outputFile, PngOptions())
        image.save(outputFile, PngOptions())

## 12 changes: 12 additions & 0 deletions Documentation-Python-Aspose-Psd-Convert-Between-Different-Color-Modes.py
@@ -0,0 +1,12 @@

      # This example from Aspose.PSD for Python Gist
  # This example from Aspose.PSD for Python Gist


      def ConvertBetweenColorModesAndBitDepthTest():
  def ConvertBetweenColorModesAndBitDepthTest():

            source_file_name = "John-OConnor_Spring-Reflections_example.psd"
        source_file_name = "John-OConnor_Spring-Reflections_example.psd"

            output_file_name = "result.psd"
        output_file_name = "result.psd"


            with PsdImage.load(source_file_name) as image:
        with PsdImage.load(source_file_name) as image:

                psdSaveOpt = PsdOptions()
            psdSaveOpt = PsdOptions()

                psdSaveOpt.channels_count = 5
            psdSaveOpt.channels_count = 5

                psdSaveOpt.color_mode = ColorModes.CMYK
            psdSaveOpt.color_mode = ColorModes.CMYK

                psdSaveOpt.compression_method = CompressionMethod.RLE
            psdSaveOpt.compression_method = CompressionMethod.RLE

                image.save(output_file_name, psdSaveOpt)
            image.save(output_file_name, psdSaveOpt)

## 37 changes: 37 additions & 0 deletions Documentation-Python-Aspose-Psd-add-layer-from-file-for-editing.py
@@ -0,0 +1,37 @@

    # This example from Aspose.PSD for Python Gist
# This example from Aspose.PSD for Python Gist


    from io import BytesIO
from io import BytesIO

    from aspose.psd.fileformats.psd import PsdImage
from aspose.psd.fileformats.psd import PsdImage

    from aspose.psd.fileformats.psd.layers import Layer
from aspose.psd.fileformats.psd.layers import Layer


    inputFile = "inputFile.png"
inputFile = "inputFile.png"

    outputFile = "AddFileAsLayer.psd"
outputFile = "AddFileAsLayer.psd"


    # Open file as Stream
# Open file as Stream

    with open(inputFile, "rb", buffering=0) as filestream:
with open(inputFile, "rb", buffering=0) as filestream:

        stream = BytesIO(filestream.read())
    stream = BytesIO(filestream.read())

        stream.seek(0)
    stream.seek(0)


        # Create PSD Layer from Stream
    # Create PSD Layer from Stream

        layer = Layer(stream)
    layer = Layer(stream)


        # Create PSD Image with the specified size
    # Create PSD Image with the specified size

        psdImage = PsdImage(layer.width, layer.height)
    psdImage = PsdImage(layer.width, layer.height)


        # Add Layer to PSD Image
    # Add Layer to PSD Image

        psdImage.layers = [layer]
    psdImage.layers = [layer]


        # Get Pixels from File
    # Get Pixels from File

        pixels = layer.load_argb_32_pixels(layer.bounds)
    pixels = layer.load_argb_32_pixels(layer.bounds)

        pixelsRange = range(len(pixels))
    pixelsRange = range(len(pixels))


        # Fill the pixels data with some values
    # Fill the pixels data with some values

        for i in pixelsRange:
    for i in pixelsRange:

            if i % 5 == 0:
        if i % 5 == 0:

                pixels[i] = 500000
            pixels[i] = 500000


        # Fast Save of Updated Image Data
    # Fast Save of Updated Image Data

        layer.save_argb_32_pixels(layer.bounds, pixels)
    layer.save_argb_32_pixels(layer.bounds, pixels)


        # Save PSD Image
    # Save PSD Image

        psdImage.save(outputFile)
    psdImage.save(outputFile)

## 30 changes: 30 additions & 0 deletions Documentation-Python-Aspose-Psd-blending-options.py
@@ -0,0 +1,30 @@

    from aspose.psd import Image, Color
from aspose.psd import Image, Color

    from aspose.psd.fileformats.core.blending import BlendMode
from aspose.psd.fileformats.core.blending import BlendMode

    from aspose.psd.imageoptions import PsdOptions, PngOptions
from aspose.psd.imageoptions import PsdOptions, PngOptions

    from aspose.pycore import cast, is_assignable
from aspose.pycore import cast, is_assignable

    from aspose.psd.fileformats.png import PngColorType
from aspose.psd.fileformats.png import PngColorType


            source = "AllTypesLayerPsd2.psd"
        source = "AllTypesLayerPsd2.psd"

            output_original = "original.png"
        output_original = "original.png"

            output_updated = "output_updated.png"
        output_updated = "output_updated.png"


            with PsdImage.load(source) as image:
        with PsdImage.load(source) as image:

                psdImage = cast(PsdImage, image)
            psdImage = cast(PsdImage, image)

                pngSaveOpt = PngOptions()
            pngSaveOpt = PngOptions()

                pngSaveOpt.color_type = PngColorType.TRUECOLOR_WITH_ALPHA
            pngSaveOpt.color_type = PngColorType.TRUECOLOR_WITH_ALPHA

                image.save(output_original, pngSaveOpt)
            image.save(output_original, pngSaveOpt)


                 # Change opacity and/or blending mode of layer
             # Change opacity and/or blending mode of layer

                psdImage.layers[1].opacity = 100
            psdImage.layers[1].opacity = 100

                psdImage.layers[4].blend_mode_key = BlendMode.HUE
            psdImage.layers[4].blend_mode_key = BlendMode.HUE


                # Add effects like shadow and color overlay and set it up
            # Add effects like shadow and color overlay and set it up

                shadow = psdImage.layers[7].blending_options.add_drop_shadow()
            shadow = psdImage.layers[7].blending_options.add_drop_shadow()

                shadow.angle = 30
            shadow.angle = 30

                shadow.color = Color.from_argb(255, 255, 0)
            shadow.color = Color.from_argb(255, 255, 0)


                psdImage.layers[9].blend_mode_key = BlendMode.LIGHTEN
            psdImage.layers[9].blend_mode_key = BlendMode.LIGHTEN

                colorOverlay = psdImage.layers[5].blending_options.add_color_overlay()
            colorOverlay = psdImage.layers[5].blending_options.add_color_overlay()

                colorOverlay.color = Color.from_argb(200, 30, 50)
            colorOverlay.color = Color.from_argb(200, 30, 50)

                colorOverlay.opacity = 150
            colorOverlay.opacity = 150

                image.save(output_updated, pngSaveOpt)
            image.save(output_updated, pngSaveOpt)

## 29 changes: 29 additions & 0 deletions Documentation-Python-Aspose-Psd-create-psd-psb-images-from-scratch.py
@@ -0,0 +1,29 @@

    from aspose.psd import Graphics, Pen, Color, Rectangle
from aspose.psd import Graphics, Pen, Color, Rectangle

    from aspose.psd.brushes import LinearGradientBrush
from aspose.psd.brushes import LinearGradientBrush

    from aspose.psd.fileformats.psd import PsdImage
from aspose.psd.fileformats.psd import PsdImage


    outputFile = "CreateFileFromScratchExample.psd"
outputFile = "CreateFileFromScratchExample.psd"


    # Create PSD Image with specified dimensions
# Create PSD Image with specified dimensions

    with PsdImage(500, 500) as img:
with PsdImage(500, 500) as img:

        # Create Regular PSD Layer and update it with Graphic API
    # Create Regular PSD Layer and update it with Graphic API

        regularLayer = img.add_regular_layer()
    regularLayer = img.add_regular_layer()


        # Use popular Graphic API for Editing
    # Use popular Graphic API for Editing

        graphics = Graphics(regularLayer)
    graphics = Graphics(regularLayer)

        pen = Pen(Color.alice_blue)
    pen = Pen(Color.alice_blue)

        brush = LinearGradientBrush(Rectangle(250, 250, 150, 100), Color.red, Color.aquamarine, 45)
    brush = LinearGradientBrush(Rectangle(250, 250, 150, 100), Color.red, Color.aquamarine, 45)

        graphics.draw_ellipse(pen, Rectangle(100, 100, 200, 200))
    graphics.draw_ellipse(pen, Rectangle(100, 100, 200, 200))

        graphics.fill_ellipse(brush, Rectangle(250, 250, 150, 100))
    graphics.fill_ellipse(brush, Rectangle(250, 250, 150, 100))


        # Create Text Layer
    # Create Text Layer

        textLayer = img.add_text_layer("Sample Text", Rectangle(200, 200, 100, 100))
    textLayer = img.add_text_layer("Sample Text", Rectangle(200, 200, 100, 100))


        # Adding Shadow to Text
    # Adding Shadow to Text

        dropShadowEffect = textLayer.blending_options.add_drop_shadow()
    dropShadowEffect = textLayer.blending_options.add_drop_shadow()

        dropShadowEffect.distance = 0
    dropShadowEffect.distance = 0

        dropShadowEffect.size = 8
    dropShadowEffect.size = 8

        dropShadowEffect.color = Color.blue
    dropShadowEffect.color = Color.blue


        # Save PSD File
    # Save PSD File

        img.save(outputFile)
    img.save(outputFile)

## 21 changes: 21 additions & 0 deletions Documentation-Python-Aspose-Psd-graphics-api.py
@@ -0,0 +1,21 @@

            loadOpt = PsdLoadOptions()
        loadOpt = PsdLoadOptions()

            loadOpt.load_effects_resource = True
        loadOpt.load_effects_resource = True

            loadOpt.allow_warp_repaint = True
        loadOpt.allow_warp_repaint = True


            inputFile = "AllTypesLayerPsd.psd"
        inputFile = "AllTypesLayerPsd.psd"


            psdName = "using_graphics_output.psd"
        psdName = "using_graphics_output.psd"

            pngName = "using_graphics_output.png"
        pngName = "using_graphics_output.png"


            with Image.load(inputFile, loadOpt) as image:
        with Image.load(inputFile, loadOpt) as image:

                psdImage = cast(PsdImage, image)
            psdImage = cast(PsdImage, image)

                layer = psdImage.layers[0]
            layer = psdImage.layers[0]

                # You can use Graphics API for editing layers
            # You can use Graphics API for editing layers

                graphics = Graphics(layer)
            graphics = Graphics(layer)

                pen = Pen(Color.alice_blue)
            pen = Pen(Color.alice_blue)

                brush = LinearGradientBrush(Rectangle(250, 250, 150, 100), Color.red, Color.aquamarine, 45)
            brush = LinearGradientBrush(Rectangle(250, 250, 150, 100), Color.red, Color.aquamarine, 45)

                graphics.draw_ellipse(pen, Rectangle(100, 100, 200, 200))
            graphics.draw_ellipse(pen, Rectangle(100, 100, 200, 200))

                graphics.fill_ellipse(brush, Rectangle(250, 250, 150, 100))
            graphics.fill_ellipse(brush, Rectangle(250, 250, 150, 100))


                psdImage.save(psdName)
            psdImage.save(psdName)

                psdImage.save(pngName, PngOptions())
            psdImage.save(pngName, PngOptions())

## 99 changes: 99 additions & 0 deletions Documentation-Python-Aspose-Psd-layer-effects.py
@@ -0,0 +1,99 @@

    from aspose.psd import Image, Color
from aspose.psd import Image, Color

    from aspose.psd.fileformats.png import PngColorType
from aspose.psd.fileformats.png import PngColorType

    from aspose.psd.fileformats.psd import PsdImage
from aspose.psd.fileformats.psd import PsdImage

    from aspose.psd.fileformats.psd.layers.fillsettings import GradientColorPoint, GradientTransparencyPoint, FillType, \
from aspose.psd.fileformats.psd.layers.fillsettings import GradientColorPoint, GradientTransparencyPoint, FillType, \

        GradientFillSettings, PatternFillSettings, ColorFillSettings
    GradientFillSettings, PatternFillSettings, ColorFillSettings

    from aspose.psd.imageloadoptions import PsdLoadOptions
from aspose.psd.imageloadoptions import PsdLoadOptions

    from aspose.psd.imageoptions import PngOptions
from aspose.psd.imageoptions import PngOptions

    from aspose.pycore import cast
from aspose.pycore import cast


    def LayerEffectsFullTest(self):
def LayerEffectsFullTest(self):

        source = self.GetFileInBaseFolderByIssue("ShowCases", "nines.psd")
    source = self.GetFileInBaseFolderByIssue("ShowCases", "nines.psd")

        result_orig = self.GetFileInOutputFolder("nines_orig.png")
    result_orig = self.GetFileInOutputFolder("nines_orig.png")

        result_psd = self.GetFileInOutputFolder("nines_mod.psd")
    result_psd = self.GetFileInOutputFolder("nines_mod.psd")

        result_mod = self.GetFileInOutputFolder("nines_mod.png")
    result_mod = self.GetFileInOutputFolder("nines_mod.png")


        # Set the PNG options
    # Set the PNG options

        png_opt = PngOptions()
    png_opt = PngOptions()

        png_opt.color_type = PngColorType.TRUECOLOR_WITH_ALPHA
    png_opt.color_type = PngColorType.TRUECOLOR_WITH_ALPHA


        # Set the PSD load options
    # Set the PSD load options

        psd_opt = PsdLoadOptions()
    psd_opt = PsdLoadOptions()

        psd_opt.load_effects_resource = True
    psd_opt.load_effects_resource = True


        # Load the PSD image
    # Load the PSD image

        with Image.load(source, psd_opt) as img:
    with Image.load(source, psd_opt) as img:

            # Cast to PsdImage
        # Cast to PsdImage

            image = cast(PsdImage, img)
        image = cast(PsdImage, img)


            # Save the original image as PNG
        # Save the original image as PNG

            image.save(result_orig, png_opt)
        image.save(result_orig, png_opt)


            # Test data for gradient
        # Test data for gradient

            gradient_color_points = [
        gradient_color_points = [

                GradientColorPoint(Color.red, 0, 50),
            GradientColorPoint(Color.red, 0, 50),

                GradientColorPoint(Color.green, 1024, 50),
            GradientColorPoint(Color.green, 1024, 50),

                GradientColorPoint(Color.blue, 2048, 50)
            GradientColorPoint(Color.blue, 2048, 50)

            ]
        ]


            tp1 = GradientTransparencyPoint()
        tp1 = GradientTransparencyPoint()

            tp1.location = 0
        tp1.location = 0

            tp1.median_point_location = 50
        tp1.median_point_location = 50

            tp1.opacity = 128
        tp1.opacity = 128


            tp2 = GradientTransparencyPoint()
        tp2 = GradientTransparencyPoint()

            tp2.location = 2048
        tp2.location = 2048

            tp2.median_point_location = 50
        tp2.median_point_location = 50

            tp2.opacity = 176
        tp2.opacity = 176

            gradient_transparency_points = [tp1, tp2]
        gradient_transparency_points = [tp1, tp2]


            # Add stroke to layer 1
        # Add stroke to layer 1

            stroke = image.layers[1].blending_options.add_stroke(FillType.GRADIENT)
        stroke = image.layers[1].blending_options.add_stroke(FillType.GRADIENT)

            stroke.size = 3
        stroke.size = 3

            gradient_fill = cast(GradientFillSettings, stroke.fill_settings)
        gradient_fill = cast(GradientFillSettings, stroke.fill_settings)

            gradient_fill.color_points = gradient_color_points
        gradient_fill.color_points = gradient_color_points

            gradient_fill.transparency_points = gradient_transparency_points
        gradient_fill.transparency_points = gradient_transparency_points


            # Add inner shadow to layer 2
        # Add inner shadow to layer 2

            inner_shadow = image.layers[2].blending_options.add_inner_shadow()
        inner_shadow = image.layers[2].blending_options.add_inner_shadow()

            inner_shadow.angle = 60
        inner_shadow.angle = 60

            inner_shadow.color = Color.yellow
        inner_shadow.color = Color.yellow


            # Add drop shadow to layer 3
        # Add drop shadow to layer 3

            drop_shadow = image.layers[3].blending_options.add_drop_shadow()
        drop_shadow = image.layers[3].blending_options.add_drop_shadow()

            drop_shadow.angle = 30
        drop_shadow.angle = 30

            drop_shadow.color = Color.violet
        drop_shadow.color = Color.violet


            # Add gradient overlay to layer 4
        # Add gradient overlay to layer 4

            gradient_overlay = image.layers[4].blending_options.add_gradient_overlay()
        gradient_overlay = image.layers[4].blending_options.add_gradient_overlay()

            gradient_overlay.settings.color_points = gradient_color_points
        gradient_overlay.settings.color_points = gradient_color_points

            gradient_overlay.settings.transparency_points = gradient_transparency_points
        gradient_overlay.settings.transparency_points = gradient_transparency_points


            # Add color overlay to layer 5
        # Add color overlay to layer 5

            color_overlay = image.layers[5].blending_options.add_color_overlay()
        color_overlay = image.layers[5].blending_options.add_color_overlay()

            color_overlay.color = Color.azure
        color_overlay.color = Color.azure

            color_overlay.opacity = 120
        color_overlay.opacity = 120


            # Add pattern overlay to layer 6
        # Add pattern overlay to layer 6

            pattern_overlay = image.layers[6].blending_options.add_pattern_overlay()
        pattern_overlay = image.layers[6].blending_options.add_pattern_overlay()


            patSettings = cast(PatternFillSettings, pattern_overlay.settings)
        patSettings = cast(PatternFillSettings, pattern_overlay.settings)


            patSettings.pattern_data = [
        patSettings.pattern_data = [

                Color.red.to_argb(), Color.transparent.to_argb(),
            Color.red.to_argb(), Color.transparent.to_argb(),

                Color.transparent.to_argb(), Color.red.to_argb()
            Color.transparent.to_argb(), Color.red.to_argb()

            ]
        ]


            patSettings.pattern_width = 2
        patSettings.pattern_width = 2

            patSettings.pattern_height = 2
        patSettings.pattern_height = 2


            # Add outer glow to layer 7
        # Add outer glow to layer 7

            outer_glow = image.layers[7].blending_options.add_outer_glow()
        outer_glow = image.layers[7].blending_options.add_outer_glow()

            outer_glow.size = 10
        outer_glow.size = 10

            outer_glow.fill_color = ColorFillSettings()
        outer_glow.fill_color = ColorFillSettings()

            outer_glow.fill_color.color = Color.crimson
        outer_glow.fill_color.color = Color.crimson


            # Save the modified image as PNG and PSD
        # Save the modified image as PNG and PSD

            image.save(result_mod, png_opt)
        image.save(result_mod, png_opt)

            image.save(result_psd)
        image.save(result_psd)

## 63 changes: 63 additions & 0 deletions ...ation-Python-Aspose-Psd-open-export-psd-psb-ai-images-to-pdf-jpeg-png-tiff-bmp-gif-bmp.py
@@ -0,0 +1,63 @@

    from aspose.psd.fileformats.ai import AiImage
from aspose.psd.fileformats.ai import AiImage

    from aspose.psd.fileformats.png import PngColorType
from aspose.psd.fileformats.png import PngColorType

    from aspose.psd.fileformats.psd import PsdImage
from aspose.psd.fileformats.psd import PsdImage

    from aspose.psd.fileformats.tiff.enums import TiffExpectedFormat
from aspose.psd.fileformats.tiff.enums import TiffExpectedFormat

    from aspose.psd.imageoptions import PngOptions, PdfOptions, TiffOptions, JpegOptions, BmpOptions, Jpeg2000Options, \
from aspose.psd.imageoptions import PngOptions, PdfOptions, TiffOptions, JpegOptions, BmpOptions, Jpeg2000Options, \

        GifOptions, PsdOptions
    GifOptions, PsdOptions


    def ExportPsdAndAIToDifferentFormatsTest(self):
def ExportPsdAndAIToDifferentFormatsTest(self):

        # Saving to PNG
    # Saving to PNG

        pngSaveOpt = PngOptions()
    pngSaveOpt = PngOptions()

        pngSaveOpt.color_type = PngColorType.TRUECOLOR_WITH_ALPHA
    pngSaveOpt.color_type = PngColorType.TRUECOLOR_WITH_ALPHA


        # Saving to PDF
    # Saving to PDF

        pdfSaveOpt = PdfOptions()
    pdfSaveOpt = PdfOptions()


        # Saving to Tiff
    # Saving to Tiff

        tiffSaveOpt = TiffOptions(TiffExpectedFormat.TIFF_NO_COMPRESSION_RGBA)
    tiffSaveOpt = TiffOptions(TiffExpectedFormat.TIFF_NO_COMPRESSION_RGBA)


        # Saving to Jpeg
    # Saving to Jpeg

        jpegSaveOpt = JpegOptions()
    jpegSaveOpt = JpegOptions()

        jpegSaveOpt.quality = 90
    jpegSaveOpt.quality = 90


        # Saving to BMP
    # Saving to BMP

        bmpSaveOpt = BmpOptions()
    bmpSaveOpt = BmpOptions()


        # Saving to JPEG2000
    # Saving to JPEG2000

        j2kSaveOpt = Jpeg2000Options()
    j2kSaveOpt = Jpeg2000Options()


        # Saving to GIF
    # Saving to GIF

        gifSaveOpt = GifOptions()
    gifSaveOpt = GifOptions()


        # Saving to PSB
    # Saving to PSB

        psbSaveOpt = PsdOptions()
    psbSaveOpt = PsdOptions()

        psbSaveOpt.version = 2
    psbSaveOpt.version = 2


        # Saving to PSD
    # Saving to PSD

        psdSaveOpt = PsdOptions()
    psdSaveOpt = PsdOptions()


        formats = {
    formats = {

            "pdf": pdfSaveOpt,
        "pdf": pdfSaveOpt,

            "jpg": jpegSaveOpt,
        "jpg": jpegSaveOpt,

            "png": pngSaveOpt,
        "png": pngSaveOpt,

            "tif": tiffSaveOpt,
        "tif": tiffSaveOpt,

            "gif": gifSaveOpt,
        "gif": gifSaveOpt,

            "j2k": j2kSaveOpt,
        "j2k": j2kSaveOpt,

            "bmp": bmpSaveOpt,
        "bmp": bmpSaveOpt,

            "psb": psbSaveOpt,
        "psb": psbSaveOpt,

            "psd": psdSaveOpt
        "psd": psdSaveOpt

        }
    }


        # Saving PSD to other formats
    # Saving PSD to other formats

        sourcePsd = "AllTypesLayerPsd2.psd"
    sourcePsd = "AllTypesLayerPsd2.psd"

        with PsdImage.load(sourcePsd) as image:
    with PsdImage.load(sourcePsd) as image:

            for format, saveOpt in formats.items():
        for format, saveOpt in formats.items():

                fn =  "export.psd.to." + format
            fn =  "export.psd.to." + format

                image.save(fn, saveOpt)
            image.save(fn, saveOpt)


        # Saving AI to other formats
    # Saving AI to other formats

        sourceAi = "ai_one_text_3.ai"
    sourceAi = "ai_one_text_3.ai"

        with AiImage.load(sourceAi) as image:
    with AiImage.load(sourceAi) as image:

            for format, saveOpt in formats.items():
        for format, saveOpt in formats.items():

                fn = "export.ai.to." + format
            fn = "export.ai.to." + format

                image.save(fn, saveOpt)
            image.save(fn, saveOpt)

## 102 changes: 102 additions & 0 deletions Documentation-Python-Aspose-adjustment-layer-enhancement.py
@@ -0,0 +1,102 @@

    from aspose.psd import Color
from aspose.psd import Color

    from aspose.psd.fileformats.png import PngColorType
from aspose.psd.fileformats.png import PngColorType

    from aspose.psd.fileformats.psd import PsdImage
from aspose.psd.fileformats.psd import PsdImage

    from aspose.psd.fileformats.psd.layers.adjustmentlayers import BrightnessContrastLayer, LevelsLayer, CurvesLayer, \
from aspose.psd.fileformats.psd.layers.adjustmentlayers import BrightnessContrastLayer, LevelsLayer, CurvesLayer, \

        ExposureLayer, HueSaturationLayer, ColorBalanceAdjustmentLayer, BlackWhiteAdjustmentLayer, PhotoFilterLayer, \
    ExposureLayer, HueSaturationLayer, ColorBalanceAdjustmentLayer, BlackWhiteAdjustmentLayer, PhotoFilterLayer, \

        ChannelMixerLayer, RgbMixerChannel, InvertAdjustmentLayer, PosterizeLayer, ThresholdLayer, SelectiveColorLayer, \
    ChannelMixerLayer, RgbMixerChannel, InvertAdjustmentLayer, PosterizeLayer, ThresholdLayer, SelectiveColorLayer, \

        CmykCorrection, SelectiveColorsTypes
    CmykCorrection, SelectiveColorsTypes

    from aspose.psd.fileformats.psd.layers.layerresources import CurvesContinuousManager
from aspose.psd.fileformats.psd.layers.layerresources import CurvesContinuousManager

    from aspose.psd.imageoptions import PngOptions
from aspose.psd.imageoptions import PngOptions

    from aspose.pycore import cast, is_assignable
from aspose.pycore import cast, is_assignable


    def AdjustmentLayerEnhancementTest():
def AdjustmentLayerEnhancementTest():

        sourcePsd = "AllAdjustments.psd"
    sourcePsd = "AllAdjustments.psd"

        outputOrigPng = "AllAdjustments_orig.png"
    outputOrigPng = "AllAdjustments_orig.png"

        outputModPng = "AllAdjustments_mod.png"
    outputModPng = "AllAdjustments_mod.png"

        pngOpt = PngOptions()
    pngOpt = PngOptions()

        pngOpt.color_type = PngColorType.TRUECOLOR_WITH_ALPHA
    pngOpt.color_type = PngColorType.TRUECOLOR_WITH_ALPHA


        with PsdImage.load(sourcePsd) as image:
    with PsdImage.load(sourcePsd) as image:

            psdImage = cast(PsdImage, image)
        psdImage = cast(PsdImage, image)

            psdImage.save(outputOrigPng, pngOpt)
        psdImage.save(outputOrigPng, pngOpt)

            layers = psdImage.layers
        layers = psdImage.layers


            for layer in layers:
        for layer in layers:

                if is_assignable(layer, BrightnessContrastLayer):
            if is_assignable(layer, BrightnessContrastLayer):

                    br = cast(BrightnessContrastLayer, layer)
                br = cast(BrightnessContrastLayer, layer)

                    br.brightness = -br.brightness
                br.brightness = -br.brightness

                    br.contrast = -br.contrast
                br.contrast = -br.contrast


                if is_assignable(layer, LevelsLayer):
            if is_assignable(layer, LevelsLayer):

                    levels = cast(LevelsLayer, layer)
                levels = cast(LevelsLayer, layer)

                    levels.master_channel.output_shadow_level = 30
                levels.master_channel.output_shadow_level = 30

                    levels.master_channel.input_shadow_level = 5
                levels.master_channel.input_shadow_level = 5

                    levels.master_channel.input_midtone_level = 2
                levels.master_channel.input_midtone_level = 2

                    levels.master_channel.output_highlight_level = 213
                levels.master_channel.output_highlight_level = 213

                    levels.master_channel.input_highlight_level = 120
                levels.master_channel.input_highlight_level = 120


                if is_assignable(layer, CurvesLayer):
            if is_assignable(layer, CurvesLayer):

                    curves = cast(CurvesLayer, layer)
                curves = cast(CurvesLayer, layer)

                    manager = curves.get_curves_manager()
                manager = curves.get_curves_manager()

                    curveManager = cast(CurvesContinuousManager, manager)
                curveManager = cast(CurvesContinuousManager, manager)

                    curveManager.add_curve_point(2, 150, 180)
                curveManager.add_curve_point(2, 150, 180)


                if is_assignable(layer, ExposureLayer):
            if is_assignable(layer, ExposureLayer):

                    exp = cast(ExposureLayer, layer)
                exp = cast(ExposureLayer, layer)

                    exp.exposure = exp.exposure + 0.1
                exp.exposure = exp.exposure + 0.1


                if is_assignable(layer, HueSaturationLayer):
            if is_assignable(layer, HueSaturationLayer):

                    hue = cast(HueSaturationLayer, layer)
                hue = cast(HueSaturationLayer, layer)

                    hue.hue = -15
                hue.hue = -15

                    hue.saturation = 30
                hue.saturation = 30


                if is_assignable(layer, ColorBalanceAdjustmentLayer):
            if is_assignable(layer, ColorBalanceAdjustmentLayer):

                    colorBal = cast(ColorBalanceAdjustmentLayer, layer)
                colorBal = cast(ColorBalanceAdjustmentLayer, layer)

                    colorBal.midtones_cyan_red_balance = 30
                colorBal.midtones_cyan_red_balance = 30


                if is_assignable(layer, BlackWhiteAdjustmentLayer):
            if is_assignable(layer, BlackWhiteAdjustmentLayer):

                    bw = cast(BlackWhiteAdjustmentLayer, layer)
                bw = cast(BlackWhiteAdjustmentLayer, layer)

                    bw.reds = 30
                bw.reds = 30

                    bw.greens = 25
                bw.greens = 25

                    bw.blues = 40
                bw.blues = 40


                if is_assignable(layer, PhotoFilterLayer):
            if is_assignable(layer, PhotoFilterLayer):

                    photoFilter = cast(PhotoFilterLayer, layer)
                photoFilter = cast(PhotoFilterLayer, layer)

                    photoFilter.color = Color.azure
                photoFilter.color = Color.azure


                if is_assignable(layer, ChannelMixerLayer):
            if is_assignable(layer, ChannelMixerLayer):

                    channelMixer = cast(ChannelMixerLayer, layer)
                channelMixer = cast(ChannelMixerLayer, layer)

                    channel = channelMixer.get_channel_by_index(0)
                channel = channelMixer.get_channel_by_index(0)

                    if is_assignable(channel, RgbMixerChannel):
                if is_assignable(channel, RgbMixerChannel):

                        rgbChannel = cast(RgbMixerChannel, channel)
                    rgbChannel = cast(RgbMixerChannel, channel)

                        rgbChannel.green = 120
                    rgbChannel.green = 120

                        rgbChannel.red = 50
                    rgbChannel.red = 50

                        rgbChannel.blue = 70
                    rgbChannel.blue = 70

                        rgbChannel.constant += 10
                    rgbChannel.constant += 10


                if is_assignable(layer, InvertAdjustmentLayer):
            if is_assignable(layer, InvertAdjustmentLayer):

                    # Here is nothing to do ¯\_(ツ)_/¯ If this layer is presented than all colors will be inverted under it.
                # Here is nothing to do ¯\_(ツ)_/¯ If this layer is presented than all colors will be inverted under it.

                    # Also, you can add it to the new image
                # Also, you can add it to the new image

                    # img = PsdImage(100, 100)
                # img = PsdImage(100, 100)

                    # img.AddInvertAdjustmentLayer()
                # img.AddInvertAdjustmentLayer()

                    pass
                pass


                if is_assignable(layer, PosterizeLayer):
            if is_assignable(layer, PosterizeLayer):

                    post = cast(PosterizeLayer, layer)
                post = cast(PosterizeLayer, layer)

                    post.levels = 3
                post.levels = 3


                if is_assignable(layer, ThresholdLayer):
            if is_assignable(layer, ThresholdLayer):

                    threshold = cast(ThresholdLayer, layer)
                threshold = cast(ThresholdLayer, layer)

                    threshold.level = 15
                threshold.level = 15


                if is_assignable(layer, SelectiveColorLayer):
            if is_assignable(layer, SelectiveColorLayer):

                    selectiveColor = cast(SelectiveColorLayer, layer)
                selectiveColor = cast(SelectiveColorLayer, layer)

                    correction = CmykCorrection()
                correction = CmykCorrection()

                    correction.cyan = 25
                correction.cyan = 25

                    correction.magenta = 10
                correction.magenta = 10

                    correction.yellow = -15
                correction.yellow = -15

                    correction.black = 5
                correction.black = 5

                    selectiveColor.set_cmyk_correction(SelectiveColorsTypes.CYANS, correction)
                selectiveColor.set_cmyk_correction(SelectiveColorsTypes.CYANS, correction)


            psdImage.save(outputModPng, pngOpt)
        psdImage.save(outputModPng, pngOpt)

## 35 changes: 35 additions & 0 deletions Documentation-Python-Aspose-pixel-data-manipulation.py
@@ -0,0 +1,35 @@

    from io import BytesIO
from io import BytesIO

    from aspose.psd.fileformats.psd import PsdImage
from aspose.psd.fileformats.psd import PsdImage

    from aspose.psd.fileformats.psd.layers import Layer
from aspose.psd.fileformats.psd.layers import Layer


    inputFile = "inputFile.png"
inputFile = "inputFile.png"

    outputFile = "AddFileAsLayer.psd"
outputFile = "AddFileAsLayer.psd"


    # Open file as Stream
# Open file as Stream

    with open(inputFile, "rb", buffering=0) as filestream:
with open(inputFile, "rb", buffering=0) as filestream:

        stream = BytesIO(filestream.read())
    stream = BytesIO(filestream.read())

        stream.seek(0)
    stream.seek(0)


        # Create PSD Layer from Stream
    # Create PSD Layer from Stream

        layer = Layer(stream)
    layer = Layer(stream)


        # Create PSD Image with the specified size
    # Create PSD Image with the specified size

        psdImage = PsdImage(layer.width, layer.height)
    psdImage = PsdImage(layer.width, layer.height)


        # Add Layer to PSD Image
    # Add Layer to PSD Image

        psdImage.layers = [layer]
    psdImage.layers = [layer]


        # Get Pixels from File
    # Get Pixels from File

        pixels = layer.load_argb_32_pixels(layer.bounds)
    pixels = layer.load_argb_32_pixels(layer.bounds)

        pixelsRange = range(len(pixels))
    pixelsRange = range(len(pixels))


        # Fill the pixels data with some values
    # Fill the pixels data with some values

        for i in pixelsRange:
    for i in pixelsRange:

            if i % 5 == 0:
        if i % 5 == 0:

                pixels[i] = 500000
            pixels[i] = 500000


        # Fast Save of Updated Image Data
    # Fast Save of Updated Image Data

        layer.save_argb_32_pixels(layer.bounds, pixels)
    layer.save_argb_32_pixels(layer.bounds, pixels)


        # Save PSD Image
    # Save PSD Image

        psdImage.save(outputFile)
    psdImage.save(outputFile)

## 80 changes: 80 additions & 0 deletions Documentation-Python-Aspose-psd-fill-layer-editing.py
@@ -0,0 +1,80 @@

        def create_regular_layer(left, top, width, height):
    def create_regular_layer(left, top, width, height):

            layer = Layer()
        layer = Layer()

            layer.left = left
        layer.left = left

            layer.top = top
        layer.top = top

            layer.right = left + width
        layer.right = left + width

            layer.bottom = top + height
        layer.bottom = top + height


            color = Color.aqua.to_argb()
        color = Color.aqua.to_argb()

            test_data = [color] * width * height
        test_data = [color] * width * height

            layer.save_argb_32_pixels(layer.bounds, test_data)
        layer.save_argb_32_pixels(layer.bounds, test_data)


            return layer
        return layer


        def FillLayerManipulationTest():
    def FillLayerManipulationTest():

            outputPng = "all_fill_layers.png"
        outputPng = "all_fill_layers.png"

            outputPsd = "all_fill_layers.psd"
        outputPsd = "all_fill_layers.psd"


            with PsdImage(100, 100) as image:
        with PsdImage(100, 100) as image:

                layer1 = create_regular_layer(0, 0, 50, 50)
            layer1 = create_regular_layer(0, 0, 50, 50)

                image.add_layer(layer1)
            image.add_layer(layer1)


                colorFillLayer = FillLayer.create_instance(FillType.COLOR)
            colorFillLayer = FillLayer.create_instance(FillType.COLOR)

                colorFillSettings = cast(ColorFillSettings, colorFillLayer.fill_settings)
            colorFillSettings = cast(ColorFillSettings, colorFillLayer.fill_settings)

                colorFillSettings.color = Color.coral
            colorFillSettings.color = Color.coral

                colorFillLayer.clipping = 1
            colorFillLayer.clipping = 1


                colorFillLayer.display_name = "Color Fill Layer"
            colorFillLayer.display_name = "Color Fill Layer"

                image.add_layer(colorFillLayer)
            image.add_layer(colorFillLayer)


                layer2 = create_regular_layer(50, 0, 50, 50)
            layer2 = create_regular_layer(50, 0, 50, 50)

                image.add_layer(layer2)
            image.add_layer(layer2)


                gradientColorPoints = [
            gradientColorPoints = [

                    GradientColorPoint(Color.red, 2048, 50),
                GradientColorPoint(Color.red, 2048, 50),

                    GradientColorPoint(Color.green, 3072, 50),
                GradientColorPoint(Color.green, 3072, 50),

                    GradientColorPoint(Color.blue, 4096, 50)
                GradientColorPoint(Color.blue, 4096, 50)

                ]
            ]


                tp1 = GradientTransparencyPoint()
            tp1 = GradientTransparencyPoint()

                tp1.location = 0
            tp1.location = 0

                tp1.median_point_location = 50
            tp1.median_point_location = 50

                tp1.opacity = 128
            tp1.opacity = 128


                tp2 = GradientTransparencyPoint()
            tp2 = GradientTransparencyPoint()

                tp2.location = 2048
            tp2.location = 2048

                tp2.median_point_location = 50
            tp2.median_point_location = 50

                tp2.opacity = 176
            tp2.opacity = 176

                gradientTransparencyPoints = [tp1, tp2]
            gradientTransparencyPoints = [tp1, tp2]


                gradientFillLayer = FillLayer.create_instance(FillType.GRADIENT)
            gradientFillLayer = FillLayer.create_instance(FillType.GRADIENT)

                gradientFillLayer.display_name = "Gradient Fill Layer"
            gradientFillLayer.display_name = "Gradient Fill Layer"

                gradientFillSettings = cast(GradientFillSettings, gradientFillLayer.fill_settings)
            gradientFillSettings = cast(GradientFillSettings, gradientFillLayer.fill_settings)

                gradientFillSettings.color_points = gradientColorPoints
            gradientFillSettings.color_points = gradientColorPoints

                gradientFillSettings.angle = -45
            gradientFillSettings.angle = -45

                gradientFillSettings.transparency_points = gradientTransparencyPoints
            gradientFillSettings.transparency_points = gradientTransparencyPoints

                gradientFillLayer.clipping = 1
            gradientFillLayer.clipping = 1

                image.add_layer(gradientFillLayer)
            image.add_layer(gradientFillLayer)


                layer3 = create_regular_layer(0, 50, 50, 50)
            layer3 = create_regular_layer(0, 50, 50, 50)

                image.add_layer(layer3)
            image.add_layer(layer3)


                patternFillLayer = FillLayer.create_instance(FillType.PATTERN)
            patternFillLayer = FillLayer.create_instance(FillType.PATTERN)

                patternFillLayer.display_name = "Pattern Fill Layer"
            patternFillLayer.display_name = "Pattern Fill Layer"

                patternFillLayer.opacity = 50
            patternFillLayer.opacity = 50

                patternFillLayer.clipping = 1
            patternFillLayer.clipping = 1

                patternFillSettings = cast(PatternFillSettings, patternFillLayer.fill_settings)
            patternFillSettings = cast(PatternFillSettings, patternFillLayer.fill_settings)

                patternFillSettings.pattern_data = [
            patternFillSettings.pattern_data = [

                    Color.red.to_argb(), Color.transparent.to_argb(), Color.transparent.to_argb(),
                Color.red.to_argb(), Color.transparent.to_argb(), Color.transparent.to_argb(),

                    Color.transparent.to_argb(), Color.red.to_argb(), Color.transparent.to_argb(),
                Color.transparent.to_argb(), Color.red.to_argb(), Color.transparent.to_argb(),

                    Color.transparent.to_argb(), Color.transparent.to_argb(), Color.red.to_argb()
                Color.transparent.to_argb(), Color.transparent.to_argb(), Color.red.to_argb()

                ]
            ]


                patternFillSettings.pattern_width = 3
            patternFillSettings.pattern_width = 3

                patternFillSettings.pattern_height = 3
            patternFillSettings.pattern_height = 3

                image.add_layer(patternFillLayer)
            image.add_layer(patternFillLayer)


                pngOpt = PngOptions()
            pngOpt = PngOptions()

                pngOpt.color_type = PngColorType.TRUECOLOR_WITH_ALPHA
            pngOpt.color_type = PngColorType.TRUECOLOR_WITH_ALPHA

                image.save(outputPng, pngOpt)
            image.save(outputPng, pngOpt)

                image.save(outputPsd)
            image.save(outputPsd)

## 29 changes: 29 additions & 0 deletions Documentation-Python-Aspose-psd-group-layer.py
@@ -0,0 +1,29 @@

    from io import BytesIO
from io import BytesIO


    from aspose.psd.fileformats.psd import PsdImage
from aspose.psd.fileformats.psd import PsdImage

    from aspose.psd.fileformats.psd.layers import Layer
from aspose.psd.fileformats.psd.layers import Layer

    from aspose.psd.imageoptions import PsdOptions
from aspose.psd.imageoptions import PsdOptions

    from aspose.psd.sources import StreamSource
from aspose.psd.sources import StreamSource

    from aspose.pycore import cast
from aspose.pycore import cast


    def LayerGroupManipulationTest():
def LayerGroupManipulationTest():

        outputPsd = "LayerGroup.psd"
    outputPsd = "LayerGroup.psd"


        psd_options = PsdOptions()
    psd_options = PsdOptions()

        stream = BytesIO()
    stream = BytesIO()

        psd_options.source = StreamSource(stream)
    psd_options.source = StreamSource(stream)


        with PsdImage.create(psd_options, 100, 100) as image:
    with PsdImage.create(psd_options, 100, 100) as image:

            psd_image = cast(PsdImage, image)
        psd_image = cast(PsdImage, image)

            layer_group = psd_image.add_layer_group("Folder", 0, True)
        layer_group = psd_image.add_layer_group("Folder", 0, True)

            layer1 = Layer()
        layer1 = Layer()

            layer1.display_name = "Layer 1"
        layer1.display_name = "Layer 1"

            layer2 = Layer()
        layer2 = Layer()

            layer2.display_name = "Layer 2"
        layer2.display_name = "Layer 2"

            layer_group.add_layer(layer1)
        layer_group.add_layer(layer1)

            layer_group.add_layer(layer2)
        layer_group.add_layer(layer2)


            assert layer_group.layers[0].display_name == "Layer 1"
        assert layer_group.layers[0].display_name == "Layer 1"

            assert layer_group.layers[1].display_name == "Layer 2"
        assert layer_group.layers[1].display_name == "Layer 2"


            psd_image.save(outputPsd)
        psd_image.save(outputPsd)

## 37 changes: 37 additions & 0 deletions Documentation-Python-Aspose-psd-layer-manipulation.py
@@ -0,0 +1,37 @@

    from aspose.psd import Image, ResizeType, Color, Rectangle
from aspose.psd import Image, ResizeType, Color, Rectangle

    from aspose.psd.fileformats.png import PngColorType
from aspose.psd.fileformats.png import PngColorType

    from aspose.psd.fileformats.psd import PsdImage
from aspose.psd.fileformats.psd import PsdImage

    from aspose.psd.imageloadoptions import PsdLoadOptions
from aspose.psd.imageloadoptions import PsdLoadOptions

    from aspose.psd.imageoptions import PngOptions
from aspose.psd.imageoptions import PngOptions

    from aspose.pycore import cast
from aspose.pycore import cast


    def LayerManipulationTest():
def LayerManipulationTest():

        source = "AllTypesLayerPsd2.psd"
    source = "AllTypesLayerPsd2.psd"

        output_original = "original_layer_manipulation.png"
    output_original = "original_layer_manipulation.png"

        output_updated = "updated_layer_manipulation.png"
    output_updated = "updated_layer_manipulation.png"

        pngOpt = PngOptions()
    pngOpt = PngOptions()

        pngOpt.color_type = PngColorType.TRUECOLOR_WITH_ALPHA
    pngOpt.color_type = PngColorType.TRUECOLOR_WITH_ALPHA


        psdLoadOpt = PsdLoadOptions()
    psdLoadOpt = PsdLoadOptions()

        psdLoadOpt.load_effects_resource = True
    psdLoadOpt.load_effects_resource = True

        psdLoadOpt.allow_warp_repaint = True
    psdLoadOpt.allow_warp_repaint = True


        with Image.load(source, psdLoadOpt) as image:
    with Image.load(source, psdLoadOpt) as image:

            psd_image = cast(PsdImage, image)
        psd_image = cast(PsdImage, image)

            psd_image.save(output_original, pngOpt)
        psd_image.save(output_original, pngOpt)


            # Resizing
        # Resizing

            psd_image.layers[2].resize(25, 25, ResizeType.HIGH_QUALITY_RESAMPLE)
        psd_image.layers[2].resize(25, 25, ResizeType.HIGH_QUALITY_RESAMPLE)


            # Rotating
        # Rotating

            psd_image.layers[5].rotate(45, True, Color.yellow)
        psd_image.layers[5].rotate(45, True, Color.yellow)


            # Simple Filters
        # Simple Filters

            psd_image.layers[3].adjust_contrast(3)
        psd_image.layers[3].adjust_contrast(3)


            # Cropping
        # Cropping

            psd_image.layers[10].crop(Rectangle(10, 10, 20, 20))
        psd_image.layers[10].crop(Rectangle(10, 10, 20, 20))

            # Aspose.PSD supports much more specific layer manipulation, please check https://reference.aspose.com/psd/python-net/
        # Aspose.PSD supports much more specific layer manipulation, please check https://reference.aspose.com/psd/python-net/


            psd_image.save(output_updated, pngOpt)
        psd_image.save(output_updated, pngOpt)

## 72 changes: 72 additions & 0 deletions Documentation-Python-Aspose-psd-shape-layer-manipulation.py
@@ -0,0 +1,72 @@

    from aspose.psd import Point, Image, PointF
from aspose.psd import Point, Image, PointF

    from aspose.psd.fileformats.core.vectorpaths import BezierKnotRecord
from aspose.psd.fileformats.core.vectorpaths import BezierKnotRecord

    from aspose.psd.fileformats.psd import PsdImage
from aspose.psd.fileformats.psd import PsdImage

    from aspose.psd.fileformats.psd.layers import ShapeLayer
from aspose.psd.fileformats.psd.layers import ShapeLayer

    from aspose.psd.fileformats.psd.layers.layerresources import PathShape
from aspose.psd.fileformats.psd.layers.layerresources import PathShape

    from aspose.pycore import cast, is_assignable
from aspose.pycore import cast, is_assignable


    def PointFToResourcePoint(point, imageSize):
def PointFToResourcePoint(point, imageSize):

        ImgToPsdRatio = 256 * 65535
    ImgToPsdRatio = 256 * 65535

        return Point(int(point.y * (ImgToPsdRatio / imageSize.height)), int(point.x * (ImgToPsdRatio / imageSize.width)))
    return Point(int(point.y * (ImgToPsdRatio / imageSize.height)), int(point.x * (ImgToPsdRatio / imageSize.width)))


    def ShapeLayerPathManipulationTest():
def ShapeLayerPathManipulationTest():

        sourceFileName = "ShapeLayerTest.psd"
    sourceFileName = "ShapeLayerTest.psd"

        originalOutput = "ShapeLayerTest_Res_or.psd"
    originalOutput = "ShapeLayerTest_Res_or.psd"

        updatedOutput = "ShapeLayerTest_Res_up.psd"
    updatedOutput = "ShapeLayerTest_Res_up.psd"


        with Image.load(sourceFileName) as image:
    with Image.load(sourceFileName) as image:

            im = cast(PsdImage, image)
        im = cast(PsdImage, image)

            im.save(originalOutput)
        im.save(originalOutput)

            for layer in im.layers:
        for layer in im.layers:

                # Finding Shape Layer
            # Finding Shape Layer

                if is_assignable(layer, ShapeLayer):
            if is_assignable(layer, ShapeLayer):

                    shapeLayer = cast(ShapeLayer, layer)
                shapeLayer = cast(ShapeLayer, layer)

                    path = shapeLayer.path
                path = shapeLayer.path

                    pathShapes = path.get_items()
                pathShapes = path.get_items()

                    knotsList = []
                knotsList = []

                    for pathShape in pathShapes:
                for pathShape in pathShapes:

                        knots = pathShape.get_items()
                    knots = pathShape.get_items()

                        knotsList.extend(knots)
                    knotsList.extend(knots)


                    # Change Path Shape properties
                # Change Path Shape properties

                    newShape = PathShape()
                newShape = PathShape()


                    bn1 = BezierKnotRecord()
                bn1 = BezierKnotRecord()

                    bn1.is_linked = True
                bn1.is_linked = True

                    bn1.points = [
                bn1.points = [

                        PointFToResourcePoint(PointF(20, 100), shapeLayer.container.size),
                    PointFToResourcePoint(PointF(20, 100), shapeLayer.container.size),

                        PointFToResourcePoint(PointF(20, 100), shapeLayer.container.size),
                    PointFToResourcePoint(PointF(20, 100), shapeLayer.container.size),

                        PointFToResourcePoint(PointF(20, 100), shapeLayer.container.size),
                    PointFToResourcePoint(PointF(20, 100), shapeLayer.container.size),

                    ]
                ]


                    bn2 = BezierKnotRecord()
                bn2 = BezierKnotRecord()

                    bn2.is_linked = True
                bn2.is_linked = True

                    bn2.points = [
                bn2.points = [

                        PointFToResourcePoint(PointF(20, 490), shapeLayer.container.size),
                    PointFToResourcePoint(PointF(20, 490), shapeLayer.container.size),

                        PointFToResourcePoint(PointF(20, 490), shapeLayer.container.size),
                    PointFToResourcePoint(PointF(20, 490), shapeLayer.container.size),

                        PointFToResourcePoint(PointF(20, 490), shapeLayer.container.size),
                    PointFToResourcePoint(PointF(20, 490), shapeLayer.container.size),

                    ]
                ]


                    bn3 = BezierKnotRecord()
                bn3 = BezierKnotRecord()

                    bn3.is_linked = True
                bn3.is_linked = True

                    bn3.points = [
                bn3.points = [

                        PointFToResourcePoint(PointF(490, 20), shapeLayer.container.size),
                    PointFToResourcePoint(PointF(490, 20), shapeLayer.container.size),

                        PointFToResourcePoint(PointF(490, 20), shapeLayer.container.size),
                    PointFToResourcePoint(PointF(490, 20), shapeLayer.container.size),

                        PointFToResourcePoint(PointF(490, 20), shapeLayer.container.size),
                    PointFToResourcePoint(PointF(490, 20), shapeLayer.container.size),

                    ]
                ]


                    bezierKnots = [bn1, bn2, bn3]
                bezierKnots = [bn1, bn2, bn3]

                    newShape.set_items(bezierKnots)
                newShape.set_items(bezierKnots)


                    newShapes = list(pathShapes)
                newShapes = list(pathShapes)

                    newShapes.append(newShape)
                newShapes.append(newShape)


                    pathShapeNew = newShapes
                pathShapeNew = newShapes

                    path.set_items(pathShapeNew)
                path.set_items(pathShapeNew)


                    shapeLayer.update()
                shapeLayer.update()


                    im.save(updatedOutput)
                im.save(updatedOutput)


                    break
                break

## 20 changes: 20 additions & 0 deletions Documentation-Python-Aspose-psd-smart-filter-direct-apply.py
@@ -0,0 +1,20 @@

    from aspose.psd import Image
from aspose.psd import Image

    from aspose.psd.fileformats.psd import PsdImage
from aspose.psd.fileformats.psd import PsdImage

    from aspose.psd.fileformats.psd.layers.smartfilters import SharpenSmartFilter
from aspose.psd.fileformats.psd.layers.smartfilters import SharpenSmartFilter

    from aspose.pycore import cast
from aspose.pycore import cast


    def SmartFilterDirectApply():
def SmartFilterDirectApply():

        source = "VerySmoothPicture.psd"
    source = "VerySmoothPicture.psd"

        output_original = "original_smart.psd"
    output_original = "original_smart.psd"

        output_updated = "output_updated.psd"
    output_updated = "output_updated.psd"


        with Image.load(source) as image:
    with Image.load(source) as image:

            im = cast(PsdImage, image)
        im = cast(PsdImage, image)

            im.save(output_original)
        im.save(output_original)

            sharpenFilter = SharpenSmartFilter()
        sharpenFilter = SharpenSmartFilter()

            regularLayer = im.layers[1]
        regularLayer = im.layers[1]

            for i in range(3):
        for i in range(3):

                sharpenFilter.apply(regularLayer)
            sharpenFilter.apply(regularLayer)


            im.save(output_updated)
        im.save(output_updated)

## 46 changes: 46 additions & 0 deletions Documentation-Python-Aspose-psd-smart-filter-features.py
@@ -0,0 +1,46 @@

    from aspose.psd import Image
from aspose.psd import Image

    from aspose.psd.fileformats.core.blending import BlendMode
from aspose.psd.fileformats.core.blending import BlendMode

    from aspose.psd.fileformats.psd import PsdImage
from aspose.psd.fileformats.psd import PsdImage

    from aspose.psd.fileformats.psd.layers.smartfilters import GaussianBlurSmartFilter, AddNoiseSmartFilter, \
from aspose.psd.fileformats.psd.layers.smartfilters import GaussianBlurSmartFilter, AddNoiseSmartFilter, \

        NoiseDistribution
    NoiseDistribution

    from aspose.psd.fileformats.psd.layers.smartobjects import SmartObjectLayer
from aspose.psd.fileformats.psd.layers.smartobjects import SmartObjectLayer

    from aspose.pycore import cast
from aspose.pycore import cast


    def SmartFilterFeaturesTest():
def SmartFilterFeaturesTest():

        source = "r2_SmartFilters.psd"
    source = "r2_SmartFilters.psd"

        output_original = "original_smart_features.psd"
    output_original = "original_smart_features.psd"

        output_updated = "output_updated_features.psd"
    output_updated = "output_updated_features.psd"


        with Image.load(source) as image:
    with Image.load(source) as image:

            im = cast(PsdImage, image)
        im = cast(PsdImage, image)

            im.save(output_original)
        im.save(output_original)

            smartObj = cast(SmartObjectLayer, im.layers[1])
        smartObj = cast(SmartObjectLayer, im.layers[1])


            # edit smart filters
        # edit smart filters

            gaussianBlur = cast(GaussianBlurSmartFilter, smartObj.smart_filters.filters[0])
        gaussianBlur = cast(GaussianBlurSmartFilter, smartObj.smart_filters.filters[0])


            # update filter values including blend mode
        # update filter values including blend mode

            gaussianBlur.radius = 1
        gaussianBlur.radius = 1

            gaussianBlur.blend_mode = BlendMode.DIVIDE
        gaussianBlur.blend_mode = BlendMode.DIVIDE

            gaussianBlur.opacity = 75
        gaussianBlur.opacity = 75

            gaussianBlur.is_enabled = False
        gaussianBlur.is_enabled = False


            # Working with Add Noise Smart Filter
        # Working with Add Noise Smart Filter

            addNoise = cast(AddNoiseSmartFilter, smartObj.smart_filters.filters[1])
        addNoise = cast(AddNoiseSmartFilter, smartObj.smart_filters.filters[1])

            addNoise.distribution = NoiseDistribution.UNIFORM
        addNoise.distribution = NoiseDistribution.UNIFORM


            # add new filter items
        # add new filter items

            filters = list(smartObj.smart_filters.filters)
        filters = list(smartObj.smart_filters.filters)

            filters.append(GaussianBlurSmartFilter())
        filters.append(GaussianBlurSmartFilter())

            filters.append(AddNoiseSmartFilter())
        filters.append(AddNoiseSmartFilter())

            smartObj.smart_filters.filters = filters
        smartObj.smart_filters.filters = filters


            # apply changes
        # apply changes

            smartObj.smart_filters.update_resource_values()
        smartObj.smart_filters.update_resource_values()


            # Apply filters directly to layer and mask of layer
        # Apply filters directly to layer and mask of layer

            smartObj.smart_filters.filters[0].apply(im.layers[2])
        smartObj.smart_filters.filters[0].apply(im.layers[2])

            smartObj.smart_filters.filters[4].apply_to_mask(im.layers[2])
        smartObj.smart_filters.filters[4].apply_to_mask(im.layers[2])


            im.save(output_updated)
        im.save(output_updated)

## 48 changes: 48 additions & 0 deletions Documentation-Python-Aspose-psd-smart-object-update.py
@@ -0,0 +1,48 @@


    from aspose.psd import Image, RasterImage
from aspose.psd import Image, RasterImage

    from aspose.psd.fileformats.psd import PsdImage
from aspose.psd.fileformats.psd import PsdImage

    from aspose.psd.fileformats.psd.layers.smartobjects import SmartObjectLayer
from aspose.psd.fileformats.psd.layers.smartobjects import SmartObjectLayer

    from aspose.psd.imageoptions import PsdOptions
from aspose.psd.imageoptions import PsdOptions

    from aspose.pycore import cast
from aspose.pycore import cast


    # Just inverts all data of image
# Just inverts all data of image

    def invert_image(image):
def invert_image(image):

        pixels = image.load_argb_32_pixels(image.bounds)
    pixels = image.load_argb_32_pixels(image.bounds)

        for i in range(len(pixels)):
    for i in range(len(pixels)):

            pixel = pixels[i]
        pixel = pixels[i]

            alpha = pixel & 0xff000000
        alpha = pixel & 0xff000000

            pixels[i] = (~ (pixel & 0x00ffffff)) | alpha
        pixels[i] = (~ (pixel & 0x00ffffff)) | alpha


        image.save_argb_32_pixels(image.bounds, pixels)
    image.save_argb_32_pixels(image.bounds, pixels)


    # Demonstation of API to work woth Smart Object Layers
# Demonstation of API to work woth Smart Object Layers

    def SmartObjectManipulationTest():
def SmartObjectManipulationTest():

        source = "new_panama-papers-8-trans4.psd"
    source = "new_panama-papers-8-trans4.psd"

        export_content_path = "export_content.jpg"
    export_content_path = "export_content.jpg"

        output_original = "smart_object_orig.psd"
    output_original = "smart_object_orig.psd"

        output_updated = "smart_object.psd"
    output_updated = "smart_object.psd"


        with Image.load(source) as image:
    with Image.load(source) as image:

            im = cast(PsdImage, image)
        im = cast(PsdImage, image)

            im.save(output_original)
        im.save(output_original)

            smartLayer = cast(SmartObjectLayer, im.layers[0])
        smartLayer = cast(SmartObjectLayer, im.layers[0])


            # How to export content of Smart Object
        # How to export content of Smart Object

            smartLayer.export_contents(export_content_path)
        smartLayer.export_contents(export_content_path)


            # Creating Smart Object as a Copy
        # Creating Smart Object as a Copy

            newLayer = smartLayer.new_smart_object_via_copy()
        newLayer = smartLayer.new_smart_object_via_copy()

            newLayer.is_visible = False
        newLayer.is_visible = False

            newLayer.display_name = "Duplicate"
        newLayer.display_name = "Duplicate"


            # Get the content of Smart Object for manipulation
        # Get the content of Smart Object for manipulation

            with smartLayer.load_contents(None) as innerImage:
        with smartLayer.load_contents(None) as innerImage:

                layer = cast(RasterImage, innerImage)
            layer = cast(RasterImage, innerImage)

                invert_image(layer)
            invert_image(layer)

                smartLayer.replace_contents(layer)
            smartLayer.replace_contents(layer)


            im.smart_object_provider.update_all_modified_content()
        im.smart_object_provider.update_all_modified_content()


            psd_options = PsdOptions(im)
        psd_options = PsdOptions(im)

            im.save(output_updated, psd_options)
        im.save(output_updated, psd_options)

## 52 changes: 52 additions & 0 deletions Documentation-Python-Aspose-psd-text-layer-manipulation-full.py
@@ -0,0 +1,52 @@

    from aspose.psd import Color
from aspose.psd import Color

    from aspose.psd.fileformats.psd import PsdImage, FontBaseline, FontCaps
from aspose.psd.fileformats.psd import PsdImage, FontBaseline, FontCaps

    from aspose.psd.fileformats.psd.layers import TextLayer
from aspose.psd.fileformats.psd.layers import TextLayer

    from aspose.pycore import cast
from aspose.pycore import cast


    def TextLayerUpdatingTest():
def TextLayerUpdatingTest():

        source_file = "text212.psd"
    source_file = "text212.psd"

        output_file = "Output_text212.psd"
    output_file = "Output_text212.psd"


        with PsdImage.load(source_file) as img:
    with PsdImage.load(source_file) as img:

            image = cast(PsdImage, img)
        image = cast(PsdImage, img)

            # Smple way to update text layer
        # Smple way to update text layer

            simple_text = cast(TextLayer, image.layers[2])
        simple_text = cast(TextLayer, image.layers[2])

            simple_text.update_text("Update", Color.red)
        simple_text.update_text("Update", Color.red)


            # More powerful way to updateText Layer - using Text Portions with different styles and paragraphs
        # More powerful way to updateText Layer - using Text Portions with different styles and paragraphs

            text_layer = cast(TextLayer, image.layers[1])
        text_layer = cast(TextLayer, image.layers[1])

            text_data = text_layer.text_data
        text_data = text_layer.text_data


            default_style = text_data.produce_portion().style
        default_style = text_data.produce_portion().style

            default_paragraph = text_data.produce_portion().paragraph
        default_paragraph = text_data.produce_portion().paragraph


            default_style.fill_color = Color.from_name("DimGray")
        default_style.fill_color = Color.from_name("DimGray")

            default_style.font_size = 51
        default_style.font_size = 51


            text_data.items[1].style.strikethrough = True
        text_data.items[1].style.strikethrough = True


            new_portions = text_data.produce_portions(
        new_portions = text_data.produce_portions(

                [
            [

                    "E=mc",
                "E=mc",

                    "2\r",
                "2\r",

                    "Bold",
                "Bold",

                    "Italic\r",
                "Italic\r",

                    "Lowercasetext"
                "Lowercasetext"

                ],
            ],

                default_style,
            default_style,

                default_paragraph
            default_paragraph

            )
        )


            new_portions[0].style.underline = True  # edit text style "E=mc"
        new_portions[0].style.underline = True  # edit text style "E=mc"

            new_portions[1].style.font_baseline = FontBaseline.SUPERSCRIPT  # edit text style "2\r"
        new_portions[1].style.font_baseline = FontBaseline.SUPERSCRIPT  # edit text style "2\r"

            new_portions[2].style.faux_bold = True  # edit text style "Bold"
        new_portions[2].style.faux_bold = True  # edit text style "Bold"

            new_portions[3].style.faux_italic = True  # edit text style "Italic\r"
        new_portions[3].style.faux_italic = True  # edit text style "Italic\r"

            new_portions[3].style.baseline_shift = -25  # edit text style "Italic\r"
        new_portions[3].style.baseline_shift = -25  # edit text style "Italic\r"

            new_portions[4].style.font_caps = FontCaps.SMALL_CAPS  # edit text style "Lowercasetext"
        new_portions[4].style.font_caps = FontCaps.SMALL_CAPS  # edit text style "Lowercasetext"


            for new_portion in new_portions:
        for new_portion in new_portions:

                text_data.add_portion(new_portion)
            text_data.add_portion(new_portion)


            text_data.update_layer_data()
        text_data.update_layer_data()

            image.save(output_file)
        image.save(output_file)

## 9 changes: 9 additions & 0 deletions Documentation-Python-Aspose-psd-text-layer-manipulation-simple.py
@@ -0,0 +1,9 @@

    source_file = "text212.psd"
source_file = "text212.psd"

    output_file = "Output_text212.psd"
output_file = "Output_text212.psd"


    with PsdImage.load(source_file) as img:
with PsdImage.load(source_file) as img:

        image = cast(PsdImage, img)
    image = cast(PsdImage, img)

        simple_text = cast(TextLayer, image.layers[2])
    simple_text = cast(TextLayer, image.layers[2])

        simple_text.update_text("Update", Color.red)
    simple_text.update_text("Update", Color.red)


        image.save(output_file)
    image.save(output_file)

## 34 changes: 34 additions & 0 deletions Documentation-Python-Aspose-psd-text-layer-manipulation-text-portion.py
@@ -0,0 +1,34 @@

    text_layer = cast(TextLayer, image.layers[1])
text_layer = cast(TextLayer, image.layers[1])

    text_data = text_layer.text_data
text_data = text_layer.text_data


    default_style = text_data.produce_portion().style
default_style = text_data.produce_portion().style

    default_paragraph = text_data.produce_portion().paragraph
default_paragraph = text_data.produce_portion().paragraph


    default_style.fill_color = Color.from_name("DimGray")
default_style.fill_color = Color.from_name("DimGray")

    default_style.font_size = 51
default_style.font_size = 51


    text_data.items[1].style.strikethrough = True
text_data.items[1].style.strikethrough = True


    new_portions = text_data.produce_portions(
new_portions = text_data.produce_portions(

        [
    [

            "E=mc",
        "E=mc",

            "2\r",
        "2\r",

            "Bold",
        "Bold",

            "Italic\r",
        "Italic\r",

            "Lowercasetext"
        "Lowercasetext"

        ],
    ],

        default_style,
    default_style,

        default_paragraph
    default_paragraph

    )
)


    new_portions[0].style.underline = True
new_portions[0].style.underline = True

    new_portions[1].style.font_baseline = FontBaseline.SUPERSCRIPT
new_portions[1].style.font_baseline = FontBaseline.SUPERSCRIPT

    new_portions[2].style.faux_bold = True
new_portions[2].style.faux_bold = True

    new_portions[3].style.faux_italic = True
new_portions[3].style.faux_italic = True

    new_portions[3].style.baseline_shift = -25
new_portions[3].style.baseline_shift = -25

    new_portions[4].style.font_caps = FontCaps.SMALL_CAPS
new_portions[4].style.font_caps = FontCaps.SMALL_CAPS


    for new_portion in new_portions:
for new_portion in new_portions:

        text_data.add_portion(new_portion)
    text_data.add_portion(new_portion)


    text_data.update_layer_data()
text_data.update_layer_data()

## 32 changes: 32 additions & 0 deletions Documentation-Python-Aspose-psd-update-create-layer-mask.py
@@ -0,0 +1,32 @@

    from aspose.psd.fileformats.psd import PsdImage
from aspose.psd.fileformats.psd import PsdImage

    from aspose.psd.fileformats.psd.layers import LayerMaskDataShort
from aspose.psd.fileformats.psd.layers import LayerMaskDataShort

    from aspose.pycore import cast
from aspose.pycore import cast


    def LayerMasksEditingTest():
def LayerMasksEditingTest():

        source = "MaskExample.psd"
    source = "MaskExample.psd"

        output_original = "original_mask_features.psd"
    output_original = "original_mask_features.psd"

        output_updated = "updated_mask_features.psd"
    output_updated = "updated_mask_features.psd"

        with PsdImage.load(source) as img:
    with PsdImage.load(source) as img:

            image = cast(PsdImage, img)
        image = cast(PsdImage, img)

            image.save(output_original)
        image.save(output_original)


            # The most simple is the using of Clipping masks
        # The most simple is the using of Clipping masks

            # Some Layer and Adjustment Layer Become Clipping Masks
        # Some Layer and Adjustment Layer Become Clipping Masks

            image.layers[4].clipping = 1
        image.layers[4].clipping = 1

            image.layers[5].clipping = 1
        image.layers[5].clipping = 1


            # Example how to add Mask to Layer
        # Example how to add Mask to Layer

            mask = LayerMaskDataShort()
        mask = LayerMaskDataShort()

            mask.left = 50
        mask.left = 50

            mask.top = 213
        mask.top = 213

            mask.right = mask.left + 150
        mask.right = mask.left + 150

            mask.bottom = mask.top + 150
        mask.bottom = mask.top + 150

            maskData = [bytes] * (mask.right - mask.left) * (mask.bottom - mask.top)
        maskData = [bytes] * (mask.right - mask.left) * (mask.bottom - mask.top)

            for index in range(len(maskData)):
        for index in range(len(maskData)):

                maskData[index] = 100 + index % 100
            maskData[index] = 100 + index % 100


            byteMask = bytes(maskData)
        byteMask = bytes(maskData)

            mask.image_data = byteMask
        mask.image_data = byteMask

            image.layers[2].add_layer_mask(mask)
        image.layers[2].add_layer_mask(mask)


            image.save(output_updated)
        image.save(output_updated)

## 35 changes: 35 additions & 0 deletions Pypi-Add-Image-as-a-layer.py
@@ -0,0 +1,35 @@

    from io import BytesIO
from io import BytesIO

    from aspose.psd.fileformats.psd import PsdImage
from aspose.psd.fileformats.psd import PsdImage

    from aspose.psd.fileformats.psd.layers import Layer
from aspose.psd.fileformats.psd.layers import Layer


    inputFile = "inputFile.png"
inputFile = "inputFile.png"

    outputFile = "AddFileAsLayer.psd"
outputFile = "AddFileAsLayer.psd"


    # Open file as Stream
# Open file as Stream

    with open(inputFile, "rb", buffering=0) as filestream:
with open(inputFile, "rb", buffering=0) as filestream:

        stream = BytesIO(filestream.read())
    stream = BytesIO(filestream.read())

        stream.seek(0)
    stream.seek(0)


        # Create PSD Layer from Stream
    # Create PSD Layer from Stream

        layer = Layer(stream)
    layer = Layer(stream)


        # Create PSD Image with the specified size
    # Create PSD Image with the specified size

        psdImage = PsdImage(layer.width, layer.height)
    psdImage = PsdImage(layer.width, layer.height)


        # Add Layer to PSD Image
    # Add Layer to PSD Image

        psdImage.layers = [layer]
    psdImage.layers = [layer]


        # Get Pixels from File
    # Get Pixels from File

        pixels = layer.load_argb_32_pixels(layer.bounds)
    pixels = layer.load_argb_32_pixels(layer.bounds)

        pixelsRange = range(len(pixels))
    pixelsRange = range(len(pixels))


        # Fill the pixels data with some values
    # Fill the pixels data with some values

        for i in pixelsRange:
    for i in pixelsRange:

            if i % 5 == 0:
        if i % 5 == 0:

                pixels[i] = 500000
            pixels[i] = 500000


        # Fast Save of Updated Image Data
    # Fast Save of Updated Image Data

        layer.save_argb_32_pixels(layer.bounds, pixels)
    layer.save_argb_32_pixels(layer.bounds, pixels)


        # Save PSD Image
    # Save PSD Image

        psdImage.save(outputFile)
    psdImage.save(outputFile)

## 5 changes: 5 additions & 0 deletions Pypi-Apply-License.py
@@ -0,0 +1,5 @@

    from aspose.psd import License
from aspose.psd import License


    license = License()
license = License()

    licensePath = "PathToLicenseFile"
licensePath = "PathToLicenseFile"

    license.set_license(licensePath)
license.set_license(licensePath)

## 29 changes: 29 additions & 0 deletions Pypi-Create-File-From-Scratch-And-Layer.py
@@ -0,0 +1,29 @@

    from aspose.psd import Graphics, Pen, Color, Rectangle
from aspose.psd import Graphics, Pen, Color, Rectangle

    from aspose.psd.brushes import LinearGradientBrush
from aspose.psd.brushes import LinearGradientBrush

    from aspose.psd.fileformats.psd import PsdImage
from aspose.psd.fileformats.psd import PsdImage


    outputFile = "CreateFileFromScratchExample.psd"
outputFile = "CreateFileFromScratchExample.psd"


    # Create PSD Image with specified dimensions
# Create PSD Image with specified dimensions

    with PsdImage(500, 500) as img:
with PsdImage(500, 500) as img:

        # Create Regular PSD Layer and update it with Graphic API
    # Create Regular PSD Layer and update it with Graphic API

        regularLayer = img.add_regular_layer()
    regularLayer = img.add_regular_layer()


        # Use popular Graphic API for Editing
    # Use popular Graphic API for Editing

        graphics = Graphics(regularLayer)
    graphics = Graphics(regularLayer)

        pen = Pen(Color.alice_blue)
    pen = Pen(Color.alice_blue)

        brush = LinearGradientBrush(Rectangle(250, 250, 150, 100), Color.red, Color.aquamarine, 45)
    brush = LinearGradientBrush(Rectangle(250, 250, 150, 100), Color.red, Color.aquamarine, 45)

        graphics.draw_ellipse(pen, Rectangle(100, 100, 200, 200))
    graphics.draw_ellipse(pen, Rectangle(100, 100, 200, 200))

        graphics.fill_ellipse(brush, Rectangle(250, 250, 150, 100))
    graphics.fill_ellipse(brush, Rectangle(250, 250, 150, 100))


        # Create Text Layer
    # Create Text Layer

        textLayer = img.add_text_layer("Sample Text", Rectangle(200, 200, 100, 100))
    textLayer = img.add_text_layer("Sample Text", Rectangle(200, 200, 100, 100))


        # Adding Shadow to Text
    # Adding Shadow to Text

        dropShadowEffect = textLayer.blending_options.add_drop_shadow()
    dropShadowEffect = textLayer.blending_options.add_drop_shadow()

        dropShadowEffect.distance = 0
    dropShadowEffect.distance = 0

        dropShadowEffect.size = 8
    dropShadowEffect.size = 8

        dropShadowEffect.color = Color.blue
    dropShadowEffect.color = Color.blue


        # Save PSD File
    # Save PSD File

        img.save(outputFile)
    img.save(outputFile)

## 30 changes: 30 additions & 0 deletions Pypi-Open-File-Update-Text.py
@@ -0,0 +1,30 @@

    from aspose.psd import Image
from aspose.psd import Image

    from aspose.psd.fileformats.png import PngColorType
from aspose.psd.fileformats.png import PngColorType

    from aspose.psd.fileformats.psd import PsdImage
from aspose.psd.fileformats.psd import PsdImage

    from aspose.psd.fileformats.psd.layers import TextLayer
from aspose.psd.fileformats.psd.layers import TextLayer

    from aspose.psd.imageloadoptions import PsdLoadOptions
from aspose.psd.imageloadoptions import PsdLoadOptions

    from aspose.psd.imageoptions import PngOptions
from aspose.psd.imageoptions import PngOptions

    from aspose.pycore import cast
from aspose.pycore import cast


    # Specify File Paths
# Specify File Paths

    sourceFile = "AllTypesLayerPsd.psd"
sourceFile = "AllTypesLayerPsd.psd"

    outputFile = "LoadImageExample.png"
outputFile = "LoadImageExample.png"


    # Specify Load Options
# Specify Load Options

    loadOptions = PsdLoadOptions()
loadOptions = PsdLoadOptions()

    loadOptions.load_effects_resource = True
loadOptions.load_effects_resource = True

    loadOptions.allow_warp_repaint = True
loadOptions.allow_warp_repaint = True


    # Specify Export Options
# Specify Export Options

    exportOptions = PngOptions()
exportOptions = PngOptions()

    exportOptions.color_type = PngColorType.TRUECOLOR_WITH_ALPHA
exportOptions.color_type = PngColorType.TRUECOLOR_WITH_ALPHA


    # Open File using Aspose.PSD for Python
# Open File using Aspose.PSD for Python

    with Image.load(sourceFile, loadOptions) as image:
with Image.load(sourceFile, loadOptions) as image:

        # Types of Aspose.PSD can be casted
    # Types of Aspose.PSD can be casted

        psdImage = cast(PsdImage, image)
    psdImage = cast(PsdImage, image)

        textLayer = cast(TextLayer, psdImage.layers[5])
    textLayer = cast(TextLayer, psdImage.layers[5])

        textLayer.update_text("Simple Text Edit")
    textLayer.update_text("Simple Text Edit")


        # Export PSD File To PNG
    # Export PSD File To PNG

        psdImage.save(outputFile, exportOptions)
    psdImage.save(outputFile, exportOptions)

## 1 change: 1 addition & 0 deletions Aspose.PSD for Python via .NET
@@ -0,0 +1 @@

    Gist for Aspose.PSD for Python
Gist for Aspose.PSD for Python