Comprehensive comparison for Cloud Platform technology in AI applications

import boto3
import json
import logging
from typing import Dict, List, Optional
from botocore.exceptions import ClientError

logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

class ProductDescriptionGenerator:
    def __init__(self, region_name: str = "us-east-1"):
        self.bedrock_runtime = boto3.client(
            service_name="bedrock-runtime",
            region_name=region_name
        )
        self.model_id = "anthropic.claude-3-sonnet-20240229-v1:0"
        self.max_tokens = 2000
        self.temperature = 0.7

    def generate_product_description(
        self,
        product_name: str,
        features: List[str],
        target_audience: str,
        tone: str = "professional"
    ) -> Optional[Dict[str, str]]:
        try:
            prompt = self._build_prompt(product_name, features, target_audience, tone)
            
            request_body = {
                "anthropic_version": "bedrock-2023-05-31",
                "max_tokens": self.max_tokens,
                "temperature": self.temperature,
                "messages": [
                    {
                        "role": "user",
                        "content": prompt
                    }
                ]
            }
            
            response = self.bedrock_runtime.invoke_model(
                modelId=self.model_id,
                contentType="application/json",
                accept="application/json",
                body=json.dumps(request_body)
            )
            
            response_body = json.loads(response["body"].read())
            generated_text = response_body["content"][0]["text"]
            
            logger.info(f"Successfully generated description for {product_name}")
            
            return {
                "product_name": product_name,
                "description": generated_text,
                "model_id": self.model_id,
                "input_tokens": response_body["usage"]["input_tokens"],
                "output_tokens": response_body["usage"]["output_tokens"]
            }
            
        except ClientError as e:
            error_code = e.response["Error"]["Code"]
            error_message = e.response["Error"]["Message"]
            logger.error(f"AWS Client Error: {error_code} - {error_message}")
            return None
            
        except KeyError as e:
            logger.error(f"Unexpected response structure: {str(e)}")
            return None
            
        except Exception as e:
            logger.error(f"Unexpected error: {str(e)}")
            return None

    def _build_prompt(
        self,
        product_name: str,
        features: List[str],
        target_audience: str,
        tone: str
    ) -> str:
        features_text = "\n".join([f"- {feature}" for feature in features])
        
        prompt = f"""Generate a compelling product description for an e-commerce website.

Product Name: {product_name}

Key Features:
{features_text}

Target Audience: {target_audience}
Tone: {tone}

Please create a description that:
1. Highlights the key benefits
2. Appeals to the target audience
3. Is SEO-friendly
4. Is between 150-200 words
5. Includes a call-to-action

Return only the product description without any additional commentary."""
        
        return prompt

if __name__ == "__main__":
    generator = ProductDescriptionGenerator(region_name="us-east-1")
    
    result = generator.generate_product_description(
        product_name="SmartFit Wireless Earbuds",
        features=[
            "Active noise cancellation",
            "30-hour battery life",
            "IPX7 waterproof rating",
            "Touch controls",
            "Premium sound quality"
        ],
        target_audience="fitness enthusiasts and commuters",
        tone="energetic and persuasive"
    )
    
    if result:
        print(json.dumps(result, indent=2))
    else:
        print("Failed to generate product description")