# Import the os module to interact with operating system features. This includes fetching environment variables.
import os
# Import the time module to perform time-related tasks, such as delays (sleep)
import time
# Import specific classes or functions directly from their modules to avoid prefixing them with the module name.
# Import the openAI library
import openai
from openai import OpenAI 
# Import the load_dotenv and find_dotenv functions from the dotenv package.
# These are used for loading environment variables from a .env file.
from dotenv import load_dotenv, find_dotenv

# Load environment variables from a .env file.
_ = load_dotenv(find_dotenv())

# Set the OpenAI API key by retrieving it from the environment variables.
openai.api_key  = os.environ['OPENAI_API_KEY'] 

# Print the version of the OpenAI library being used. 
print(openai.__version__)

# Initialize client
client = OpenAI()

# Store conversation history
conversation = [
    {
        "role": "system",
        "content": """
You are a professional AI career advisor.

Before giving advice, you must:
1. Ask about the user's education level.
2. Ask about technical background.
3. Ask about programming experience.
4. Ask about career goals.
5. Ask about time availability.

After collecting enough details,
create a customized AI career roadmap.
"""
    }
]

print("\n🤖 AI Career Assistant")
print("Type 'exit' to quit.\n")

while True:
    try:
        user_input = input("You: ")

        if user_input.lower() == "exit":
            print("Good luck with your AI journey 🚀")
            break

        # Add user message
        conversation.append({
            "role": "user",
            "content": user_input
        })

        # Send conversation to OpenAI
        response = client.responses.create(
            model="gpt-4.1-mini",  # Fast & affordable
            input=conversation
        )

        # Extract assistant reply safely
        reply = response.output_text

        print("\nAssistant:", reply, "\n")

        # Add assistant reply to memory
        conversation.append({
            "role": "assistant",
            "content": reply
        })

    except Exception as e:
        print("Error:", e)

  

// product-subgraph.ts - A federated Apollo subgraph
import { gql } from 'graphql-tag';
import { buildSubgraphSchema } from '@apollo/subgraph';
import { ApolloServer } from '@apollo/server';
import { startStandaloneServer } from '@apollo/server/standalone';

// 1. Define the GraphQL schema with @key directive for federation
const typeDefs = gql`
  extend schema
    @link(url: "https://specs.apollo.dev/federation/v2.3", 
          import: ["@key", "@shareable", "@external"])

  type Product @key(fields: "id") {
    id: ID!
    name: String!
    description: String
    price: Price!
    inventory: InventoryData
    reviews: [Review!]! @requires(fields: "id")
  }

  type Price {
    amount: Float!
    currency: String!
    discount: DiscountInfo
  }

  type DiscountInfo {
    percentage: Int
    validUntil: String
  }

  type InventoryData {
    stock: Int!
    warehouse: String
    lastRestocked: String
  }

  extend type Review @key(fields: "id") {
    id: ID! @external
    product: Product @requires(fields: "id")
  }

  type Query {
    product(id: ID!): Product
    productsByCategory(category: String!, limit: Int = 10): [Product!]!
    searchProducts(query: String!, filters: ProductFilters): ProductSearchResult!
  }

  input ProductFilters {
    minPrice: Float
    maxPrice: Float
    inStock: Boolean
    categories: [String!]
  }

  type ProductSearchResult {
    products: [Product!]!
    total: Int!
    pageInfo: PageInfo!
  }

  type PageInfo {
    hasNextPage: Boolean!
    endCursor: String
  }
`;

// 2. Implement resolvers with data loaders for N+1 prevention
const resolvers = {
  Product: {
    // Reference resolver for federated entities
    __resolveReference: async (reference, { dataSources }) => {
      return dataSources.productAPI.getProductById(reference.id);
    },
    
    // Resolver for reviews with batch loading
    reviews: async (product, _, { dataSources }) => {
      return dataSources.reviewAPI.getReviewsByProductId(product.id);
    },
    
    // Field-level resolver for computed fields
    inventory: async (product, _, { dataSources, cache }) => {
      const cacheKey = `inventory:${product.id}`;
      const cached = await cache.get(cacheKey);
      
      if (cached) return JSON.parse(cached);
      
      const inventory = await dataSources.inventoryAPI.getInventory(product.id);
      await cache.set(cacheKey, JSON.stringify(inventory), { ttl: 300 }); // 5 min cache
      return inventory;
    }
  },
  
  Query: {
    product: async (_, { id }, { dataSources, requestId }) => {
      console.log(`[${requestId}] Fetching product ${id}`);
      return dataSources.productAPI.getProductById(id);
    },
    
    productsByCategory: async (_, { category, limit }, { dataSources }) => {
      // Implement cursor-based pagination for scalability
      return dataSources.productAPI.getProductsByCategory(category, limit);
    },
    
    searchProducts: async (_, { query, filters }, { dataSources }) => {
      // Implement search with Elasticsearch/OpenSearch integration
      return dataSources.searchAPI.searchProducts(query, filters);
    }
  }
};

// 3. Data source implementation with Redis caching
class ProductAPI {
  private redis;
  private db;
  
  constructor(redisClient, dbConnection) {
    this.redis = redisClient;
    this.db = dbConnection;
  }
  
  async getProductById(id: string) {
    const cacheKey = `product:${id}`;
    
    // Check Redis cache first
    const cached = await this.redis.get(cacheKey);
    if (cached) {
      return JSON.parse(cached);
    }
    
    // Cache miss - query database
    const product = await this.db.query(
      `SELECT p.*, 
              json_build_object('amount', p.price_amount, 
                               'currency', p.price_currency) as price
       FROM products p 
       WHERE p.id = $1 AND p.status = 'active'`,
      [id]
    );
    
    if (product.rows.length === 0) return null;
    
    // Cache with adaptive TTL based on product popularity
    const ttl = await this.calculateAdaptiveTTL(id);
    await this.redis.setex(cacheKey, ttl, JSON.stringify(product.rows[0]));
    
    return product.rows[0];
  }
  
  private async calculateAdaptiveTTL(productId: string): Promise {
    // More popular products get shorter TTL for freshness
    const views = await this.redis.get(`views:${productId}`);
    const baseTTL = 300; // 5 minutes
    
    if (!views) return baseTTL;
    
    const viewCount = parseInt(views);
    if (viewCount > 1000) return 60; // 1 minute for popular items
    if (viewCount > 100) return 120; // 2 minutes
    return baseTTL;
  }
}

// 4. Build and start the server
const schema = buildSubgraphSchema({ typeDefs, resolvers });
const server = new ApolloServer({
  schema,
  plugins: [
    // Apollo Studio reporting
    ApolloServerPluginLandingPageLocalDefault({ embed: true }),
    // Query complexity analysis
    {
      async requestDidStart() {
        return {
          async didResolveOperation(context) {
            const complexity = calculateQueryComplexity(
              context.request.query,
              context.request.variables
            );
            if (complexity > 1000) {
              throw new GraphQLError('Query too complex');
            }
          }
        };
      }
    }
  ]
});

// Start server
const { url } = await startStandaloneServer(server, {
  listen: { port: 4001 },
  context: async ({ req }) => ({
    dataSources: {
      productAPI: new ProductAPI(redisClient, db),
      reviewAPI: new ReviewAPI(),
      inventoryAPI: new InventoryAPI(),
      searchAPI: new SearchAPI()
    },
    cache: redisClient,
    requestId: req.headers['x-request-id']
  })
});

console.log(`🚀 Product subgraph ready at ${url}`);

  

// advanced-caching.ts - Smart GraphQL caching with invalidation
import { parse, print, visit } from 'graphql';
import Redis from 'ioredis';
import { createHash } from 'crypto';

class GraphQLSmartCache {
  private redis: Redis;
  private cacheHits = 0;
  private cacheMisses = 0;
  
  constructor(redisUrl: string) {
    this.redis = new Redis(redisUrl);
  }
  
  // Generate cache key from query and variables
  private generateCacheKey(
    query: string, 
    variables: Record,
    userId?: string
  ): string {
    const ast = parse(query);
    
    // Normalize query (remove whitespace, sort fields)
    const normalizedQuery = this.normalizeQuery(ast);
    
    // Create hash of query + variables + user context
    const hashInput = JSON.stringify({
      query: normalizedQuery,
      variables: this.normalizeVariables(variables),
      user: userId || 'anonymous'
    });
    
    return `gql:${createHash('sha256').update(hashInput).digest('hex')}`;
  }
  
  // Cache GraphQL response with field-level invalidation tags
  async cacheResponse(
    query: string,
    variables: Record,
    response: any,
    options: {
      ttl: number;
      invalidationTags: string[];
      userId?: string;
    }
  ): Promise {
    const cacheKey = this.generateCacheKey(query, variables, options.userId);
    const cacheValue = JSON.stringify({
      data: response,
      timestamp: Date.now(),
      tags: options.invalidationTags
    });
    
    // Store main response
    await this.redis.setex(cacheKey, options.ttl, cacheValue);
    
    // Store reverse index for tag-based invalidation
    for (const tag of options.invalidationTags) {
      await this.redis.sadd(`tag:${tag}`, cacheKey);
    }
    
    // Store query pattern for pattern-based invalidation
    const queryPattern = this.extractQueryPattern(query);
    await this.redis.sadd(`pattern:${queryPattern}`, cacheKey);
  }
  
  // Retrieve cached response
  async getCachedResponse(
    query: string,
    variables: Record,
    userId?: string
  ): Promise {
    const cacheKey = this.generateCacheKey(query, variables, userId);
    const cached = await this.redis.get(cacheKey);
    
    if (cached) {
      this.cacheHits++;
      const parsed = JSON.parse(cached);
      
      // Check if cache is stale based on tags
      const isStale = await this.isCacheStale(parsed.tags);
      if (isStale) {
        await this.redis.del(cacheKey);
        this.cacheMisses++;
        return null;
      }
      
      return parsed.data;
    }
    
    this.cacheMisses++;
    return null;
  }
  
  // Invalidate cache by tags (e.g., when product data updates)
  async invalidateByTags(tags: string[]): Promise {
    for (const tag of tags) {
      const cacheKeys = await this.redis.smembers(`tag:${tag}`);
      
      if (cacheKeys.length > 0) {
        // Delete all cached entries with this tag
        await this.redis.del(...cacheKeys);
        await this.redis.del(`tag:${tag}`);
        
        console.log(`Invalidated ${cacheKeys.length} entries for tag: ${tag}`);
      }
    }
  }
  
  // Partial cache invalidation based on query patterns
  async invalidateByPattern(pattern: string): Promise {
    const cacheKeys = await this.redis.smembers(`pattern:${pattern}`);
    
    if (cacheKeys.length > 0) {
      // Invalidate matching queries
      await this.redis.del(...cacheKeys);
      await this.redis.del(`pattern:${pattern}`);
    }
  }
  
  // Extract invalidation tags from GraphQL query
  extractInvalidationTags(query: string): string[] {
    const ast = parse(query);
    const tags: string[] = [];
    
    visit(ast, {
      Field(node) {
        // Map fields to entity types for tagging
        const fieldToTagMap: Record = {
          'product': ['product'],
          'products': ['product:list'],
          'user': ['user'],
          'order': ['order', 'user:${userId}:orders']
        };
        
        if (fieldToTagMap[node.name.value]) {
          tags.push(...fieldToTagMap[node.name.value]);
        }
      }
    });
    
    return [...new Set(tags)]; // Remove duplicates
  }
  
  // Adaptive TTL based on query characteristics
  calculateAdaptiveTTL(query: string, userId?: string): number {
    const ast = parse(query);
    let maxTTL = 300; // Default 5 minutes
    
    // Adjust TTL based on query type
    visit(ast, {
      Field(node) {
        const fieldTTLs: Record = {
          'product': 60,           // Products update frequently
          'inventory': 30,         // Inventory changes often
          'userProfile': 86400,    // User profiles change rarely
          'catalog': 3600,         // Catalog changes daily
          'reviews': 1800          // Reviews update every 30 min
        };
        
        if (fieldTTLs[node.name.value]) {
          maxTTL = Math.min(maxTTL, fieldTTLs[node.name.value]);
        }
      }
    });
    
    // Authenticated users get fresher data
    if (userId) {
      maxTTL = Math.min(maxTTL, 120);
    }
    
    return maxTTL;
  }
  
  // Get cache statistics
  getStats() {
    const total = this.cacheHits + this.cacheMisses;
    const hitRate = total > 0 ? (this.cacheHits / total) * 100 : 0;
    
    return {
      hits: this.cacheHits,
      misses: this.cacheMisses,
      hitRate: `${hitRate.toFixed(2)}%`,
      total
    };
  }
}

// Usage example in a GraphQL resolver
const smartCache = new GraphQLSmartCache(process.env.REDIS_URL);

const productResolvers = {
  Query: {
    product: async (_, { id }, context) => {
      const query = context.queryString; // Original GraphQL query
      const userId = context.user?.id;
      
      // Try cache first
      const cached = await smartCache.getCachedResponse(query, { id }, userId);
      if (cached) {
        context.metrics.cacheHit();
        return cached;
      }
      
      // Cache miss - fetch from database
      const product = await db.products.findUnique({ where: { id } });
      
      // Cache the response
      const invalidationTags = smartCache.extractInvalidationTags(query);
      const ttl = smartCache.calculateAdaptiveTTL(query, userId);
      
      await smartCache.cacheResponse(
        query,
        { id },
        product,
        {
          ttl,
          invalidationTags,
          userId
        }
      );
      
      context.metrics.cacheMiss();
      return product;
    }
  },
  
  Mutation: {
    updateProduct: async (_, { id, input }, context) => {
      // Update product in database
      const updated = await db.products.update({
        where: { id },
        data: input
      });
      
      // Invalidate all caches related to this product
      await smartCache.invalidateByTags(['product', `product:${id}`]);
      
      return updated;
    }
  }
};

  

import requests
from bs4 import BeautifulSoup
from openai import OpenAI
import json

# Initialize OpenAI client
client = OpenAI(api_key="YOUR_API_KEY")

url = "https://example.com/product-page"
response = requests.get(url)
soup = BeautifulSoup(response.text, "html.parser")

# Extract visible text only
page_text = soup.get_text(separator="\n")

prompt = f"""
Extract the following details from the text:
- Product Name
- Price
- Description
- Key Features

Return output in JSON format.

TEXT:
{page_text}
"""

completion = client.chat.completions.create(
    model="gpt-4o-mini",
    messages=[{"role": "user", "content": prompt}],
)

result = completion.choices[0].message.content

print(result)