AI core code examples

import openai  
from config import OPENAI_API_KEY  

class ContentGenerator:  
    def __init__(self, model="gpt-4-0613", temperature=0.7, max_tokens=1024):  
        self.model = model  
        self.temperature = temperature  
        self.max_tokens = max_tokens  
        openai.api_key = OPENAI_API_KEY  

    def generate_content(self, platform: str, topic: str, style: str) -> str:  
        prompt = f"""  
        Generate a {platform}-style post about '{topic}' in {style} tone.  
        Include:  
        1. Catchy headline  
        2. 3 key points with emojis  
        3. Call-to-action hashtags  
        """  
        response = openai.ChatCompletion.create(  
            model=self.model,  
            messages=[{"role": "user", "content": prompt}],  
            temperature=self.temperature,  
            max_tokens=self.max_tokens  
        )  
        return response.choices[0].message['content'].strip()  

# Example usage  
generator = ContentGenerator()  
xiaohongshu_post = generator.generate_content(  
    platform="Xiaohongshu",   
    topic="Sustainable Fashion",   
    style="inspirational"  
)  

from transformers import pipeline, AutoTokenizer, AutoModelForSeq2SeqLM  

class NeuralTranslator:  
    def __init__(self, model_name="facebook/m2m100_1.2B"):  
        self.tokenizer = AutoTokenizer.from_pretrained(model_name)  
        self.model = AutoModelForSeq2SeqLM.from_pretrained(model_name)  
        self.translator = pipeline(  
            "translation",  
            model=self.model,  
            tokenizer=self.tokenizer,  
            device=0 if torch.cuda.is_available() else -1  
        )  

    def translate(self, text: str, target_lang: str) -> str:  
        # Set target language token (e.g., "fr" for French)  
        self.tokenizer.tgt_lang = target_lang  
        translated = self.translator(  
            text,  
            max_length=512,  
            num_beams=5,  
            early_stopping=True  
        )  
        return translated[0]['translation_text']  

# Example usage  
translator = NeuralTranslator()  
english_to_french = translator.translate(  
    "Sustainable fashion reduces environmental impact",   
    target_lang="fr"  
)  

import tree_sitter  
from tree_sitter_languages import get_language  

class CodeAssistant:  
    def __init__(self):  
        self.parser = tree_sitter.Parser()  
        self.parser.set_language(get_language('python'))  

    def generate_code(self, task: str, context: str = "") -> str:  
        prompt = f"""  
        You are an expert programmer.  
        Context: {context}  
        Task: {task}  
        Output:  
        1. Complete code snippet  
        2. Brief explanation  
        3. Time complexity analysis  
        """  
        # ... GPT API call similar to ContentGenerator ...  

    def validate_syntax(self, code: str) -> bool:  
        tree = self.parser.parse(bytes(code, "utf8"))  
        return not tree.root_node.has_error  

# Example usage  
assistant = CodeAssistant()  
python_code = assistant.generate_code(  
    task="Implement quicksort in Python",  
    context="For educational purposes"  
)  
if assistant.validate_syntax(python_code):  
    print("Valid syntax")  

class SWOTAnalyzer:  
    SWOT_TEMPLATE = """  
    **Company:** {company}  
    **Industry:** {industry}  
    | Category       | Items                          |  
    |----------------|--------------------------------|  
    | **Strengths**  | {strengths}                    |  
    | **Weaknesses** | {weaknesses}                   |  
    | **Opportunities**| {opportunities}              |  
    | **Threats**    | {threats}                      |  
    """  

    def generate_swot(self, company: str, industry: str) -> str:  
        prompt = f"""  
        Generate comprehensive SWOT analysis for:  
        Company: {company}  
        Industry: {industry}  
        Output format:  
        - 4 strengths (bullet points)  
        - 4 weaknesses  
        - 4 opportunities  
        - 4 threats  
        """  
        # ... GPT API call ...  
        return self._format_swot(response, company, industry)  

    def _format_swot(self, raw_data: str, company: str, industry: str) -> str:  
        # Parse GPT response into structured template  
        # ... implementation omitted for brevity ...  
        return self.SWOT_TEMPLATE.format(  
            company=company,  
            industry=industry,  
            strengths="• "+raw_data.split("Strengths:")[1].split("Weaknesses:")[0].strip().replace("\n", "\n• "),  
            # ... similar parsing for other sections ...  
        )  

# Example usage  
analyzer = SWOTAnalyzer()  
swot_report = analyzer.generate_swot("Tesla", "Electric Vehicles")  

class VideoScriptEngine:  
    def __init__(self):  
        self.content_gen = ContentGenerator(model="gpt-4")  
        self.translator = NeuralTranslator()  

    def generate_script(self, topic: str, duration: int, target_lang: str = "en"):  
        # Generate base script  
        prompt = f"""  
        Create {duration}-minute video script about '{topic}' with:  
        1. Hook introduction (0:00-0:30)  
        2. 3 main segments with visual cues  
        3. Call-to-action conclusion  
        """  
        script = self.content_gen.generate_custom(prompt)  

        # Localize if needed  
        if target_lang != "en":  
            script = self.translator.translate(script, target_lang)  

        return self._add_timestamps(script, duration)  

    def _add_timestamps(self, script: str, duration: int) -> str:  
        # Algorithm to insert time markers  
        # ... implementation using regex and duration calculation ...