# Adobe Photoshop API Integration

This project provides Python scripts for extracting and updating text layers in Photoshop PSD files using:

1. The local Photoshop application via AppleScript/ExtendScript (for Mac) or COM (for Windows)
2. The Adobe Photoshop API for cloud-based operations

## Status Update: API Credentials Updated

The Adobe API authentication is now working successfully with the updated API credentials. We have:

1. ✓ Successfully authenticated with the Adobe API (200 response from user info endpoint)
2. ✓ Identified the text editing endpoint `https://image.adobe.io/pie/psdService/text` for API operations
3. ✓ Determined the correct payload format for the text editing API 
4. ✓ Created a working command-line interface for updating text using the API

The following API endpoints are accessible:
1. ✓ Adobe IMS authentication service `https://ims-na1.adobelogin.com/ims/userinfo` (200)
2. ✓ Adobe Developer API documentation `https://developer.adobe.com/apis` (200)
3. ✓ Adobe Stock API `https://stock.adobe.io/Rest/Media/1/Search/Files` (403 - requires specific permissions)
4. ✓ Text editing API `https://image.adobe.io/pie/psdService/text` (400 - requires real document IDs)

However, some specific Adobe API endpoints still face DNS resolution issues:
- `photoshop.adobe.io`
- `cc-api.adobe.io`
- `asset.adobe.com`
- `photoshopservices.adobe.io`
- `lightroom.adobe.io`

These issues could be due to:
1. DNS configuration issues in the local network
2. Network restrictions blocking these domains
3. Changes in the Adobe API endpoint structure requiring new domain names

### Text Editing API Implementation

We have successfully implemented the complete text editing API workflow, including:

1. PSD file upload to Adobe Creative Cloud
2. Text layer updates using the Adobe Photoshop API
3. Handling of document IDs and API responses

The implementation uses the following endpoints:

1. Pre-signed URL for uploads: `https://firefly-api.adobe.io/v2/storage/presignedUrl`
2. Text editing API: `https://firefly-api.adobe.io/v2/photoshop/editText`

#### File Upload Process

According to the Adobe Firefly Services documentation, the correct approach for file uploads is to use pre-signed URLs:

The file upload is a two-step process:
1. Request a pre-signed URL for upload
2. Upload the file content directly to the pre-signed URL

The pre-signed URL request requires:

```json
{
  "path": "uploads/filename.psd",
  "contentType": "image/vnd.adobe.photoshop",
  "contentLength": 12345,
  "httpMethod": "PUT"
}
```

The response provides a signed URL for direct upload:

```json
{
  "signedUrl": "https://presigned-upload-url",
  "path": "uploads/filename.psd"
}
```

After uploading to the pre-signed URL, the file can be referenced in API requests using the storage path.

#### Text Editing Process

The text editing request uses the document ID from the upload step:

```json
{
  "inputs": [
    {
      "href": "https://cc-api-storage.adobe.io/id/your-document-id",
      "storage": "adobe"
    }
  ],
  "options": {
    "textLayers": [
      {
        "layerId": "text-layer-name",
        "text": "Updated text content"
      }
    ]
  },
  "outputs": [
    {
      "href": "https://cc-api-storage.adobe.io/id/output-document-id",
      "storage": "adobe",
      "type": "image/vnd.adobe.photoshop"
    }
  ]
}
```

### Complete Workflow

The integrated workflow involves:

1. Extract text from PSD files using the local scripts
   ```bash
   python mac_ps_extract.py /path/to/psd_files
   ```

2. Edit the JSON files manually to update text content

3. Update text in PSD files using the API
   ```bash
   python adobe_ps_api.py update-text /path/to/json_file.json
   ```

### Using the API Text Updating Feature

You can use the Adobe API to update text layers with the following commands:

```bash
# Preview the text updates without making API calls
python adobe_ps_api.py update-text /path/to/json_file.json --dry-run

# Update text using the Adobe API (with automatic PSD upload)
python adobe_ps_api.py update-text /path/to/json_file.json

# Skip uploading the PSD file (uses placeholder ID, will likely fail)
python adobe_ps_api.py update-text /path/to/json_file.json --no-upload
```

The command accepts JSON files in the same format as those generated by the text extraction scripts (`mac_ps_extract.py` and `batch_extract_text.py`).

### Updated Implementation

After reviewing the Adobe Firefly Services documentation at https://developer.adobe.com/firefly-services/docs/photoshop/, we've updated our implementation to use:

1. Pre-signed URLs for file uploads instead of a direct upload endpoint
2. The correct Firefly Services endpoints for Photoshop API operations

The updated implementation uses the following endpoints:

1. Pre-signed URL for uploads: `https://firefly-api.adobe.io/v2/storage/presignedUrl`
2. Text editing API: `https://firefly-api.adobe.io/v2/photoshop/editText`

Each endpoint has a fallback in case the primary endpoint is not accessible:
1. Alternative pre-signed URL endpoint: `https://image.adobe.io/pie/psdService/presignedUrl`
2. Alternative text editing endpoint: `https://image.adobe.io/pie/psdService/text`

### Current Status

The implementation is now aligned with Adobe's current API documentation for Firefly Services. **Authentication is working successfully with the new credentials**, which is a major improvement. However, we're still facing issues with the specific service endpoints:

1. **Authentication Success ✓**: The new credentials successfully authenticate with Adobe's identity services:
   - The user info endpoint returns a 200 response
   - We can now make authenticated requests to Adobe's API services

2. **Service Endpoint Issues (404)**: While authentication works, we're still encountering 404 errors when trying to use the specific Photoshop API endpoints:
   - Pre-signed URL endpoints for file uploads return 404 errors
   - Photoshop text editing endpoints return 404 errors 
   - This suggests either the endpoints have changed or the account doesn't have access to these specific services

3. **Possible Solutions**:
   - The token may need additional API scopes beyond the current ones (`openid,AdobeID,read_organizations`)
   - Recommended additional scopes: `firefly_api`, `creative_sdk`, or specific Photoshop API scopes
   - The organization account may need to subscribe to the specific Photoshop API services
   - Adobe may have updated their endpoint URLs that aren't reflected in the documentation

4. **Next Steps**:
   - Contact Adobe Developer Support with the specific 404 errors
   - Check if the organization account has access to the Photoshop API services
   - Generate a new token with expanded scopes through the Adobe Developer Console
   - Test alternative endpoint URLs that might be mentioned in newer documentation

### API Authentication Success

The updated API credentials are now working for authentication:

```
API Key: 2d35c7a0f2344b24962f40979ea0c888
Access Token: [Updated token in adobe_ps_api.py]
```

Authentication is confirmed by:
- ✓ 200 response from the Adobe IMS user info endpoint
- ✓ Successful connection to the API documentation endpoints
- ✓ Response from the text editing endpoint (though with 400 error, which is expected without valid document IDs)

### API Diagnostics and Testing

You can run various diagnostic tools to check API connectivity and functionality:

```bash
# Test API connectivity
python adobe_ps_api.py test-api

# Test text editing API
python adobe_ps_api.py test-text-edit

# Preview text updates from a JSON file
python adobe_ps_api.py update-text /path/to/json_file.json --dry-run
```

These tests will check various Adobe API endpoints and report which ones are accessible, as well as attempt to test the text editing functionality.

### Next Development Steps

Based on our testing, we recommend the following development steps:

1. Test the full file upload and text update workflow with the new credentials
2. Verify the document ID retrieval process after upload
3. Ensure the text layer updates are correctly formatted for the API
4. Set up the download process for retrieving modified files

The complete workflow should now be functional:
1. Upload local PSD file to Adobe Creative Cloud
2. Get document ID from the uploaded file
3. Extract layer information to identify text layers
4. Update text using the API endpoint
5. Download the modified file back to the local system

## Working Local Scripts

The local scripts that interact directly with the installed Photoshop application remain functional as alternatives to the API approach:

- `batch_extract_text.py` - Extract text layers from local PSD files
- `batch_update_text.py` - Update text layers in local PSD files
- `mac_ps_extract.py` - Mac-specific version for text extraction
- `mac_ps_update.py` - Mac-specific version for text updating

### Requirements

- Python 3.6+
- Adobe Photoshop installed (for local scripts)
- Required Python packages:
  ```
  pip install photoshop-python-api  # For Windows scripts
  pip install requests  # For API diagnostics
  ```

### Usage (Local Scripts)

```bash
# Extract text from local PSD files
python batch_extract_text.py /path/to/psd_files -o /path/to/output_dir

# Update text in local PSD files
python batch_update_text.py /path/to/json_files -p /path/to/psd_files --save

# For Mac users:
python mac_ps_extract.py /path/to/psd_files -o /path/to/output_dir
python mac_ps_update.py /path/to/json_files -p /path/to/psd_files --save
```

## Workflow

1. **Extract text** from PSD files using the local scripts
2. **Edit** the resulting JSON files manually
3. **Update** the PSD files with the edited text using either:
   - The local scripts for direct Photoshop integration
   - The API scripts for cloud-based operations

## JSON Format

The JSON files contain the following information:

```json
{
  "documentName": "example.psd",
  "extractedAt": "2025-03-31 12:34:56",
  "dimensions": {
    "width": 1920,
    "height": 1080
  },
  "textLayerCount": 2,
  "textLayers": [
    {
      "id": "",
      "name": "Heading",
      "path": "Heading",
      "text": "Original Text",
      "updatedText": "Updated Text",
      "visible": true,
      "styleInfo": {
        "font": "Arial",
        "size": 24,
        "color": null,
        "alignment": "left",
        "styles": [
          {
            "start": 0,
            "end": 12,
            "text": "Original Text",
            "font": "Arial",
            "style": "Regular",
            "size": 24
          }
        ]
      },
      "hasRichTextFormatting": false
    }
  ]
}
```

## Troubleshooting

### Local Scripts
- Ensure Photoshop is installed and accessible
- On macOS, use the `mac_ps_*.py` scripts which are designed to work around compatibility issues
- On Windows, ensure `photoshop-python-api` is properly installed

### API Integration
- When using the API integration:
  1. Ensure your credentials are current and valid (the authentication test passes)
  2. Check that the PSD file can be successfully uploaded
  3. If endpoints return 404, try different endpoint URLs or contact Adobe support
  4. For DNS resolution issues, consider using a different network or VPN