Tworzenie wzorców z miejscami do uzupełnienia

import openai

client = openai.OpenAI(api_key='sk-...')

EMAIL_TEMPLATE = '''Write a follow-up email from {sender_name} to {recipient_name}.
Context: {context}
Tone: {tone}
Length: {word_count} words.
Include a clear call to action: {cta}.
Do not mention competitors. Active voice. No bullet points.'''

def generate_email(sender, recipient, context, tone, word_count, cta):
    prompt = EMAIL_TEMPLATE.format(
        sender_name=sender,
        recipient_name=recipient,
        context=context,
        tone=tone,
        word_count=word_count,
        cta=cta
    )

    response = client.chat.completions.create(
        model='gpt-4o-mini',
        messages=[{'role': 'user', 'content': prompt}]
    )
    return response.choices[0].message.content

result = generate_email(
    sender='Sarah Chen',
    recipient='Mr. Patel',
    context='We met at the DevConf conference last week and discussed API integration.',
    tone='warm and professional',
    word_count=120,
    cta='Schedule a 20-minute demo call'
)
print(result)

import openai

client = openai.OpenAI(api_key='sk-...')

def generate_product_description(product, audience, tone, word_count, key_benefit):
    prompt = (
        f'Write a product description for {product}, designed for {audience}. '
        f'Tone: {tone}. '
        f'Length: {word_count} words. '
        f'Lead with this key benefit: {key_benefit}. '
        'Active voice. No bullet points. No pricing mentions.'
    )

    response = client.chat.completions.create(
        model='gpt-4o-mini',
        messages=[{'role': 'user', 'content': prompt}]
    )
    return response.choices[0].message.content

print(generate_product_description(
    product='FocusFlow, a time-blocking productivity app',
    audience='freelancers and independent consultants',
    tone='energetic and practical',
    word_count=150,
    key_benefit='Reclaim two hours every day by blocking distractions automatically'
))

def build_prompt(product, audience, tone='professional and friendly', word_count=200, format_style='prose'):
    format_instruction = {
        'prose': 'Write in continuous paragraphs. No bullet points.',
        'bullets': 'Use bullet points. Each point is one sentence.',
        'numbered': 'Use a numbered list. Each item is one sentence.'
    }.get(format_style, 'Write in continuous paragraphs.')

    return (
        f'Write a description of {product} for {audience}. '
        f'Tone: {tone}. '
        f'Length: {word_count} words. '
        f'{format_instruction} '
        'Active voice. No competitor mentions.'
    )

# Minimal call — uses all defaults
print(build_prompt('Notion', 'students'))

# Full call — overrides defaults
print(build_prompt('Notion', 'students', tone='casual', word_count=100, format_style='bullets'))

SYSTEM_TEMPLATE = 'You are a {role} writing for {company}. Your audience is {audience}. Style: {style}.'

USER_TEMPLATE = 'Write a {content_type} about {topic}. Length: {word_count} words. Deadline tone: {urgency}.'

import openai

client = openai.OpenAI(api_key='sk-...')

def generate(role, company, audience, style, content_type, topic, word_count, urgency):
    system_msg = SYSTEM_TEMPLATE.format(
        role=role, company=company, audience=audience, style=style
    )
    user_msg = USER_TEMPLATE.format(
        content_type=content_type, topic=topic,
        word_count=word_count, urgency=urgency
    )

    response = client.chat.completions.create(
        model='gpt-4o-mini',
        messages=[
            {'role': 'system', 'content': system_msg},
            {'role': 'user', 'content': user_msg}
        ]
    )
    return response.choices[0].message.content

import re

def validate_template(template_str, provided_vars):
    required = set(re.findall(r'\{\{(\w+)\}\}', template_str))
    missing = required - set(provided_vars.keys())

    if missing:
        raise ValueError(f'Missing required template variables: {missing}')

    return True

template = 'Write a {{word_count}}-word {{tone}} description of {{product}} for {{audience}}.'
vars_provided = {'word_count': 150, 'tone': 'friendly', 'product': 'TaskFlow'}

try:
    validate_template(template, vars_provided)
except ValueError as e:
    print(f'Template error: {e}')
    # Output: Template error: Missing required template variables: {{'audience'}}

def build_report_prompt(topic, audience, word_count, include_recommendations=False, cta=None):
    prompt = f'Write a report on {topic} for {audience}. Length: {word_count} words. Active voice.'

    if include_recommendations:
        prompt += ' End with a numbered list of 3 specific recommendations.'

    if cta:
        prompt += f' Close with this call to action: {cta}'

    return prompt

# Without optional sections
print(build_report_prompt('cloud cost optimization', 'engineering managers', 400))

# With optional sections
print(build_report_prompt(
    topic='cloud cost optimization',
    audience='engineering managers',
    word_count=600,
    include_recommendations=True,
    cta='Book a cost audit with our team at cloudcost.io'
))

VALID_TONES = ['professional', 'casual', 'urgent', 'empathetic', 'enthusiastic']
VALID_FORMATS = ['prose', 'bullets', 'numbered', 'table']

def generate_content(topic, tone, format_style, word_count):
    if tone not in VALID_TONES:
        raise ValueError(f'Invalid tone: {tone}. Choose from: {VALID_TONES}')
    if format_style not in VALID_FORMATS:
        raise ValueError(f'Invalid format: {format_style}. Choose from: {VALID_FORMATS}')

    format_map = {
        'prose': 'continuous paragraphs, no lists',
        'bullets': 'bullet points',
        'numbered': 'numbered list',
        'table': 'a markdown table'
    }

    prompt = (f'Write about {topic} in {tone} tone. '
              f'Format: {format_map[format_style]}. '
              f'Length: {word_count} words. Active voice.')

    return prompt