fsdfsd

app.py

@@ -1,4 +1,31 @@
 import streamlit as st
+import json
+import yaml
+
+# Load logged-in user data from YAML file
+
+
+def load_logged_in_user():
+    user_file = "/home/vscode/Brads_Store/config/logged_in_user.yml"
+    try:
+        with open(user_file, "r") as file:
+            user_data = yaml.safe_load(file)
+            return user_data.get("username", "")
+    except FileNotFoundError:
+        return ""
+
+# Load cart data from JSON file, filtered by logged-in user
+
+
+def load_cart_data(username):
+    cart_file = "/home/vscode/Brads_Store/pages/config/cart_data.json"
+    try:
+        with open(cart_file, "r") as file:
+            cart_data = json.load(file)
+            return [item for item in cart_data if item.get("username") == username]
+    except FileNotFoundError:
+        return []
+
 
 # Set page config
 st.set_page_config(
@@ -8,63 +35,12 @@ st.set_page_config(
     initial_sidebar_state="expanded"
 )
 
-# Add custom CSS for modern sidebar styling
-st.markdown("""
-<style>
-    [data-testid="stSidebarContent"] {
-        background-color: #444444;
-        padding: 1rem;
-    }
-    .cart-header {
-        display: flex;
-        justify-content: space-between;
-        align-items: center;
-        margin-bottom: 15px;
-        padding-bottom: 10px;
-        border-bottom: 1px solid #eee;
-    }
-    .cart-item {
-        background-color: #555555;
-        border-radius: 8px;
-        padding: 10px;
-        margin-bottom: 10px;
-        box-shadow: 0 1px 3px rgba(0,0,0,0.1);
-    }
-    .cart-controls {
-        display: flex;
-        align-items: center;
-        justify-content: space-between;
-        margin-top: 8px;
-    }
-    .quantity-display {
-        text-align: center;
-        font-weight: bold;
-        margin: 5px 0;
-    }
-    .cart-total {
-        margin-top: 15px;
-        padding-top: 15px;
-        border-top: 1px solid #eee;
-        font-weight: bold;
-        font-size: 16px;
-    }
-    .empty-cart {
-        text-align: center;
-        padding: 20px 0;
-    }
-    .quantity-row {
-        display: flex;
-        justify-content: center;
-        align-items: center;
-        gap: 10px;
-        margin-top: 8px;
-    }
-</style>
-""", unsafe_allow_html=True)
+# Get logged-in user
+logged_in_user = load_logged_in_user()
 
 # Initialize session state variables
 if 'cart' not in st.session_state:
-    st.session_state.cart = []
+    st.session_state.cart = load_cart_data(logged_in_user)
 
 if 'show_cart' not in st.session_state:
     st.session_state.show_cart = False
@@ -74,13 +50,13 @@ if 'show_cart' not in st.session_state:
 
 def add_to_cart(product_name, price, quantity):
     for item in st.session_state.cart:
-        if item["name"] == product_name:
+        if item["product_name"] == product_name:
             item["quantity"] += quantity
             st.toast(f"Added {quantity} more {product_name} to cart!")
             return
 
     st.session_state.cart.append({
-        "name": product_name,
+        "product_name": product_name,
         "price": price,
         "quantity": quantity
     })
@@ -89,89 +65,86 @@ def add_to_cart(product_name, price, quantity):
 
 # Define your pages
 home_page = st.Page("pages/home.py", title="Home", icon="🏠")
-prints_page = st.Page("pages/prints.py", title="Prints", icon="🖼️")
-clothing_page = st.Page("pages/charcuterie_boards.py",
-                        title="Charcuterie Boards", icon="👕")
+cutting_boards_page = st.Page(
+    "pages/cutting_boards.py", title="Cutting Boards", icon="🥠")
+charcuterie_page = st.Page(
+    "pages/charcuterie_boards.py", title="Charcuterie Boards", icon="🍴")
 accessories_page = st.Page("pages/accessories.py",
                            title="Accessories", icon="🧢")
 about_page = st.Page("pages/about.py", title="About", icon="ℹ️")
+cart_page = st.Page("pages/cart.py", title="Shopping Cart", icon="🛒")
+login_page = st.Page("pages/login_page.py", title="User Login Page", icon="🔒")
 
 # Create navigation
-pg = st.navigation([home_page, prints_page, clothing_page,
-                   accessories_page, about_page])
+pg = st.navigation([home_page, cutting_boards_page, charcuterie_page,
+                   accessories_page, cart_page, about_page, login_page])
 
 # Cart in sidebar
 with st.sidebar:
     cart_count = sum(item.get("quantity", 1) for item in st.session_state.cart)
 
-    st.markdown(
-        f"""
-        <div class="cart-header">
-            <span style="font-size: 18px; font-weight: bold;">Shopping Cart</span>
-            <span style="background-color: #1E90FF; color: white; padding: 2px 8px; border-radius: 12px; font-size: 14px;">{cart_count}</span>
-        </div>
-        """,
-        unsafe_allow_html=True
-    )
+    with st.container(border=True):
+        st.markdown(
+            f"""
+            <div class="cart-header">
+                <span style="font-size: 18px; font-weight: bold;">Shopping Cart</span>
+                <span style="background-color: #1E90FF; color: white; padding: 2px 8px; border-radius: 12px; font-size: 14px;">{cart_count}</span>
+            </div>
+            """,
+            unsafe_allow_html=True
+        )
 
     if not st.session_state.cart:
-        st.markdown('<div class="empty-cart">Your cart is empty</div>',
-                    unsafe_allow_html=True)
+        with st.container(border=True):
+            st.markdown(
+                '<div class="empty-cart">Your cart is empty</div>', unsafe_allow_html=True)
     else:
         for i, item in enumerate(st.session_state.cart):
+            product_name = item['product_name']
             price_display = item['price']
             quantity = item.get('quantity', 1)
 
+            # Create an expander for each item
+            with st.expander(f"{product_name} - {price_display}", expanded=False):
+                with st.container(border=True):
+                    st.markdown(
+                        '<div class="quantity-row" style="display: flex; justify-content: center; align-items: center;">', unsafe_allow_html=True)
+                    col1, col2, col3 = st.columns([1, 2, 1])
+                    with col1:
+                        if st.button("➖", key=f"decrease_{i}", help="Decrease quantity"):
+                            if item["quantity"] > 1:
+                                item["quantity"] -= 1
+                            else:
+                                st.session_state.cart.pop(i)
+                            st.rerun()
+                    with col2:
+                        st.markdown(
+                            f"<div style='text-align: center; font-weight: bold;'>Qty: {quantity}</div>", unsafe_allow_html=True)
+                    with col3:
+                        if st.button("➕", key=f"increase_{i}", help="Increase quantity"):
+                            item["quantity"] += 1
+                            st.rerun()
+                    st.markdown('</div>', unsafe_allow_html=True)
+
+                    if st.button("🗑️ Remove", key=f"remove_{i}", help="Remove from cart", use_container_width=True):
+                        st.session_state.cart.pop(i)
+                        st.rerun()
+
+        total = sum(float(item["price"].replace(
+            "$", "")) * item.get("quantity", 1) for item in st.session_state.cart)
+
+        with st.container(border=True):
             st.markdown(
                 f"""
-                <div class="cart-item">
-                    <div style="display: flex; justify-content: space-between;">
-                        <span style="font-weight: bold;">{item['name']}</span>
-                        <span>{price_display}</span>
-                    </div>
+                <div class="cart-total">
+                    Total: <span style="color: #1E90FF;">${total:.2f}</span>
                 </div>
                 """,
                 unsafe_allow_html=True
             )
 
-            st.markdown('<div class="quantity-row">', unsafe_allow_html=True)
-            col1, col2, col3 = st.columns([1, 2, 1])
-            with col1:
-                if st.button("➖", key=f"decrease_{i}", help="Decrease quantity"):
-                    if item["quantity"] > 1:
-                        item["quantity"] -= 1
-                    else:
-                        st.session_state.cart.pop(i)
-                    st.rerun()
-            with col2:
-                st.markdown(
-                    f"<span style='font-weight: bold;'>{quantity}</span>", unsafe_allow_html=True)
-            with col3:
-                if st.button("➕", key=f"increase_{i}", help="Increase quantity"):
-                    item["quantity"] += 1
-                    st.rerun()
-            st.markdown('</div>', unsafe_allow_html=True)
-
-            if st.button("🗑️", key=f"remove_{i}", help="Remove from cart"):
-                st.session_state.cart.pop(i)
-                st.rerun()
-
-        total = sum(float(item["price"].replace(
-            "$", "")) * item.get("quantity", 1) for item in st.session_state.cart)
-
-        st.markdown(
-            f"""
-            <div class="cart-total">
-                Total: <span style="color: #1E90FF;">${total:.2f}</span>
-            </div>
-            """,
-            unsafe_allow_html=True
-        )
-
         if st.button("Proceed to Checkout", key="checkout", use_container_width=True):
-            st.success("Thank you for your purchase! (This is a demo)")
-            st.session_state.cart = []
-            st.rerun()
+            st.switch_page("pages/cart.py")
 
 # Run the current page
 pg.run()

config/logged_in_user.yml

@@ -0,0 +1,2 @@
+role: user
+username: testtt

pages/about.py

@@ -10,7 +10,6 @@ load_dotenv()
 st.title("SambaNova Chat with Llama-3.3-70B")
 
 # File paths
-SEARCH_RESULTS_PATH = "search_results.txt"
 PROMPT_TEMPLATE_PATH = "summary_prompt.txt"
 
 # Initialize the client with API key from .env
@@ -56,31 +55,25 @@ def stream_sambanova_response(messages_for_api):
 
 # Chat input
 if user_input := st.chat_input("Ask something..."):
-    # Dynamically load the latest contents of the files
+    # Load the latest contents of the prompt template
     prompt_template = read_file(PROMPT_TEMPLATE_PATH)
-    search_results = read_file(SEARCH_RESULTS_PATH)
 
-    # Ensure that the content of both files is available
-    if not prompt_template or not search_results:
-        st.error("Error loading necessary files.")
+    # Ensure the prompt template is available
+    if not prompt_template:
+        st.error("Error loading the prompt template.")
     else:
-        # Display the loaded search results so we can verify they're being fetched correctly
-        st.subheader("Loaded Search Results:")
-        st.text_area("Search Results", search_results, height=300)
-
-        # Prepare the full prompt with the latest file contents
+        # Prepare the full prompt in the background, without displaying it
         full_prompt = prompt_template.replace("{user_input}", user_input)
-        full_prompt = full_prompt.replace("{search_results}", search_results)
 
         # Add user message to chat history
         st.session_state.messages.append(
-            {"role": "user", "content": full_prompt})
+            {"role": "user", "content": user_input})
 
         # Display user message
         with st.chat_message("user"):
-            st.markdown(full_prompt)
+            st.markdown(user_input)
 
-        # Prepare API call with conversation history
+        # Prepare API call with conversation history, ensuring the model sees the full prompt
         messages_for_api = st.session_state.messages[:-1] + [
             {"role": "user", "content": full_prompt}]
 

pages/accessories.py

@@ -1,143 +1,122 @@
 import streamlit as st
 import yaml
+import hashlib
 import os
-import base64
-
-# Define the path to the custom icon
-icon_path = "/home/vscode/Brads_Store/pages/config/images/icon2.png"
-
-
-def load_image_as_base64(image_path):
-    with open(image_path, "rb") as img_file:
-        return base64.b64encode(img_file.read()).decode()
-
-
-# Load the icon image as base64
-icon_base64 = load_image_as_base64(icon_path)
-
-# Custom CSS for container styling
-custom_css = f"""
-<style>
-    .title-container {{
-        display: flex;
-        align-items: center;
-        background-color: #444;
-        padding: 10px 20px;
-        border-radius: 15px;
-        transition: background-color 0.3s ease, transform 0.3s ease;
-        box-shadow: 0px 4px 10px rgba(0, 0, 0, 0.1);
-        margin-bottom: 30px;
-        border: 2px solid #007BFF;
-    }}
-    .title-icon {{
-        width: 80px;
-        height: 80px;
-        background-image: url(data:image/png;base64,{icon_base64});
-        background-size: cover;
-        margin-right: 15px;
-        transition: transform 0.5s ease;
-    }}
-    .title-container:hover .title-icon {{
-        transform: rotate(360deg);
-    }}
-    .title-text {{
-        font-size: 2.5em;
-        font-weight: bold;
-        color: white;
-        transition: color 0.3s ease;
-    }}
-    .title-container:hover .title-text {{
-        color: #007BFF;
-    }}
-    .product-card {{
-        text-align: center;
-        margin-bottom: 20px;
-        padding: 15px;
-        border: 2px solid #007BFF;
-        border-radius: 10px;
-        background-color: #444;
-        color: white;
-    }}
-    .product-card h3 {{
-        background-color: #444;
-        color: white;
-        padding: 10px;
-        border-radius: 5px;
-    }}
-    .product-card p {{
-        background-color: #444;
-        color: white;
-        padding: 5px;
-        border-radius: 5px;
-        display: inline-block;
-        font-weight: bold;
-    }}
-</style>
-<div class="title-container">
-    <div class="title-icon"></div>
-    <div class="title-text">Charcuterie Boards Collection</div>
-</div>
-"""
-
-# Inject the custom CSS and HTML into the Streamlit app
-st.markdown(custom_css, unsafe_allow_html=True)
-
-# Header Section with Container
-with st.container(border=True):
-    st.markdown("""
-    <h3 style='margin-bottom: 20px; color: white;'>Cutting boards that tell a story: handmade with love.</h3>
-    """, unsafe_allow_html=True)
-
-# Load YAML file
-yaml_file_path = "/home/vscode/Brads_Store/pages/config/images_config_cuttting_boards.yml"
-if not os.path.exists(yaml_file_path):
-    st.error("Configuration file not found!")
-    st.stop()
-
-with open(yaml_file_path, "r") as file:
-    product_data = yaml.safe_load(file)
-
-# Filter products
-prints = {name: info for name, info in product_data["items"].items(
-) if info.get("category", "") == "print"} or product_data["items"]
-
-# Display products in a structured container
-total_products = len(prints)
-num_columns = 3
-
-with st.container(border=True):
-    for i in range(0, total_products, num_columns):
-        cols = st.columns(num_columns)
-        for j in range(num_columns):
-            if i + j < total_products:
-                product_name = list(prints.keys())[i + j]
-                product_info = prints[product_name]
-                with cols[j]:
-                    with st.container(border=True):
-                        st.markdown(f"""
-                        <div class="product-card">
-                            <h3>{product_name}</h3>
-                            <p><b>{product_info['price']}</b></p>
-                        </div>
-                        """, unsafe_allow_html=True)
-                        st.image(product_info["image_path"],
-                                 use_container_width=True)
-
-                        with st.expander("View Details"):
-                            st.subheader(product_name)
-                            st.write(f"**Price:** {product_info['price']}")
-                            st.write(product_info["description"])
-
-                            quantity = st.number_input(
-                                "Quantity:", min_value=1, value=1, step=1, key=f"quantity_{i + j}"
-                            )
-                            if st.button("🛒 Add to Cart", key=f"btn_{i + j}"):
-                                if 'cart' not in st.session_state:
-                                    st.session_state.cart = []
-                                st.session_state.cart.append({
-                                    "name": product_name,
-                                    "price": product_info['price'],
-                                    "quantity": quantity
-                                })
-                                st.success(
-                                    f"Added {quantity} {product_name} to cart!")
+
+# File paths
+USERS_FILE = "/home/vscode/Brads_Store/pages/config/users.yml"
+LOGGED_IN_FILE = "/home/vscode/Brads_Store/config/logged_in_user.yml"
+
+# Load users from YAML file
+
+
+def load_users():
+    with open(USERS_FILE, "r") as file:
+        return yaml.safe_load(file)["users"]
+
+# Save users to YAML file
+
+
+def save_users(users):
+    with open(USERS_FILE, "w") as file:
+        yaml.dump({"users": users}, file)
+
+# Save logged in user
+
+
+def save_logged_in_user(username, role):
+    # Create directory if it doesn't exist
+    os.makedirs(os.path.dirname(LOGGED_IN_FILE), exist_ok=True)
+    with open(LOGGED_IN_FILE, "w") as file:
+        yaml.dump({"username": username, "role": role}, file)
+
+# Hash function for passwords
+
+
+def hash_password(password):
+    return hashlib.sha256(password.encode()).hexdigest()
+
+# Authenticate user
+
+
+def authenticate(username, password):
+    users = load_users()
+    for user in users:
+        if user["username"] == username and user["password"] == password:
+            return user["role"]
+    return None
+
+# Add new user
+
+
+def add_user(username, password, role):
+    users = load_users()
+    if any(user["username"] == username for user in users):
+        return False  # Username already exists
+    users.append({"username": username, "password": password, "role": role})
+    save_users(users)
+    return True
+
+
+# Streamlit UI
+st.title("Login Page")
+username = st.text_input("Username")
+password = st.text_input("Password", type="password")
+
+if st.button("Login"):
+    role = authenticate(username, password)
+    if role:
+        save_logged_in_user(username, role)
+        st.success(f"Welcome, {username}! Role: {role}")
+        st.session_state.logged_in = True
+        st.session_state.username = username
+        st.session_state.role = role
+    else:
+        st.error("Invalid username or password")
+
+# Add New User section in a popover
+with st.popover("Add New User"):
+    new_username = st.text_input("New Username")
+    new_password = st.text_input("New Password", type="password")
+    confirm_password = st.text_input("Confirm Password", type="password")
+    new_role = st.selectbox("Role", ["user", "admin"])
+
+    # Check if passwords match
+    passwords_match = new_password == confirm_password
+
+    # Show match status if both fields have input
+    if new_password and confirm_password:
+        if passwords_match:
+            st.success("Passwords match!")
+        else:
+            st.warning("Sorry, the passwords didn't match")
+
+    if st.button("Add User"):
+        if not new_username or not new_password:
+            st.error("Username and password are required")
+        elif not passwords_match:
+            st.error("Passwords do not match. Please try again.")
+        elif add_user(new_username, new_password, new_role):
+            # Log in the new user automatically
+            save_logged_in_user(new_username, new_role)
+            st.success(
+                f"User added successfully! You are now logged in as {new_username}")
+            st.session_state.logged_in = True
+            st.session_state.username = new_username
+            st.session_state.role = new_role
+            st.rerun()  # Rerun the app to update the UI
+        else:
+            st.error("Username already exists. Please choose a different one.")
+
+# Display logged in status if in session state
+if st.session_state.get('logged_in'):
+    st.sidebar.success(f"Logged in as: {st.session_state.username}")
+    if st.sidebar.button("Log out"):
+        # Clear the logged in user file
+        if os.path.exists(LOGGED_IN_FILE):
+            os.remove(LOGGED_IN_FILE)
+        # Clear session state
+        st.session_state.logged_in = False
+        st.session_state.pop('username', None)
+        st.session_state.pop('role', None)
+        st.rerun()

pages/cart.py

@@ -0,0 +1,143 @@
+import streamlit as st
+import json
+import yaml
+from pathlib import Path
+
+# Load logged-in user data from YAML file
+
+
+def load_logged_in_user():
+    user_file = Path("/home/vscode/Brads_Store/config/logged_in_user.yml")
+    try:
+        with user_file.open("r") as file:
+            user_data = yaml.safe_load(file)
+            return user_data.get("username", "")
+    except FileNotFoundError:
+        return ""
+
+# Load cart data from JSON file, filtered by logged-in user
+
+
+def load_cart_data(username):
+    cart_file = Path("/home/vscode/Brads_Store/pages/config/cart_data.json")
+    try:
+        with cart_file.open("r") as file:
+            cart_data = json.load(file)
+            return [item for item in cart_data if item.get("username") == username]
+    except FileNotFoundError:
+        return []
+
+# Save updated cart data to JSON file
+
+
+def save_cart_data(cart_data):
+    cart_file = Path("/home/vscode/Brads_Store/pages/config/cart_data.json")
+    try:
+        with cart_file.open("w") as file:
+            json.dump(cart_data, file, indent=4)
+    except Exception as e:
+        st.error(f"Error saving cart data: {e}")
+
+# Load product details from combined_items.yml
+
+
+def load_product_details():
+    items_file = Path(
+        "/home/vscode/Brads_Store/pages/config/combined_items.yml")
+    try:
+        with items_file.open("r") as file:
+            items_data = yaml.safe_load(file)
+            return items_data.get("items", {})
+    except FileNotFoundError:
+        return {}
+
+
+# Main app container
+main_container = st.container(border=False)
+
+# Sidebar user info with styling
+with st.sidebar:
+    st.divider()
+    user_container = st.container(border=True)
+    with user_container:
+        # Get logged-in user
+        logged_in_user = load_logged_in_user()
+        st.subheader(f"Logged in as: {logged_in_user}")
+    st.divider()
+
+# Initialize session state variables
+if 'cart' not in st.session_state:
+    st.session_state.cart = load_cart_data(logged_in_user)
+
+# Load product details
+product_details = load_product_details()
+
+with main_container:
+    st.title("🛒 Your Shopping Cart")
+    st.divider()
+
+    # Cart items container
+    cart_container = st.container(border=False)
+    with cart_container:
+        st.subheader("Your Cart Items")
+
+        if not st.session_state.cart:
+            empty_cart = st.container(border=True, height=100)
+            empty_cart.write("Your cart is empty.")
+        else:
+            updated_cart = []
+            for i, item in enumerate(st.session_state.cart):
+                # Create a container for each item with border
+                item_container = st.container(border=True)
+                with item_container:
+                    product_name = item['product_name']
+                    product_info = product_details.get(product_name, {})
+                    image_path = product_info.get('image_path', '')
+                    description = product_info.get(
+                        'description', 'No description available.')
+
+                    # Create columns for layout
+                    col1, col2, col3 = st.columns([1, 2, 1])
+                    with col1:
+                        if image_path:
+                            st.image(image_path, width=100)
+                    with col2:
+                        st.markdown(f"**{product_name}**")
+                        st.caption(description)
+                        quantity = st.number_input(
+                            "Qty",
+                            min_value=1,
+                            value=item.get('quantity', 1),
+                            key=f"qty_{product_name}_{i}",  # Ensure uniqueness
+                            label_visibility="collapsed",
+                            format="%d",
+                            step=1
+                        )
+                        item['quantity'] = quantity
+                    with col3:
+                        # Unique key
+                        if st.button("Remove", key=f"remove_{product_name}_{i}"):
+                            st.session_state.cart.pop(i)  # Remove the item
+                            # Save updated cart
+                            save_cart_data(st.session_state.cart)
+                            st.rerun()  # Refresh the UI after removal
+
+                updated_cart.append(item)
+
+                # Add a small divider between items (except after the last item)
+                if i < len(st.session_state.cart) - 1:
+                    st.markdown("<br>", unsafe_allow_html=True)
+
+            # Update the session state with the modified cart
+            st.session_state.cart = updated_cart
+            save_cart_data(st.session_state.cart)
+
+    st.divider()
+
+    # Total container with styling
+    total_container = st.container(border=True)
+    with total_container:
+        # Total Calculation
+        total = sum(float(item["price"].replace("$", "")) *
+                    item.get("quantity", 1) for item in st.session_state.cart)
+        st.subheader(f"**Total: ${total:.2f}**")

pages/charcuterie_boards.py

@@ -2,9 +2,17 @@ import streamlit as st
 import yaml
 import os
 import base64
+import json
+from datetime import datetime
 
-# Define the path to the custom icon
-icon_path = "/home/vscode/Brads_Store/pages/config/images/icon1.png"
+# Define file paths
+icon_path = "pages/config/images/icon1.png"
+css_path = "pages/styles/page_style1.css"
+yaml_file_path = "pages/config/items/images_config_charcuterie_boards.yml"
+CART_FILE = "pages/config/cart_data.json"
+logged_user_file = "config/logged_in_user.yml"
+
+# Function to load an image as base64
 
 
 def load_image_as_base64(image_path):
@@ -15,96 +23,86 @@ def load_image_as_base64(image_path):
 # Load the icon image as base64
 icon_base64 = load_image_as_base64(icon_path)
 
-# Custom CSS for padding and styling
-custom_css = f"""
-<style>
-    /* Title Container */
-    .title-container {{
-        display: flex;
-        align-items: center;
-        background-color: rgba(255, 255, 255, 0.8);
-        padding: 10px 20px;
-        border-radius: 15px;
-        transition: background-color 0.3s ease, transform 0.3s ease;
-        box-shadow: 0px 4px 10px rgba(0, 0, 0, 0.1);
-        margin-bottom: 30px; /* Adds space between title and header */
-    }}
-    .title-container:hover {{
-        background-color: rgba(255, 255, 255, 1);
-        transform: scale(1.05);
-    }}
-    .title-icon {{
-        width: 80px;
-        height: 80px;
-        background-image: url(data:image/png;base64,{icon_base64});
-        background-size: cover;
-        margin-right: 15px;
-        transition: transform 0.5s ease;
-    }}
-    .title-container:hover .title-icon {{
-        transform: rotate(360deg);
-    }}
-    .title-text {{
-        font-size: 2.5em;
-        font-weight: bold;
-        color: #333;
-        transition: color 0.3s ease;
-    }}
-    .title-container:hover .title-text {{
-        color: #007BFF;
-    }}
-
-    /* Section Styling */
-    .section {{
-        margin-top: 50px; /* Adds space between sections */
-    }}
-
-    /* Product Card Styling */
-    .product-card {{
-        text-align: center;
-        margin-bottom: 30px;
-    }}
-    .product-card h3 {{
-        margin-bottom: 10px;
-    }}
-    .product-card p {{
-        margin-top: 0;
-    }}
-
-    /* Expander Customization */
-    .streamlit-expanderHeader {{
-        background-color: #f0f2f6; /* Header background color */
-        color: #333; /* Header text color */
-        font-weight: bold;
-        padding: 10px;
-        border-radius: 5px;
-    }}
-    .streamlit-expanderContent {{
-        background-color: #ffffff; /* Content background color */
-        padding: 10px;
-        border: 1px solid #e6e6e6;
-        border-top: none;
-        border-radius: 0 0 5px 5px;
-    }}
-</style>
-<div class="title-container">
-    <div class="title-icon"></div>
-    <div class="title-text">Charcuterie Boards Collection</div>
-</div>
-"""
-
-# Inject the custom CSS and HTML into the Streamlit app
-st.markdown(custom_css, unsafe_allow_html=True)
-
-# Header text with padding
-st.markdown("""
-<div style='margin-bottom: 50px;'>
-    <h3>Vibrant psychedelic prints for your walls</h3>
-</div>
+# Function to load CSS from file
+
+
+def load_css(file_path):
+    with open(file_path, "r") as f:
+        return f"<style>{f.read()}</style>"
+
+
+st.markdown(load_css(css_path), unsafe_allow_html=True)
+
+# Function to load the logged-in user from YAML
+
+
+def load_logged_in_user():
+    if os.path.exists(logged_user_file):
+        with open(logged_user_file, "r") as f:
+            data = yaml.safe_load(f)
+            return data.get("username", "guest")
+    return "guest"
+
+
+# Use the logged-in user automatically
+username = load_logged_in_user()
+
+# Functions to load and save cart data from/to JSON file
+
+
+def load_cart_data():
+    if os.path.exists(CART_FILE):
+        with open(CART_FILE, "r") as f:
+            try:
+                return json.load(f)
+            except json.JSONDecodeError:
+                return []
+    return []
+
+
+def save_cart_data(data):
+    with open(CART_FILE, "w") as f:
+        json.dump(data, f, indent=4)
+
+
+# Header Section with Icon and Title
+st.markdown(f"""
+    <style>
+        .title-container {{
+            display: flex;
+            align-items: center;
+            justify-content: center;
+            background-color: #444;
+            padding: 10px 20px;
+            border-radius: 15px;
+            box-shadow: 0px 4px 10px rgba(0, 0, 0, 0.1);
+            margin-bottom: 30px;
+            border: 2px solid #007BFF;
+        }}
+        .title-icon {{
+            width: 80px;
+            height: 80px;
+            background-image: url(data:image/png;base64,{icon_base64});
+            background-size: cover;
+            margin-right: 15px;
+        }}
+        .title-text {{
+            font-size: 2.5em;
+            font-weight: bold;
+            color: white;
+            transition: color 0.3s ease;
+        }}
+        .title-container:hover .title-text {{
+            color: #007BFF;
+        }}
+    </style>
+    <div class="title-container">
+        <div class="title-icon"></div>
+        <div class="title-text">Cutting Boards That Tell a Story</div>
+    </div>
 """, unsafe_allow_html=True)
 
-# Load YAML file
-yaml_file_path = "/home/vscode/Brads_Store/pages/config/images_config_cuttting_boards.yml"
+# Load product data from YAML file
 if not os.path.exists(yaml_file_path):
     st.error("Configuration file not found!")
     st.stop()
@@ -112,55 +110,64 @@ if not os.path.exists(yaml_file_path):
 with open(yaml_file_path, "r") as file:
     product_data = yaml.safe_load(file)
 
-# Filter for prints only (assuming you have a category field in your YAML)
+# Filter products (if 'category' equals "print", otherwise use all products)
 prints = {name: info for name, info in product_data["items"].items(
-) if info.get("category", "") == "print"}
-
-# If no prints found, show all products
-if not prints:
-    prints = product_data["items"]
+) if info.get("category", "") == "print"} or product_data["items"]
 
-# Display prints in a grid layout
-product_names = list(prints.keys())
-num_products = len(product_names)
+# Display products in a structured container
+total_products = len(prints)
 num_columns = 3
 
-for i in range(0, num_products, num_columns):
-    cols = st.columns(num_columns)
-    for j in range(num_columns):
-        if i + j < num_products:
-            product_name = product_names[i + j]
-            product_info = prints[product_name]
-            with cols[j]:
-                st.markdown(f"""
-                <div class="product-card">
-                    <h3>{product_name}</h3>
-                    <p><b>{product_info['price']}</b></p>
-                </div>
-                """, unsafe_allow_html=True)
-
-                st.image(product_info["image_path"], use_container_width=True)
-
-                with st.expander("View Details"):
-                    st.subheader(product_name)
-                    st.write(f"**Price:** {product_info['price']}")
-                    st.write(product_info["description"])
-
-                    # Add quantity selector in expander
-                    quantity = st.number_input(
-                        "Quantity:",
-                        min_value=1,
-                        value=1,
-                        step=1,
-                        key=f"quantity_{i + j}"
-                    )
-
-                    if st.button("🛒 Add to Cart", key=f"btn_{i + j}"):
-                        if 'cart' not in st.session_state:
-                            st.session_state.cart = []
-                        st.session_state.cart.append({
-                            "name": product_name,
-                            "price": product_info['price'],
-                            "quantity": quantity
-                        })
-                        st.success(f"Added {quantity} {product_name} to cart!")
+with st.container(border=True):
+    for i in range(0, total_products, num_columns):
+        cols = st.columns(num_columns)
+        for j in range(num_columns):
+            if i + j < total_products:
+                product_name = list(prints.keys())[i + j]
+                product_info = prints[product_name]
+                with cols[j]:
+                    with st.container(border=True):
+                        st.markdown(f"""
+                        <div class="product-card">
+                            <h3>{product_name}</h3>
+                            <p><b>{product_info['price']}</b></p>
+                        </div>
+                        """, unsafe_allow_html=True)
+                        st.image(product_info["image_path"],
+                                 use_container_width=True)
+
+                        with st.expander("View Details"):
+                            st.subheader(product_name)
+                            st.write(f"**Price:** {product_info['price']}")
+                            st.write(product_info["description"])
+
+                            quantity = st.number_input(
+                                "Quantity:", min_value=1, value=1, step=1, key=f"quantity_{i + j}")
+                            if st.button("🛒 Add to Cart", key=f"btn_{i + j}"):
+                                # Create a new cart entry with username, timestamp, and product details
+                                new_entry = {
+                                    "username": username,
+                                    "timestamp": datetime.now().isoformat(),
+                                    "product_name": product_name,
+                                    "price": product_info["price"],
+                                    "quantity": quantity
+                                }
+                                # Optionally, update session state for the current session cart
+                                if 'cart' not in st.session_state:
+                                    st.session_state.cart = []
+                                st.session_state.cart.append(new_entry)
+
+                                # Append the new entry to the persistent cart JSON file
+                                cart_data = load_cart_data()
+                                cart_data.append(new_entry)
+                                save_cart_data(cart_data)
+
+                                st.success(
+                                    f"Added {quantity} {product_name} to cart!")
+
+# Footer Section
+st.markdown("""
+<div class="footer-container">
+    <p>&copy; 2025 Charcuterie Boards Store. All rights reserved.</p>
+</div>
+""", unsafe_allow_html=True)

pages/config/cart_data.json

@@ -0,0 +1,30 @@
+[
+    {
+        "username": "testtt",
+        "timestamp": "2025-03-17T23:44:40.281767",
+        "product_name": "Psychedelic Poster 1",
+        "price": "$19.99",
+        "quantity": 2
+    },
+    {
+        "username": "testtt",
+        "timestamp": "2025-03-17T23:55:41.790624",
+        "product_name": "Psychedelic Cutting Board",
+        "price": "$29.99",
+        "quantity": 4
+    },
+    {
+        "username": "testtt",
+        "timestamp": "2025-03-17T23:55:41.790624",
+        "product_name": "Psychedelic Cutting Board",
+        "price": "$29.99",
+        "quantity": 5
+    },
+    {
+        "username": "testtt",
+        "timestamp": "2025-03-27T23:55:41.790624",
+        "product_name": "Psychedelic Cutting Board",
+        "price": "$29.99",
+        "quantity": 2
+    }
+]

pages/config/combined_items.yml

@@ -0,0 +1,29 @@
+items:
+  Charcuterie Board 1:
+    description: A mesmerizing psychedelic art print, perfect for your wall.
+    image_path: /home/vscode/Brads_Store/pages/config/images/cutting_boards/board1.png
+    price: $19.99
+  Psychedelic Art Coaster:
+    description: A psychedelic-themed coaster to add a trippy vibe to your drinks.
+    image_path: /home/vscode/project_assistant_dashboard/pages/config/images/download
+      (1).png
+    price: $9.99
+  Psychedelic Canvas:
+    description: A high-quality psychedelic canvas print for art lovers.
+    image_path: /home/vscode/project_assistant_dashboard/pages/config/images/image
+      (2).png
+    price: $49.99
+  Psychedelic Cutting Board:
+    description: The best money can buy!!!!
+    image_path: /home/vscode/Brads_Store/pages/config/images/cutting_boards/abstract1.png
+    price: $29.99
+  Psychedelic Poster 1:
+    description: A mesmerizing psychedelic art print, perfect for your wall.
+    image_path: /home/vscode/Brads_Store/pages/config/images/cutting_boards/image
+      (2).png
+    price: $19.99
+  Psychedelic Poster 2:
+    description: An intense, vibrant psychedelic poster to captivate any space.
+    image_path: /home/vscode/project_assistant_dashboard/pages/config/images/image
+      (1).png
+    price: $24.99

pages/config/images_config.yml

@@ -1,21 +1,25 @@
 items:
-  Psychedelic Cutting Board:
+  Classic Wood Charcuterie Board:
     image_path: "/home/vscode/project_assistant_dashboard/pages/config/images/download.png"
-    price: "$29.99"
-    description: "A stunning psychedelic cutting board to add a splash of color to your kitchen."
-  Psychedelic Poster 1:
+    price: "$34.99"
+    description: "A timeless wooden charcuterie board, perfect for serving cheeses and meats in style."
+
+  Elegant Marble Charcuterie Board:
     image_path: "/home/vscode/project_assistant_dashboard/pages/config/images/image.png"
-    price: "$19.99"
-    description: "A mesmerizing psychedelic art print, perfect for your wall."
-  Psychedelic Poster 2:
+    price: "$44.99"
+    description: "A luxurious marble charcuterie board designed for upscale presentations."
+
+  Modern Slate Charcuterie Board:
     image_path: "/home/vscode/project_assistant_dashboard/pages/config/images/image (1).png"
-    price: "$24.99"
-    description: "An intense, vibrant psychedelic poster to captivate any space."
-  Psychedelic Canvas:
+    price: "$39.99"
+    description: "A sleek and durable slate charcuterie board for a contemporary serving experience."
+
+  Rustic Acacia Charcuterie Board:
     image_path: "/home/vscode/project_assistant_dashboard/pages/config/images/image (2).png"
     price: "$49.99"
-    description: "A high-quality psychedelic canvas print for art lovers."
-  Psychedelic Art Coaster:
+    description: "A premium acacia wood charcuterie board with a natural rustic finish."
+
+  Compact Bamboo Charcuterie Board:
     image_path: "/home/vscode/project_assistant_dashboard/pages/config/images/download (1).png"
-    price: "$9.99"
-    description: "A psychedelic-themed coaster to add a trippy vibe to your drinks."
+    price: "$24.99"
+    description: "A lightweight and eco-friendly bamboo charcuterie board, ideal for small gatherings."

pages/config/images_config_cuttting_boards.yml

@@ -1,16 +1,15 @@
 items:
-  Psychedelic Cutting Board:
+  Artistic Abstract Charcuterie Board:
     image_path: "/home/vscode/Brads_Store/pages/config/images/cutting_boards/abstract1.png"
-    price: "$29.99"
-    description: "The best money can buy!!!!"
-  Psychedelic Poster 1:
-    image_path: "/home/vscode/Brads_Store/pages/config/images/cutting_boards/image (2).png"
-    price: "$19.99"
-    description: "A mesmerizing psychedelic art print, perfect for your wall."
-  Charcuterie Board 1:
-    image_path: "/home/vscode/Brads_Store/pages/config/images/cutting_boards/board1.png"
-    price: "$19.99"
-    description: "A mesmerizing psychedelic art print, perfect for your wall."
-
+    price: "$34.99"
+    description: "A beautifully designed charcuterie board with a unique abstract pattern."
 
+  Elegant Display Charcuterie Board:
+    image_path: "/home/vscode/Brads_Store/pages/config/images/cutting_boards/image (2).png"
+    price: "$24.99"
+    description: "A stylish and functional charcuterie board, ideal for serving snacks and appetizers."
 
+  Premium Hardwood Charcuterie Board:
+    image_path: "/home/vscode/Brads_Store/pages/config/images/cutting_boards/board1.png"
+    price: "$39.99"
+    description: "A durable hardwood charcuterie board with a smooth finish, perfect for hosting events."

pages/config/items/images_config_charcuterie_boards.yml

@@ -0,0 +1,25 @@
+items:
+  Classic Wood Charcuterie Board:
+    image_path: "/home/vscode/project_assistant_dashboard/pages/config/images/download.png"
+    price: "$34.99"
+    description: "A timeless wooden charcuterie board, perfect for serving cheeses and meats in style."
+
+  Elegant Marble Charcuterie Board:
+    image_path: "/home/vscode/project_assistant_dashboard/pages/config/images/image.png"
+    price: "$44.99"
+    description: "A luxurious marble charcuterie board designed for upscale presentations."
+
+  Modern Slate Charcuterie Board:
+    image_path: "/home/vscode/project_assistant_dashboard/pages/config/images/image (1).png"
+    price: "$39.99"
+    description: "A sleek and durable slate charcuterie board for a contemporary serving experience."
+
+  Rustic Acacia Charcuterie Board:
+    image_path: "/home/vscode/project_assistant_dashboard/pages/config/images/image (2).png"
+    price: "$49.99"
+    description: "A premium acacia wood charcuterie board with a natural rustic finish."
+
+  Compact Bamboo Charcuterie Board:
+    image_path: "/home/vscode/project_assistant_dashboard/pages/config/images/download (1).png"
+    price: "$24.99"
+    description: "A lightweight and eco-friendly bamboo charcuterie board, ideal for small gatherings."

pages/config/items/images_config_cuttting_boards.yml

@@ -0,0 +1,15 @@
+items:
+  Artistic Abstract Charcuterie Board:
+    image_path: "/home/vscode/Brads_Store/pages/config/images/cutting_boards/abstract1.png"
+    price: "$34.99"
+    description: "A beautifully designed charcuterie board with a unique abstract pattern."
+
+  Elegant Display Charcuterie Board:
+    image_path: "/home/vscode/Brads_Store/pages/config/images/cutting_boards/image (2).png"
+    price: "$24.99"
+    description: "A stylish and functional charcuterie board, ideal for serving snacks and appetizers."
+
+  Premium Hardwood Charcuterie Board:
+    image_path: "/home/vscode/Brads_Store/pages/config/images/cutting_boards/board1.png"
+    price: "$39.99"
+    description: "A durable hardwood charcuterie board with a smooth finish, perfect for hosting events."

pages/config/users.yml

@@ -0,0 +1,19 @@
+users:
+- password: admin123
+  role: admin
+  username: admin
+- password: userpass1
+  role: user
+  username: user1
+- password: userpass2
+  role: user
+  username: user2
+- password: test
+  role: user
+  username: test
+- password: test
+  role: user
+  username: testt
+- password: test
+  role: user
+  username: testtt

pages/config/wishlist_data.json

@@ -0,0 +1,30 @@
+[
+    {
+        "username": "testtt",
+        "timestamp": "2025-03-17T23:44:40.281767",
+        "product_name": "Psychedelic Poster 1",
+        "price": "$19.99",
+        "quantity": 2
+    },
+    {
+        "username": "testtt",
+        "timestamp": "2025-03-17T23:55:41.790624",
+        "product_name": "Psychedelic Cutting Board",
+        "price": "$29.99",
+        "quantity": 4
+    },
+    {
+        "username": "testtt",
+        "timestamp": "2025-03-17T23:55:41.790624",
+        "product_name": "Psychedelic Cutting Board",
+        "price": "$29.99",
+        "quantity": 5
+    },
+    {
+        "username": "testtt",
+        "timestamp": "2025-03-27T23:55:41.790624",
+        "product_name": "Psychedelic Cutting Board",
+        "price": "$29.99",
+        "quantity": 2
+    }
+]

pages/cutting_boards.py

@@ -0,0 +1,175 @@
+import streamlit as st
+import yaml
+import os
+import base64
+import json
+from datetime import datetime
+
+# Define file paths
+icon_path = "pages/config/images/icon2.png"
+css_path = "pages/styles/page_style1.css"
+yaml_file_path = "pages/config/items/images_config_cuttting_boards.yml"
+CART_FILE = "pages/config/cart_data.json"
+logged_user_file = "config/logged_in_user.yml"
+
+# Function to load an image as base64
+
+
+def load_image_as_base64(image_path):
+    with open(image_path, "rb") as img_file:
+        return base64.b64encode(img_file.read()).decode()
+
+
+# Load the icon image as base64
+icon_base64 = load_image_as_base64(icon_path)
+
+# Function to load CSS from file
+
+
+def load_css(file_path):
+    with open(file_path, "r") as f:
+        return f"<style>{f.read()}</style>"
+
+
+st.markdown(load_css(css_path), unsafe_allow_html=True)
+
+# Function to load the logged-in user from YAML
+
+
+def load_logged_in_user():
+    if os.path.exists(logged_user_file):
+        with open(logged_user_file, "r") as f:
+            data = yaml.safe_load(f)
+            return data.get("username", "guest")
+    return "guest"
+
+
+# Use the logged-in user automatically
+username = load_logged_in_user()
+
+# Functions to load and save cart data from/to JSON file
+
+
+def load_cart_data():
+    if os.path.exists(CART_FILE):
+        with open(CART_FILE, "r") as f:
+            try:
+                return json.load(f)
+            except json.JSONDecodeError:
+                return []
+    return []
+
+
+def save_cart_data(data):
+    with open(CART_FILE, "w") as f:
+        json.dump(data, f, indent=4)
+
+
+# Header Section with Icon and Title
+st.markdown(f"""
+    <style>
+        .title-container {{
+            display: flex;
+            align-items: center;
+            justify-content: center;
+            background-color: #444;
+            padding: 15px 30px;
+            border-radius: 15px;
+            box-shadow: 0px 4px 10px rgba(0, 0, 0, 0.1);
+            margin-bottom: 30px;
+            border: 2px solid #007BFF;
+        }}
+        .title-icon {{
+            width: 80px;
+            height: 80px;
+            background-image: url(data:image/png;base64,{icon_base64});
+            background-size: cover;
+        }}
+        .title-text {{
+            font-size: 2.5em;
+            font-weight: bold;
+            color: white;
+            margin: 0 40px; /* Adds space between the icons and text */
+            transition: color 0.3s ease;
+        }}
+        .title-container:hover .title-text {{
+            color: #007BFF;
+        }}
+    </style>
+    <div class="title-container">
+        <div class="title-icon"></div>
+        <div class="title-text">Charcuterie Boards: Elevate Your Presentation</div>
+        <div class="title-icon"></div>
+    </div>
+""", unsafe_allow_html=True)
+
+
+# Load product data from YAML file
+if not os.path.exists(yaml_file_path):
+    st.error("Configuration file not found!")
+    st.stop()
+
+with open(yaml_file_path, "r") as file:
+    product_data = yaml.safe_load(file)
+
+# Filter products (if 'category' equals "print", otherwise use all products)
+prints = {name: info for name, info in product_data["items"].items(
+) if info.get("category", "") == "print"} or product_data["items"]
+
+# Display products in a structured container
+total_products = len(prints)
+num_columns = 3
+
+with st.container(border=True):
+    for i in range(0, total_products, num_columns):
+        cols = st.columns(num_columns)
+        for j in range(num_columns):
+            if i + j < total_products:
+                product_name = list(prints.keys())[i + j]
+                product_info = prints[product_name]
+                with cols[j]:
+                    with st.container(border=True):
+                        st.markdown(f"""
+                        <div class="product-card">
+                            <h3>{product_name}</h3>
+                            <p><b>{product_info['price']}</b></p>
+                        </div>
+                        """, unsafe_allow_html=True)
+                        st.image(product_info["image_path"],
+                                 use_container_width=True)
+
+                        with st.expander("View Details"):
+                            st.subheader(product_name)
+                            st.write(f"**Price:** {product_info['price']}")
+                            st.write(product_info["description"])
+
+                            quantity = st.number_input(
+                                "Quantity:", min_value=1, value=1, step=1, key=f"quantity_{i + j}")
+                            if st.button("🛒 Add to Cart", key=f"btn_{i + j}"):
+                                # Create a new cart entry with username, timestamp, and product details
+                                new_entry = {
+                                    "username": username,
+                                    "timestamp": datetime.now().isoformat(),
+                                    "product_name": product_name,
+                                    "price": product_info["price"],
+                                    "quantity": quantity
+                                }
+                                # Optionally, update session state for the current session cart
+                                if 'cart' not in st.session_state:
+                                    st.session_state.cart = []
+                                st.session_state.cart.append(new_entry)
+
+                                # Append the new entry to the persistent cart JSON file
+                                cart_data = load_cart_data()
+                                cart_data.append(new_entry)
+                                save_cart_data(cart_data)
+
+                                st.success(
+                                    f"Added {quantity} {product_name} to cart!")
+
+# Footer Section
+st.markdown("""
+<div class="footer-container">
+    <p>&copy; 2025 Charcuterie Boards Store. All rights reserved.</p>
+</div>
+""", unsafe_allow_html=True)

pages/home.py

@@ -1,147 +1,58 @@
 import streamlit as st
+import json
 import yaml
-import os
 
-# Add custom CSS
-st.markdown("""
-<style>
-    .stButton button {
-        background-color: #1E90FF; /* Dodger Blue */
-        color: white;
-        border-radius: 8px;
-        padding: 10px 24px;
-        font-weight: bold;
-        border: none;
-    }
-    .stButton button:hover {
-        background-color: #007ACC; /* Darker blue on hover */
-    }
-    .product-card {
-        border: 1px solid #eee;
-        border-radius: 10px;
-        padding: 10px;
-        transition: transform 0.3s;
-    }
-    .product-card:hover {
-        transform: scale(1.02);
-        box-shadow: 0 4px 8px rgba(0,0,0,0.1);
-    }
-    .category-header {
-        text-align: center;
-        margin-bottom: 30px;
-        color: #333;
-    }
-    /* New styles for cart controls */
-    .cart-controls {
-        display: flex;
-        align-items: center;
-        justify-content: space-between;
-        margin-top: 10px;
-    }
-    .quantity-selector {
-        border-radius: 8px;
-        border: 1px solid #ddd;
-        padding: 5px;
-        width: 100%;
-    }
-    .add-to-cart-btn {
-        width: 100%;
-        margin-top: 10px;
-    }
-</style>
-""", unsafe_allow_html=True)
+# Load logged-in user data from YAML file
 
-# Main page header
-st.title("🌀 Psychedelic Art Gallery")
-st.markdown(
-    "### Explore our collection of trippy, vibrant artwork and accessories!"
-)
 
-# Load YAML file
-yaml_file_path = "/home/vscode/project_assistant_dashboard/pages/config/images_config.yml"
-if not os.path.exists(yaml_file_path):
-    st.error("Configuration file not found!")
-    st.stop()
+def load_logged_in_user():
+    user_file = "/home/vscode/Brads_Store/config/logged_in_user.yml"
+    try:
+        with open(user_file, "r") as file:
+            user_data = yaml.safe_load(file)
+            return user_data.get("username", "")
+    except FileNotFoundError:
+        return ""
 
-with open(yaml_file_path, "r") as file:
-    product_data = yaml.safe_load(file)
+# Load cart data from JSON file, filtered by logged-in user
 
-# Initialize cart in session state if it doesn't exist
-if 'cart' not in st.session_state:
-    st.session_state.cart = []
-
-# Function to display featured products
-
-
-def display_featured_products():
-    cols = st.columns(3)
-
-    # Get first 6 products for featured display
-    featured_items = {}
-    count = 0
-
-    for product_name, product_info in product_data["items"].items():
-        if count < 6:
-            featured_items[product_name] = product_info
-            count += 1
-
-    for i, (product_name, product_info) in enumerate(featured_items.items()):
-        with cols[i % 3]:  # Distribute products evenly across columns
-            st.markdown(f"""
-            <div class="product-card">
-                <h3>{product_name}</h3>
-                <p><b>{product_info['price']}</b></p>
-            </div>
-            """, unsafe_allow_html=True)
 
-            st.image(product_info["image_path"], use_container_width=True)
+def load_cart_data(username):
+    cart_file = "/home/vscode/Brads_Store/pages/config/cart_data.json"
+    try:
+        with open(cart_file, "r") as file:
+            cart_data = json.load(file)
+            return [item for item in cart_data if item.get("username") == username]
+    except FileNotFoundError:
+        return []
 
-            with st.expander("View Details & Add to Cart"):
-                st.subheader(product_name)
-                st.write(f"**Price:** {product_info['price']}")
-                st.write(product_info["description"])
+# Get logged-in user
+logged_in_user = load_logged_in_user()
 
-                # Create two columns for quantity and add button
-                qty_col, btn_col = st.columns([1, 1])
+# Display logged-in user
+st.sidebar.subheader(f"Logged in as: {logged_in_user}")
 
-                with qty_col:
-                    quantity = st.number_input(
-                        "Quantity",
-                        min_value=1,
-                        value=1,
-                        step=1,
-                        key=f"quantity_{i}",
-                        label_visibility="collapsed"
-                    )
-
-                with btn_col:
-                    if st.button("Add to Cart", key=f"btn_{i}"):
-                        st.session_state.cart.append({
-                            "name": product_name,
-                            "price": product_info['price'],
-                            "quantity": quantity
-                        })
-                        st.toast(f"Added {quantity} {product_name} to cart!")
-                        st.rerun()
-
-
-# Display featured products
-st.markdown("<h2 class='category-header'>🔥 Featured Collection</h2>",
-            unsafe_allow_html=True)
-display_featured_products()
-
-# Category quick links
-st.markdown("## Explore Categories")
-col1, col2, col3 = st.columns(3)
-
-with col1:
-    st.page_link("pages/prints.py", label="Prints Collection", icon="🖼️")
-with col2:
-    st.page_link("pages/clothing.py", label="Clothing Collection", icon="👕")
-with col3:
-    st.page_link("pages/accessories.py",
-                 label="Accessories Collection", icon="🧢")
-
-# Footer
-st.markdown("---")
-st.markdown("© 2025 Psychedelic Art Gallery. All rights reserved.")
+# Initialize session state variables
+if 'cart' not in st.session_state:
+    st.session_state.cart = load_cart_data(logged_in_user)
+
+st.title("Shopping Cart Test Page")
+
+# Display Cart Items
+st.subheader("Your Cart Items")
+if not st.session_state.cart:
+    st.write("Your cart is empty.")
+else:
+    for i, item in enumerate(st.session_state.cart):
+        st.write(
+            f"{item['product_name']} - {item['price']} x {item.get('quantity', 1)}")
+
+# Refresh Cart Data Button
+if st.button("Reload Cart Data"):
+    st.session_state.cart = load_cart_data(logged_in_user)
+    st.rerun()
+
+# Total Calculation
+total = sum(float(item["price"].replace("$", "")) *
+            item.get("quantity", 1) for item in st.session_state.cart)
+st.subheader(f"Total: ${total:.2f}")

pages/login_page.py

@@ -0,0 +1,122 @@
+import streamlit as st
+import yaml
+import hashlib
+import os
+
+# File paths
+USERS_FILE = "/home/vscode/Brads_Store/pages/config/users.yml"
+LOGGED_IN_FILE = "/home/vscode/Brads_Store/config/logged_in_user.yml"
+
+# Load users from YAML file
+
+
+def load_users():
+    with open(USERS_FILE, "r") as file:
+        return yaml.safe_load(file)["users"]
+
+# Save users to YAML file
+
+
+def save_users(users):
+    with open(USERS_FILE, "w") as file:
+        yaml.dump({"users": users}, file)
+
+# Save logged in user
+
+
+def save_logged_in_user(username, role):
+    # Create directory if it doesn't exist
+    os.makedirs(os.path.dirname(LOGGED_IN_FILE), exist_ok=True)
+    with open(LOGGED_IN_FILE, "w") as file:
+        yaml.dump({"username": username, "role": role}, file)
+
+# Hash function for passwords
+
+
+def hash_password(password):
+    return hashlib.sha256(password.encode()).hexdigest()
+
+# Authenticate user
+
+
+def authenticate(username, password):
+    users = load_users()
+    for user in users:
+        if user["username"] == username and user["password"] == password:
+            return user["role"]
+    return None
+
+# Add new user
+
+
+def add_user(username, password, role):
+    users = load_users()
+    if any(user["username"] == username for user in users):
+        return False  # Username already exists
+    users.append({"username": username, "password": password, "role": role})
+    save_users(users)
+    return True
+
+
+# Streamlit UI
+st.title("Login Page")
+username = st.text_input("Username")
+password = st.text_input("Password", type="password")
+
+if st.button("Login"):
+    role = authenticate(username, password)
+    if role:
+        save_logged_in_user(username, role)
+        st.success(f"Welcome, {username}! Role: {role}")
+        st.session_state.logged_in = True
+        st.session_state.username = username
+        st.session_state.role = role
+    else:
+        st.error("Invalid username or password")
+
+# Add New User section in a popover
+with st.popover("Add New User"):
+    new_username = st.text_input("New Username")
+    new_password = st.text_input("New Password", type="password")
+    confirm_password = st.text_input("Confirm Password", type="password")
+    new_role = st.selectbox("Role", ["user", "admin"])
+
+    # Check if passwords match
+    passwords_match = new_password == confirm_password
+
+    # Show match status if both fields have input
+    if new_password and confirm_password:
+        if passwords_match:
+            st.success("Passwords match!")
+        else:
+            st.warning("Sorry, the passwords didn't match")
+
+    if st.button("Add User"):
+        if not new_username or not new_password:
+            st.error("Username and password are required")
+        elif not passwords_match:
+            st.error("Passwords do not match. Please try again.")
+        elif add_user(new_username, new_password, new_role):
+            # Log in the new user automatically
+            save_logged_in_user(new_username, new_role)
+            st.success(
+                f"User added successfully! You are now logged in as {new_username}")
+            st.session_state.logged_in = True
+            st.session_state.username = new_username
+            st.session_state.role = new_role
+            st.rerun()  # Rerun the app to update the UI
+        else:
+            st.error("Username already exists. Please choose a different one.")
+
+# Display logged in status if in session state
+if st.session_state.get('logged_in'):
+    st.sidebar.success(f"Logged in as: {st.session_state.username}")
+    if st.sidebar.button("Log out"):
+        # Clear the logged in user file
+        if os.path.exists(LOGGED_IN_FILE):
+            os.remove(LOGGED_IN_FILE)
+        # Clear session state
+        st.session_state.logged_in = False
+        st.session_state.pop('username', None)
+        st.session_state.pop('role', None)
+        st.rerun()

pages/prints.py

@@ -1,62 +0,0 @@
-import streamlit as st
-import yaml
-import os
-
-# Page header
-st.title("🖼️ Prints Collection")
-st.markdown("### Vibrant psychedelic prints for your walls")
-
-# Load YAML file
-yaml_file_path = "/home/vscode/Brads_Store/pages/config/images_config_cuttting_boards.yml"
-if not os.path.exists(yaml_file_path):
-    st.error("Configuration file not found!")
-    st.stop()
-
-with open(yaml_file_path, "r") as file:
-    product_data = yaml.safe_load(file)
-
-# Filter for prints only (assuming you have a category field in your YAML)
-prints = {}
-for product_name, product_info in product_data["items"].items():
-    if product_info.get("category", "") == "print":
-        prints[product_name] = product_info
-
-# If no prints found, show all products
-if not prints:
-    prints = product_data["items"]
-
-# Display prints
-cols = st.columns(3)
-for i, (product_name, product_info) in enumerate(prints.items()):
-    with cols[i % 3]:
-        st.markdown(f"""
-        <div class="product-card">
-            <h3>{product_name}</h3>
-            <p><b>{product_info['price']}</b></p>
-        </div>
-        """, unsafe_allow_html=True)
-
-        st.image(product_info["image_path"], use_container_width=True)
-
-        with st.popover("View Details"):
-            st.subheader(product_name)
-            st.write(f"**Price:** {product_info['price']}")
-            st.write(product_info["description"])
-
-            # Add quantity selector in popover
-            quantity = st.number_input(
-                "Quantity:",
-                min_value=1,
-                value=1,
-                step=1,
-                key=f"quantity_{i}"
-            )
-
-            if st.button("🛒 Add to Cart", key=f"btn_{i}"):
-                st.session_state.cart.append({
-                    "name": product_name,
-                    "price": product_info['price'],
-                    "quantity": quantity
-                })
-                st.toast(f"Added {quantity} {product_name} to cart!")
-                st.rerun()

pages/styles/page_style1.css

@@ -0,0 +1,72 @@
+/* styles.css */
+.title-container {
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    background-color: #444;
+    padding: 10px 20px;
+    border-radius: 15px;
+    transition: background-color 0.3s ease, transform 0.3s ease;
+    box-shadow: 0px 4px 10px rgba(0, 0, 0, 0.1);
+    margin-bottom: 30px;
+    border: 2px solid #007BFF;
+}
+
+.title-icon {
+    width: 80px;
+    height: 80px;
+    background-size: cover;
+    margin: 0 15px;
+    transition: transform 0.5s ease;
+    background-image: url(data:image/png;base64, /* your base64 encoded image here */);
+}
+
+.title-container:hover .title-icon {
+    transform: rotate(360deg);
+}
+
+.title-text {
+    font-size: 2.5em;
+    font-weight: bold;
+    color: white;
+    transition: color 0.3s ease;
+}
+
+.title-container:hover .title-text {
+    color: #007BFF;
+}
+
+.product-card {
+    text-align: center;
+    margin-bottom: 20px;
+    padding: 15px;
+    border: 2px solid #007BFF;
+    border-radius: 10px;
+    background-color: #444;
+    color: white;
+}
+
+.product-card h3 {
+    background-color: #444;
+    color: white;
+    padding: 10px;
+    border-radius: 5px;
+}
+
+.product-card p {
+    background-color: #444;
+    color: white;
+    padding: 5px;
+    border-radius: 5px;
+    display: inline-block;
+    font-weight: bold;
+}
+
+.footer-container {
+    text-align: center;
+    padding: 20px;
+    background-color: #222;
+    color: white;
+    border-top: 2px solid #007BFF;
+    margin-top: 30px;
+}

prompts/customer_service_prompt.txt

@@ -0,0 +1,28 @@
+You are an AI-powered customer service assistant for a website. Your primary role is to assist users by answering their questions, providing relevant information, and helping them navigate the website. You should always be professional, polite, and helpful.
+
+How to Use Information:
+You will be provided with a separate reference document containing detailed information about the website, its products, services, policies, and other relevant topics. Use this reference information to generate responses when applicable. Do not disclose the full contents of the reference document unless explicitly asked. Instead, summarize or provide answers based on the user’s question.
+
+Response Guidelines:
+
+Prioritize User Input – The user’s message is the most important factor in generating responses.
+Be Concise but Informative – Provide clear and accurate answers without overwhelming the user with unnecessary details.
+Use a Friendly and Professional Tone – Responses should be courteous and engaging.
+Acknowledge Limitations – If you do not have information, politely guide the user to customer support or relevant resources.
+Adapt to the User's Needs – Adjust responses based on the user’s tone and question complexity.
+Example Scenarios:
+
+If a user asks about a product, refer to the product details in the reference document.
+If a user has a technical issue, guide them through troubleshooting steps.
+If a user inquires about company policies, summarize key points from the reference document.
+If the user asks for something beyond your knowledge, suggest alternative support channels.
+Example User Interactions:
+
+User: “What is your return policy?”
+AI: “Our return policy allows returns within 30 days of purchase. Items must be in their original condition. Would you like me to provide more details or help with a return request?”
+
+User: “Tell me about [Product X].”
+AI: “Certainly! [Product X] is designed for [feature overview]. It includes [key features] and is available for [pricing]. Would you like to know about shipping options?”
+
+User: “Can I speak to a human representative?”
+AI: “Of course! You can reach our customer support team at [contact info] or via live chat. Is there anything I can assist you with in the meantime?”

search_results.txt

@@ -1,27 +1 @@
-Search Query: training an image classification model
-==================================================
-Result 1: Create_a_dataset_for_training.txt
-Similarity Score: 0.3584
-Full Content:
-Create a dataset for training Hugging Face Models Datasets Spaces Posts Docs Enterprise Pricing Log In Sign Up Diffusers documentation Create a dataset for training Diffusers 🏡 View all docs AWS Trainium & Inferentia Accelerate Amazon SageMaker Argilla AutoTrain Bitsandbytes Chat UI Competitions Dataset viewer Datasets Diffusers Distilabel Evaluate Google Cloud Google TPUs Gradio Hub Hub Python Library Hugging Face Generative AI Services (HUGS) Huggingface.js Inference API (serverless) Inference Endpoints (dedicated) Leaderboards Lighteval Optimum PEFT Safetensors Sentence Transformers TRL Tasks Text Embeddings Inference Text Generation Inference Tokenizers Transformers Transformers.js smolagents timm Search documentation main v0.32.2 v0.31.0 v0.30.3 v0.29.2 v0.28.2 v0.27.2 v0.26.3 v0.25.1 v0.24.0 v0.23.1 v0.22.3 v0.21.0 v0.20.0 v0.19.3 v0.18.2 v0.17.1 v0.16.0 v0.15.0 v0.14.0 v0.13.0 v0.12.0 v0.11.0 v0.10.2 v0.9.0 v0.8.0 v0.7.0 v0.6.0 v0.5.1 v0.4.1 v0.3.0 v0.2.4 EN JA KO PT ZH Get started 🧨 Diffusers Quicktour Effective and efficient diffusion Installation Tutorials Overview Understanding pipelines, models and schedulers AutoPipeline Train a diffusion model Load LoRAs for inference Accelerate inference of text-to-image diffusion models Working with big models Load pipelines and adapters Load pipelines Load community pipelines and components Load schedulers and models Model files and layouts Load adapters Push files to the Hub Generative tasks Unconditional image generation Text-to-image Image-to-image Inpainting Text or image-to-video Depth-to-image Inference techniques Overview Create a server Distributed inference Merge LoRAs Scheduler features Pipeline callbacks Reproducible pipelines Controlling image quality Prompt techniques Advanced inference Outpainting Specific pipeline examples CogVideoX Stable Diffusion XL SDXL Turbo Kandinsky IP-Adapter PAG ControlNet T2I-Adapter Latent Consistency Model Textual inversion Shap-E DiffEdit Trajectory Consistency Distillation-LoRA Stable Video Diffusion Marigold Computer Vision Training Overview Create a dataset for training Adapt a model to a new task Models Methods Quantization Methods Getting Started bitsandbytes gguf torchao Accelerate inference and reduce memory Speed up inference Reduce memory usage PyTorch 2.0 xFormers Token merging DeepCache TGATE xDiT Optimized model formats JAX/Flax ONNX OpenVINO Core ML Optimized hardware Metal Performance Shaders (MPS) Habana Gaudi AWS Neuron Conceptual Guides Philosophy Controlled generation How to contribute? Diffusers' Ethical Guidelines Evaluating Diffusion Models Community Projects Projects built with Diffusers API Main Classes Loaders Models Pipelines Schedulers Internal classes Join the Hugging Face community and get access to the augmented documentation experience Collaborate on models, datasets and Spaces Faster examples with accelerated inference Switch between documentation themes Sign Up to get started Create a dataset for training There are many datasets on the Hub to train a model on, but if you can’t find one you’re interested in or want to use your own, you can create a dataset with the 🤗 Datasets library. The dataset structure depends on the task you want to train your model on. The most basic dataset structure is a directory of images for tasks like unconditional image generation. Another dataset structure may be a directory of images and a text file containing their corresponding text captions for tasks like text-to-image generation. This guide will show you two ways to create a dataset to finetune on: provide a folder of images to the --train_data_dir argument upload a dataset to the Hub and pass the dataset repository id to the --dataset_name argument 💡 Learn more about how to create an image dataset for training in the Create an image dataset guide. Provide a dataset as a folder For unconditional generation, you can provide your own dataset as a folder of images. The training script uses the ImageFolder builder from 🤗 Datasets to automatically build a dataset from the folder. Your directory structure should look like: Copied data_dir/xxx.png data_dir/xxy.png data_dir/[...]/xxz.png Pass the path to the dataset directory to the --train_data_dir argument, and then you can start training: Copied accelerate launch train_unconditional.py \ --train_data_dir <path-to-train-directory> \ <other-arguments> Upload your data to the Hub 💡 For more details and context about creating and uploading a dataset to the Hub, take a look at the Image search with 🤗 Datasets post. Start by creating a dataset with the ImageFolder feature, which creates an image column containing the PIL-encoded images. You can use the data_dir or data_files parameters to specify the location of the dataset. The data_files parameter supports mapping specific files to dataset splits like train or test : Copied from datasets import load_dataset # example 1: local folder dataset = load_dataset( "imagefolder" , data_dir= "path_to_your_folder" ) # example 2: local files (supported formats are tar, gzip, zip, xz, rar, zstd) dataset = load_dataset( "imagefolder" , data_files= "path_to_zip_file" ) # example 3: remote files (supported formats are tar, gzip, zip, xz, rar, zstd) dataset = load_dataset( "imagefolder" , data_files= "https://download.microsoft.com/download/3/E/1/3E1C3F21-ECDB-4869-8368-6DEBA77B919F/kagglecatsanddogs_3367a.zip" , ) # example 4: providing several splits dataset = load_dataset( "imagefolder" , data_files={ "train" : [ "path/to/file1" , "path/to/file2" ], "test" : [ "path/to/file3" , "path/to/file4" ]} ) Then use the push_to_hub method to upload the dataset to the Hub: Copied # assuming you have ran the huggingface-cli login command in a terminal dataset.push_to_hub( "name_of_your_dataset" ) # if you want to push to a private repo, simply pass private=True: dataset.push_to_hub( "name_of_your_dataset" , private= True ) Now the dataset is available for training by passing the dataset name to the --dataset_name argument: Copied accelerate launch --mixed_precision= "fp16" train_text_to_image.py \ --pretrained_model_name_or_path= "stable-diffusion-v1-5/stable-diffusion-v1-5" \ --dataset_name= "name_of_your_dataset" \ <other-arguments> Next steps Now that you’ve created a dataset, you can plug it into the train_data_dir (if your dataset is local) or dataset_name (if your dataset is on the Hub) arguments of a training script. For your next steps, feel free to try and use your dataset to train a model for unconditional generation or text-to-image generation ! < > Update on GitHub ← Overview Adapt a model to a new task → Create a dataset for training Provide a dataset as a folder Upload your data to the Hub Next steps
---------------------------------------------------
-Result 2: Image_Classification.txt
-Similarity Score: 0.3516
-Full Content:
-Image classification Hugging Face Models Datasets Spaces Posts Docs Enterprise Pricing Log In Sign Up Datasets documentation Image classification Datasets 🏡 View all docs AWS Trainium & Inferentia Accelerate Amazon SageMaker Argilla AutoTrain Bitsandbytes Chat UI Competitions Dataset viewer Datasets Diffusers Distilabel Evaluate Google Cloud Google TPUs Gradio Hub Hub Python Library Hugging Face Generative AI Services (HUGS) Huggingface.js Inference API (serverless) Inference Endpoints (dedicated) Leaderboards Lighteval Optimum PEFT Safetensors Sentence Transformers TRL Tasks Text Embeddings Inference Text Generation Inference Tokenizers Transformers Transformers.js smolagents timm Search documentation main v3.2.0 v3.1.0 v3.0.2 v2.21.0 v2.20.0 v2.19.0 v2.18.0 v2.17.1 v2.16.1 v2.15.0 v2.14.7 v2.13.2 v2.12.0 v2.11.0 v2.10.0 v2.9.0 v2.8.0 v2.7.1 v2.6.2 v2.5.2 v2.4.0 v2.3.2 v2.2.1 v2.1.0 v2.0.0 v1.18.3 v1.17.0 v1.16.1 v1.15.1 v1.14.0 v1.13.3 v1.12.1 v1.11.0 v1.10.2 v1.9.0 v1.8.0 v1.7.0 v1.6.2 v1.5.0 v1.4.1 v1.3.0 v1.2.1 v1.1.3 v1.0.2 v0.4.0 v0.3.0 EN Get started 🤗 Datasets Quickstart Installation Tutorials Overview Load a dataset from the Hub Know your dataset Preprocess Create a dataset Share a dataset to the Hub How-to guides Overview General usage Load Process Stream Use with TensorFlow Use with PyTorch Use with JAX Use with Spark Cache management Cloud storage Search index CLI Troubleshooting Audio Load audio data Process audio data Create an audio dataset Vision Load image data Process image data Create an image dataset Depth estimation Image classification Semantic segmentation Object detection Load video data Create a video dataset Text Load text data Process text data Tabular Load tabular data Dataset repository Share Create a dataset card Structure your repository Create a dataset loading script Conceptual guides Datasets 🤝 Arrow The cache Dataset or IterableDataset Dataset features Build and load Batch mapping Reference Main classes Builder classes Loading methods Table Classes Utilities Join the Hugging Face community and get access to the augmented documentation experience Collaborate on models, datasets and Spaces Faster examples with accelerated inference Switch between documentation themes Sign Up to get started Image classification Image classification datasets are used to train a model to classify an entire image. There are a wide variety of applications enabled by these datasets such as identifying endangered wildlife species or screening for disease in medical images. This guide will show you how to apply transformations to an image classification dataset. Before you start, make sure you have up-to-date versions of albumentations and cv2 installed: Copied pip install -U albumentations opencv-python This guide uses the Beans dataset for identifying the type of bean plant disease based on an image of its leaf. Load the dataset and take a look at an example: Copied >>> from datasets import load_dataset >>> dataset = load_dataset( "beans" ) >>> dataset[ "train" ][ 10 ] { 'image' : <PIL.JpegImagePlugin.JpegImageFile image mode=RGB size=500x500 at 0x7F8D2F4D7A10 >, 'image_file_path' : '/root/.cache/huggingface/datasets/downloads/extracted/b0a21163f78769a2cf11f58dfc767fb458fc7cea5c05dccc0144a2c0f0bc1292/train/angular_leaf_spot/angular_leaf_spot_train.204.jpg' , 'labels' : 0 } The dataset has three fields: image : a PIL image object. image_file_path : the path to the image file. labels : the label or category of the image. Next, check out an image: Now apply some augmentations with albumentations . You’ll randomly crop the image, flip it horizontally, and adjust its brightness. Copied >>> import cv2 >>> import albumentations >>> import numpy as np >>> transform = albumentations.Compose([ ... albumentations.RandomCrop(width= 256 , height= 256 ), ... albumentations.HorizontalFlip(p= 0.5 ), ... albumentations.RandomBrightnessContrast(p= 0.2 ), ... ]) Create a function to apply the transformation to the images: Copied >>> def transforms ( examples ): ... examples[ "pixel_values" ] = [ ... transform(image=np.array(image))[ "image" ] for image in examples[ "image" ] ... ] ... ... return examples Use the set_transform() function to apply the transformation on-the-fly to batches of the dataset to consume less disk space: Copied >>> dataset.set_transform(transforms) You can verify the transformation worked by indexing into the pixel_values of the first example: Copied >>> import numpy as np >>> import matplotlib.pyplot as plt >>> img = dataset[ "train" ][ 0 ][ "pixel_values" ] >>> plt.imshow(img) Now that you know how to process a dataset for image classification, learn how to train an image classification model and use it for inference. < > Update on GitHub ← Depth estimation Semantic segmentation → Image classification
---------------------------------------------------
-Result 3: Image-to-image.txt
-Similarity Score: 0.3497
-Full Content:
-Image-to-image Hugging Face Models Datasets Spaces Posts Docs Enterprise Pricing Log In Sign Up Diffusers documentation Image-to-image Diffusers 🏡 View all docs AWS Trainium & Inferentia Accelerate Amazon SageMaker Argilla AutoTrain Bitsandbytes Chat UI Competitions Dataset viewer Datasets Diffusers Distilabel Evaluate Google Cloud Google TPUs Gradio Hub Hub Python Library Hugging Face Generative AI Services (HUGS) Huggingface.js Inference API (serverless) Inference Endpoints (dedicated) Leaderboards Lighteval Optimum PEFT Safetensors Sentence Transformers TRL Tasks Text Embeddings Inference Text Generation Inference Tokenizers Transformers Transformers.js smolagents timm Search documentation main v0.32.2 v0.31.0 v0.30.3 v0.29.2 v0.28.2 v0.27.2 v0.26.3 v0.25.1 v0.24.0 v0.23.1 v0.22.3 v0.21.0 v0.20.0 v0.19.3 v0.18.2 v0.17.1 v0.16.0 v0.15.0 v0.14.0 v0.13.0 v0.12.0 v0.11.0 v0.10.2 v0.9.0 v0.8.0 v0.7.0 v0.6.0 v0.5.1 v0.4.1 v0.3.0 v0.2.4 EN JA KO PT ZH Get started 🧨 Diffusers Quicktour Effective and efficient diffusion Installation Tutorials Overview Understanding pipelines, models and schedulers AutoPipeline Train a diffusion model Load LoRAs for inference Accelerate inference of text-to-image diffusion models Working with big models Load pipelines and adapters Load pipelines Load community pipelines and components Load schedulers and models Model files and layouts Load adapters Push files to the Hub Generative tasks Unconditional image generation Text-to-image Image-to-image Inpainting Text or image-to-video Depth-to-image Inference techniques Overview Create a server Distributed inference Merge LoRAs Scheduler features Pipeline callbacks Reproducible pipelines Controlling image quality Prompt techniques Advanced inference Outpainting Specific pipeline examples CogVideoX Stable Diffusion XL SDXL Turbo Kandinsky IP-Adapter PAG ControlNet T2I-Adapter Latent Consistency Model Textual inversion Shap-E DiffEdit Trajectory Consistency Distillation-LoRA Stable Video Diffusion Marigold Computer Vision Training Overview Create a dataset for training Adapt a model to a new task Models Methods Quantization Methods Getting Started bitsandbytes gguf torchao Accelerate inference and reduce memory Speed up inference Reduce memory usage PyTorch 2.0 xFormers Token merging DeepCache TGATE xDiT Optimized model formats JAX/Flax ONNX OpenVINO Core ML Optimized hardware Metal Performance Shaders (MPS) Habana Gaudi AWS Neuron Conceptual Guides Philosophy Controlled generation How to contribute? Diffusers' Ethical Guidelines Evaluating Diffusion Models Community Projects Projects built with Diffusers API Main Classes Loaders Models Pipelines Schedulers Internal classes Join the Hugging Face community and get access to the augmented documentation experience Collaborate on models, datasets and Spaces Faster examples with accelerated inference Switch between documentation themes Sign Up to get started Image-to-image Image-to-image is similar to text-to-image , but in addition to a prompt, you can also pass an initial image as a starting point for the diffusion process. The initial image is encoded to latent space and noise is added to it. Then the latent diffusion model takes a prompt and the noisy latent image, predicts the added noise, and removes the predicted noise from the initial latent image to get the new latent image. Lastly, a decoder decodes the new latent image back into an image. With 🤗 Diffusers, this is as easy as 1-2-3: Load a checkpoint into the AutoPipelineForImage2Image class; this pipeline automatically handles loading the correct pipeline class  based on the checkpoint: Copied import torch from diffusers import AutoPipelineForImage2Image from diffusers.utils import load_image, make_image_grid pipeline = AutoPipelineForImage2Image.from_pretrained( "kandinsky-community/kandinsky-2-2-decoder" , torch_dtype=torch.float16, use_safetensors= True ) pipeline.enable_model_cpu_offload() # remove following line if xFormers is not installed or you have PyTorch 2.0 or higher installed pipeline.enable_xformers_memory_efficient_attention() You’ll notice throughout the guide, we use enable_model_cpu_offload() and enable_xformers_memory_efficient_attention() , to save memory and increase inference speed. If you’re using PyTorch 2.0, then you don’t need to call enable_xformers_memory_efficient_attention() on your pipeline because it’ll already be using PyTorch 2.0’s native scaled-dot product attention . Load an image to pass to the pipeline: Copied init_image = load_image( "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/cat.png" ) Pass a prompt and image to the pipeline to generate an image: Copied prompt = "cat wizard, gandalf, lord of the rings, detailed, fantasy, cute, adorable, Pixar, Disney, 8k" image = pipeline(prompt, image=init_image).images[ 0 ] make_image_grid([init_image, image], rows= 1 , cols= 2 ) initial image generated image Popular models The most popular image-to-image models are Stable Diffusion v1.5 , Stable Diffusion XL (SDXL) , and Kandinsky 2.2 . The results from the Stable Diffusion and Kandinsky models vary due to their architecture differences and training process; you can generally expect SDXL to produce higher quality images than Stable Diffusion v1.5. Let’s take a quick look at how to use each of these models and compare their results. Stable Diffusion v1.5 Stable Diffusion v1.5 is a latent diffusion model initialized from an earlier checkpoint, and further finetuned for 595K steps on 512x512 images. To use this pipeline for image-to-image, you’ll need to prepare an initial image to pass to the pipeline. Then you can pass a prompt and the image to the pipeline to generate a new image: Copied import torch from diffusers import AutoPipelineForImage2Image from diffusers.utils import make_image_grid, load_image pipeline = AutoPipelineForImage2Image.from_pretrained( "stable-diffusion-v1-5/stable-diffusion-v1-5" , torch_dtype=torch.float16, variant= "fp16" , use_safetensors= True ) pipeline.enable_model_cpu_offload() # remove following line if xFormers is not installed or you have PyTorch 2.0 or higher installed pipeline.enable_xformers_memory_efficient_attention() # prepare image url = "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/img2img-init.png" init_image = load_image(url) prompt = "Astronaut in a jungle, cold color palette, muted colors, detailed, 8k" # pass prompt and image to pipeline image = pipeline(prompt, image=init_image).images[ 0 ] make_image_grid([init_image, image], rows= 1 , cols= 2 ) initial image generated image Stable Diffusion XL (SDXL) SDXL is a more powerful version of the Stable Diffusion model. It uses a larger base model, and an additional refiner model to increase the quality of the base model’s output. Read the SDXL guide for a more detailed walkthrough of how to use this model, and other techniques it uses to produce high quality images. Copied import torch from diffusers import AutoPipelineForImage2Image from diffusers.utils import make_image_grid, load_image pipeline = AutoPipelineForImage2Image.from_pretrained( "stabilityai/stable-diffusion-xl-refiner-1.0" , torch_dtype=torch.float16, variant= "fp16" , use_safetensors= True ) pipeline.enable_model_cpu_offload() # remove following line if xFormers is not installed or you have PyTorch 2.0 or higher installed pipeline.enable_xformers_memory_efficient_attention() # prepare image url = "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/img2img-sdxl-init.png" init_image = load_image(url) prompt = "Astronaut in a jungle, cold color palette, muted colors, detailed, 8k" # pass prompt and image to pipeline image = pipeline(prompt, image=init_image, strength= 0.5 ).images[ 0 ] make_image_grid([init_image, image], rows= 1 , cols= 2 ) initial image generated image Kandinsky 2.2 The Kandinsky model is different from the Stable Diffusion models because it uses an image prior model to create image embeddings. The embeddings help create a better alignment between text and images, allowing the latent diffusion model to generate better images. The simplest way to use Kandinsky 2.2 is: Copied import torch from diffusers import AutoPipelineForImage2Image from diffusers.utils import make_image_grid, load_image pipeline = AutoPipelineForImage2Image.from_pretrained( "kandinsky-community/kandinsky-2-2-decoder" , torch_dtype=torch.float16, use_safetensors= True ) pipeline.enable_model_cpu_offload() # remove following line if xFormers is not installed or you have PyTorch 2.0 or higher installed pipeline.enable_xformers_memory_efficient_attention() # prepare image url = "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/img2img-init.png" init_image = load_image(url) prompt = "Astronaut in a jungle, cold color palette, muted colors, detailed, 8k" # pass prompt and image to pipeline image = pipeline(prompt, image=init_image).images[ 0 ] make_image_grid([init_image, image], rows= 1 , cols= 2 ) initial image generated image Configure pipeline parameters There are several important parameters you can configure in the pipeline that’ll affect the image generation process and image quality. Let’s take a closer look at what these parameters do and how changing them affects the output. Strength strength is one of the most important parameters to consider and it’ll have a huge impact on your generated image. It determines how much the generated image resembles the initial image. In other words: 📈 a higher strength value gives the model more “creativity” to generate an image that’s different from the initial image; a strength value of 1.0 means the initial image is more or less ignored 📉 a lower strength value means the generated image is more similar to the initial image The strength and num_inference_steps parameters are related because strength determines the number of noise steps to add. For example, if the num_inference_steps is 50 and strength is 0.8, then this means adding 40 (50 * 0.8) steps of noise to the initial image and then denoising for 40 steps to get the newly generated image. Copied import torch from diffusers import AutoPipelineForImage2Image from diffusers.utils import make_image_grid, load_image pipeline = AutoPipelineForImage2Image.from_pretrained( "stable-diffusion-v1-5/stable-diffusion-v1-5" , torch_dtype=torch.float16, variant= "fp16" , use_safetensors= True ) pipeline.enable_model_cpu_offload() # remove following line if xFormers is not installed or you have PyTorch 2.0 or higher installed pipeline.enable_xformers_memory_efficient_attention() # prepare image url = "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/img2img-init.png" init_image = load_image(url) prompt = "Astronaut in a jungle, cold color palette, muted colors, detailed, 8k" # pass prompt and image to pipeline image = pipeline(prompt, image=init_image, strength= 0.8 ).images[ 0 ] make_image_grid([init_image, image], rows= 1 , cols= 2 ) strength = 0.4 strength = 0.6 strength = 1.0 Guidance scale The guidance_scale parameter is used to control how closely aligned the generated image and text prompt are. A higher guidance_scale value means your generated image is more aligned with the prompt, while a lower guidance_scale value means your generated image has more space to deviate from the prompt. You can combine guidance_scale with strength for even more precise control over how expressive the model is. For example, combine a high strength + guidance_scale for maximum creativity or use a combination of low strength and low guidance_scale to generate an image that resembles the initial image but is not as strictly bound to the prompt. Copied import torch from diffusers import AutoPipelineForImage2Image from diffusers.utils import make_image_grid, load_image pipeline = AutoPipelineForImage2Image.from_pretrained( "stable-diffusion-v1-5/stable-diffusion-v1-5" , torch_dtype=torch.float16, variant= "fp16" , use_safetensors= True ) pipeline.enable_model_cpu_offload() # remove following line if xFormers is not installed or you have PyTorch 2.0 or higher installed pipeline.enable_xformers_memory_efficient_attention() # prepare image url = "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/img2img-init.png" init_image = load_image(url) prompt = "Astronaut in a jungle, cold color palette, muted colors, detailed, 8k" # pass prompt and image to pipeline image = pipeline(prompt, image=init_image, guidance_scale= 8.0 ).images[ 0 ] make_image_grid([init_image, image], rows= 1 , cols= 2 ) guidance_scale = 0.1 guidance_scale = 5.0 guidance_scale = 10.0 Negative prompt A negative prompt conditions the model to not include things in an image, and it can be used to improve image quality or modify an image. For example, you can improve image quality by including negative prompts like “poor details” or “blurry” to encourage the model to generate a higher quality image. Or you can modify an image by specifying things to exclude from an image. Copied import torch from diffusers import AutoPipelineForImage2Image from diffusers.utils import make_image_grid, load_image pipeline = AutoPipelineForImage2Image.from_pretrained( "stabilityai/stable-diffusion-xl-refiner-1.0" , torch_dtype=torch.float16, variant= "fp16" , use_safetensors= True ) pipeline.enable_model_cpu_offload() # remove following line if xFormers is not installed or you have PyTorch 2.0 or higher installed pipeline.enable_xformers_memory_efficient_attention() # prepare image url = "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/img2img-init.png" init_image = load_image(url) prompt = "Astronaut in a jungle, cold color palette, muted colors, detailed, 8k" negative_prompt = "ugly, deformed, disfigured, poor details, bad anatomy" # pass prompt and image to pipeline image = pipeline(prompt, negative_prompt=negative_prompt, image=init_image).images[ 0 ] make_image_grid([init_image, image], rows= 1 , cols= 2 ) negative_prompt = "ugly, deformed, disfigured, poor details, bad anatomy" negative_prompt = "jungle" Chained image-to-image pipelines There are some other interesting ways you can use an image-to-image pipeline aside from just generating an image (although that is pretty cool too). You can take it a step further and chain it with other pipelines. Text-to-image-to-image Chaining a text-to-image and image-to-image pipeline allows you to generate an image from text and use the generated image as the initial image for the image-to-image pipeline. This is useful if you want to generate an image entirely from scratch. For example, let’s chain a Stable Diffusion and a Kandinsky model. Start by generating an image with the text-to-image pipeline: Copied from diffusers import AutoPipelineForText2Image, AutoPipelineForImage2Image import torch from diffusers.utils import make_image_grid pipeline = AutoPipelineForText2Image.from_pretrained( "stable-diffusion-v1-5/stable-diffusion-v1-5" , torch_dtype=torch.float16, variant= "fp16" , use_safetensors= True ) pipeline.enable_model_cpu_offload() # remove following line if xFormers is not installed or you have PyTorch 2.0 or higher installed pipeline.enable_xformers_memory_efficient_attention() text2image = pipeline( "Astronaut in a jungle, cold color palette, muted colors, detailed, 8k" ).images[ 0 ] text2image Now you can pass this generated image to the image-to-image pipeline: Copied pipeline = AutoPipelineForImage2Image.from_pretrained( "kandinsky-community/kandinsky-2-2-decoder" , torch_dtype=torch.float16, use_safetensors= True ) pipeline.enable_model_cpu_offload() # remove following line if xFormers is not installed or you have PyTorch 2.0 or higher installed pipeline.enable_xformers_memory_efficient_attention() image2image = pipeline( "Astronaut in a jungle, cold color palette, muted colors, detailed, 8k" , image=text2image).images[ 0 ] make_image_grid([text2image, image2image], rows= 1 , cols= 2 ) Image-to-image-to-image You can also chain multiple image-to-image pipelines together to create more interesting images. This can be useful for iteratively performing style transfer on an image, generating short GIFs, restoring color to an image, or restoring missing areas of an image. Start by generating an image: Copied import torch from diffusers import AutoPipelineForImage2Image from diffusers.utils import make_image_grid, load_image pipeline = AutoPipelineForImage2Image.from_pretrained( "stable-diffusion-v1-5/stable-diffusion-v1-5" , torch_dtype=torch.float16, variant= "fp16" , use_safetensors= True ) pipeline.enable_model_cpu_offload() # remove following line if xFormers is not installed or you have PyTorch 2.0 or higher installed pipeline.enable_xformers_memory_efficient_attention() # prepare image url = "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/img2img-init.png" init_image = load_image(url) prompt = "Astronaut in a jungle, cold color palette, muted colors, detailed, 8k" # pass prompt and image to pipeline image = pipeline(prompt, image=init_image, output_type= "latent" ).images[ 0 ] It is important to specify output_type="latent" in the pipeline to keep all the outputs in latent space to avoid an unnecessary decode-encode step. This only works if the chained pipelines are using the same VAE. Pass the latent output from this pipeline to the next pipeline to generate an image in a comic book art style : Copied pipeline = AutoPipelineForImage2Image.from_pretrained( "ogkalu/Comic-Diffusion" , torch_dtype=torch.float16 ) pipeline.enable_model_cpu_offload() # remove following line if xFormers is not installed or you have PyTorch 2.0 or higher installed pipeline.enable_xformers_memory_efficient_attention() # need to include the token "charliebo artstyle" in the prompt to use this checkpoint image = pipeline( "Astronaut in a jungle, charliebo artstyle" , image=image, output_type= "latent" ).images[ 0 ] Repeat one more time to generate the final image in a pixel art style : Copied pipeline = AutoPipelineForImage2Image.from_pretrained( "kohbanye/pixel-art-style" , torch_dtype=torch.float16 ) pipeline.enable_model_cpu_offload() # remove following line if xFormers is not installed or you have PyTorch 2.0 or higher installed pipeline.enable_xformers_memory_efficient_attention() # need to include the token "pixelartstyle" in the prompt to use this checkpoint image = pipeline( "Astronaut in a jungle, pixelartstyle" , image=image).images[ 0 ] make_image_grid([init_image, image], rows= 1 , cols= 2 ) Image-to-upscaler-to-super-resolution Another way you can chain your image-to-image pipeline is with an upscaler and super-resolution pipeline to really increase the level of details in an image. Start with an image-to-image pipeline: Copied import torch from diffusers import AutoPipelineForImage2Image from diffusers.utils import make_image_grid, load_image pipeline = AutoPipelineForImage2Image.from_pretrained( "stable-diffusion-v1-5/stable-diffusion-v1-5" , torch_dtype=torch.float16, variant= "fp16" , use_safetensors= True ) pipeline.enable_model_cpu_offload() # remove following line if xFormers is not installed or you have PyTorch 2.0 or higher installed pipeline.enable_xformers_memory_efficient_attention() # prepare image url = "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/img2img-init.png" init_image = load_image(url) prompt = "Astronaut in a jungle, cold color palette, muted colors, detailed, 8k" # pass prompt and image to pipeline image_1 = pipeline(prompt, image=init_image, output_type= "latent" ).images[ 0 ] It is important to specify output_type="latent" in the pipeline to keep all the outputs in latent space to avoid an unnecessary decode-encode step. This only works if the chained pipelines are using the same VAE. Chain it to an upscaler pipeline to increase the image resolution: Copied from diffusers import StableDiffusionLatentUpscalePipeline upscaler = StableDiffusionLatentUpscalePipeline.from_pretrained( "stabilityai/sd-x2-latent-upscaler" , torch_dtype=torch.float16, variant= "fp16" , use_safetensors= True ) upscaler.enable_model_cpu_offload() upscaler.enable_xformers_memory_efficient_attention() image_2 = upscaler(prompt, image=image_1, output_type= "latent" ).images[ 0 ] Finally, chain it to a super-resolution pipeline to further enhance the resolution: Copied from diffusers import StableDiffusionUpscalePipeline super_res = StableDiffusionUpscalePipeline.from_pretrained( "stabilityai/stable-diffusion-x4-upscaler" , torch_dtype=torch.float16, variant= "fp16" , use_safetensors= True ) super_res.enable_model_cpu_offload() super_res.enable_xformers_memory_efficient_attention() image_3 = super_res(prompt, image=image_2).images[ 0 ] make_image_grid([init_image, image_3.resize(( 512 , 512 ))], rows= 1 , cols= 2 ) Control image generation Trying to generate an image that looks exactly the way you want can be difficult, which is why controlled generation techniques and models are so useful. While you can use the negative_prompt to partially control image generation, there are more robust methods like prompt weighting and ControlNets. Prompt weighting Prompt weighting allows you to scale the representation of each concept in a prompt. For example, in a prompt like “Astronaut in a jungle, cold color palette, muted colors, detailed, 8k”, you can choose to increase or decrease the embeddings of “astronaut” and “jungle”. The Compel library provides a simple syntax for adjusting prompt weights and generating the embeddings. You can learn how to create the embeddings in the Prompt weighting guide. AutoPipelineForImage2Image has a prompt_embeds (and negative_prompt_embeds if you’re using a negative prompt) parameter where you can pass the embeddings which replaces the prompt parameter. Copied from diffusers import AutoPipelineForImage2Image import torch pipeline = AutoPipelineForImage2Image.from_pretrained( "stable-diffusion-v1-5/stable-diffusion-v1-5" , torch_dtype=torch.float16, variant= "fp16" , use_safetensors= True ) pipeline.enable_model_cpu_offload() # remove following line if xFormers is not installed or you have PyTorch 2.0 or higher installed pipeline.enable_xformers_memory_efficient_attention() image = pipeline(prompt_embeds=prompt_embeds, # generated from Compel negative_prompt_embeds=negative_prompt_embeds, # generated from Compel image=init_image, ).images[ 0 ] ControlNet ControlNets provide a more flexible and accurate way to control image generation because you can use an additional conditioning image. The conditioning image can be a canny image, depth map, image segmentation, and even scribbles! Whatever type of conditioning image you choose, the ControlNet generates an image that preserves the information in it. For example, let’s condition an image with a depth map to keep the spatial information in the image. Copied from diffusers.utils import load_image, make_image_grid # prepare image url = "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/img2img-init.png" init_image = load_image(url) init_image = init_image.resize(( 958 , 960 )) # resize to depth image dimensions depth_image = load_image( "https://huggingface.co/lllyasviel/control_v11f1p_sd15_depth/resolve/main/images/control.png" ) make_image_grid([init_image, depth_image], rows= 1 , cols= 2 ) Load a ControlNet model conditioned on depth maps and the AutoPipelineForImage2Image : Copied from diffusers import ControlNetModel, AutoPipelineForImage2Image import torch controlnet = ControlNetModel.from_pretrained( "lllyasviel/control_v11f1p_sd15_depth" , torch_dtype=torch.float16, variant= "fp16" , use_safetensors= True ) pipeline = AutoPipelineForImage2Image.from_pretrained( "stable-diffusion-v1-5/stable-diffusion-v1-5" , controlnet=controlnet, torch_dtype=torch.float16, variant= "fp16" , use_safetensors= True ) pipeline.enable_model_cpu_offload() # remove following line if xFormers is not installed or you have PyTorch 2.0 or higher installed pipeline.enable_xformers_memory_efficient_attention() Now generate a new image conditioned on the depth map, initial image, and prompt: Copied prompt = "Astronaut in a jungle, cold color palette, muted colors, detailed, 8k" image_control_net = pipeline(prompt, image=init_image, control_image=depth_image).images[ 0 ] make_image_grid([init_image, depth_image, image_control_net], rows= 1 , cols= 3 ) initial image depth image ControlNet image Let’s apply a new style to the image generated from the ControlNet by chaining it with an image-to-image pipeline: Copied pipeline = AutoPipelineForImage2Image.from_pretrained( "nitrosocke/elden-ring-diffusion" , torch_dtype=torch.float16, ) pipeline.enable_model_cpu_offload() # remove following line if xFormers is not installed or you have PyTorch 2.0 or higher installed pipeline.enable_xformers_memory_efficient_attention() prompt = "elden ring style astronaut in a jungle" # include the token "elden ring style" in the prompt negative_prompt = "ugly, deformed, disfigured, poor details, bad anatomy" image_elden_ring = pipeline(prompt, negative_prompt=negative_prompt, image=image_control_net, strength= 0.45 , guidance_scale= 10.5 ).images[ 0 ] make_image_grid([init_image, depth_image, image_control_net, image_elden_ring], rows= 2 , cols= 2 ) Optimize Running diffusion models is computationally expensive and intensive, but with a few optimization tricks, it is entirely possible to run them on consumer and free-tier GPUs. For example, you can use a more memory-efficient form of attention such as PyTorch 2.0’s scaled-dot product attention or xFormers (you can use one or the other, but there’s no need to use both). You can also offload the model to the GPU while the other pipeline components wait on the CPU. Copied + pipeline.enable_model_cpu_offload() + pipeline.enable_xformers_memory_efficient_attention() With torch.compile , you can boost your inference speed even more by wrapping your UNet with it: Copied pipeline.unet = torch. compile (pipeline.unet, mode= "reduce-overhead" , fullgraph= True ) To learn more, take a look at the Reduce memory usage and Torch 2.0 guides. < > Update on GitHub ← Text-to-image Inpainting → Image-to-image Popular models Stable Diffusion v1.5 Stable Diffusion X L (SDX L) Kandinsky 2.2 Configure pipeline parameters Strength Guidance scale Negative prompt Chained image-to-image pipelines Text-to-image-to-image Image-to-image-to-image Image-to-upscaler-to-super-resolution Control image generation Prompt weighting Control Net Optimize
---------------------------------------------------
-Result 4: Use_model_after_training.txt
-Similarity Score: 0.3477
-Full Content:
-Use model after training Hugging Face Models Datasets Spaces Posts Docs Enterprise Pricing Log In Sign Up TRL documentation Use model after training TRL 🏡 View all docs AWS Trainium & Inferentia Accelerate Amazon SageMaker Argilla AutoTrain Bitsandbytes Chat UI Competitions Dataset viewer Datasets Diffusers Distilabel Evaluate Google Cloud Google TPUs Gradio Hub Hub Python Library Hugging Face Generative AI Services (HUGS) Huggingface.js Inference API (serverless) Inference Endpoints (dedicated) Leaderboards Lighteval Optimum PEFT Safetensors Sentence Transformers TRL Tasks Text Embeddings Inference Text Generation Inference Tokenizers Transformers Transformers.js smolagents timm Search documentation main v0.13.0 v0.12.2 v0.11.4 v0.10.1 v0.9.6 v0.8.6 v0.7.11 v0.6.0 v0.5.0 v0.4.7 v0.3.1 v0.2.1 v0.1.1 EN Get started TRL Installation Quickstart Get started with Command Line Interfaces (CLIs) Dataset Formats PPO Training FAQ Use Trained Models Customize the Training Understanding Logs API Trainers AlignProp BCO CPO DDPO DPO Online DPO GKD KTO Nash-MD ORPO PPO PRM Reward RLOO SFT Iterative SFT XPO Model Classes Best of N Sampling Judges Callbacks Data Utilities Text Environments Script Utilities Examples Community Tutorials Example Overview Sentiment Tuning Training with PEFT Detoxifying a Language Model Training StackLlama Learning to Use Tools Multi Adapter RLHF Join the Hugging Face community and get access to the augmented documentation experience Collaborate on models, datasets and Spaces Faster examples with accelerated inference Switch between documentation themes Sign Up to get started Use model after training Once you have trained a model using either the SFTTrainer, PPOTrainer, or DPOTrainer, you will have a fine-tuned model that can be used for text generation. In this section, we’ll walk through the process of loading the fine-tuned model and generating text. If you need to run an inference server with the trained model, you can explore libraries such as text-generation-inference . Load and Generate If you have fine-tuned a model fully, meaning without the use of PEFT you can simply load it like any other language model in transformers. E.g. the value head that was trained during the PPO training is no longer needed and if you load the model with the original transformer class it will be ignored: Copied from transformers import AutoTokenizer, AutoModelForCausalLM model_name_or_path = "kashif/stack-llama-2" #path/to/your/model/or/name/on/hub device = "cpu" # or "cuda" if you have a GPU model = AutoModelForCausalLM.from_pretrained(model_name_or_path).to(device) tokenizer = AutoTokenizer.from_pretrained(model_name_or_path) inputs = tokenizer.encode( "This movie was really" , return_tensors= "pt" ).to(device) outputs = model.generate(inputs) print (tokenizer.decode(outputs[ 0 ])) Alternatively you can also use the pipeline: Copied from transformers import pipeline model_name_or_path = "kashif/stack-llama-2" #path/to/your/model/or/name/on/hub pipe = pipeline( "text-generation" , model=model_name_or_path) print (pipe( "This movie was really" )[ 0 ][ "generated_text" ]) Use Adapters PEFT Copied from peft import PeftConfig, PeftModel from transformers import AutoModelForCausalLM, AutoTokenizer base_model_name = "kashif/stack-llama-2" #path/to/your/model/or/name/on/hub" adapter_model_name = "path/to/my/adapter" model = AutoModelForCausalLM.from_pretrained(base_model_name) model = PeftModel.from_pretrained(model, adapter_model_name) tokenizer = AutoTokenizer.from_pretrained(base_model_name) You can also merge the adapters into the base model so you can use the model like a normal transformers model, however the checkpoint will be significantly bigger: Copied model = AutoModelForCausalLM.from_pretrained(base_model_name) model = PeftModel.from_pretrained(model, adapter_model_name) model = model.merge_and_unload() model.save_pretrained( "merged_adapters" ) Once you have the model loaded and either merged the adapters or keep them separately on top you can run generation as with a normal model outlined above. < > Update on GitHub ← PPO Training FAQ Customize the Training → Use model after training Load and Generate Use Adapters PEFT
---------------------------------------------------
-Result 5: Training_on_TPU_with_TensorFlow.txt
-Similarity Score: 0.3368
-Full Content:
-Training on TPU with TensorFlow Hugging Face Models Datasets Spaces Posts Docs Enterprise Pricing Log In Sign Up Transformers documentation Training on TPU with TensorFlow Transformers 🏡 View all docs AWS Trainium & Inferentia Accelerate Amazon SageMaker Argilla AutoTrain Bitsandbytes Chat UI Competitions Dataset viewer Datasets Diffusers Distilabel Evaluate Google Cloud Google TPUs Gradio Hub Hub Python Library Hugging Face Generative AI Services (HUGS) Huggingface.js Inference API (serverless) Inference Endpoints (dedicated) Leaderboards Lighteval Optimum PEFT Safetensors Sentence Transformers TRL Tasks Text Embeddings Inference Text Generation Inference Tokenizers Transformers Transformers.js smolagents timm Search documentation main v4.48.0 v4.47.1 v4.46.3 v4.45.2 v4.44.2 v4.43.4 v4.42.4 v4.41.2 v4.40.2 v4.39.3 v4.38.2 v4.37.2 v4.36.1 v4.35.2 v4.34.1 v4.33.3 v4.32.1 v4.31.0 v4.30.0 v4.29.1 v4.28.1 v4.27.2 v4.26.1 v4.25.1 v4.24.0 v4.23.1 v4.22.2 v4.21.3 v4.20.1 v4.19.4 v4.18.0 v4.17.0 v4.16.2 v4.15.0 v4.14.1 v4.13.0 v4.12.5 v4.11.3 v4.10.1 v4.9.2 v4.8.2 v4.7.0 v4.6.0 v4.5.1 v4.4.2 v4.3.3 v4.2.2 v4.1.1 v4.0.1 v3.5.1 v3.4.0 v3.3.1 v3.2.0 v3.1.0 v3.0.2 v2.11.0 v2.10.0 v2.9.1 v2.8.0 v2.7.0 v2.6.0 v2.5.1 v2.4.1 v2.3.0 v2.2.2 v2.1.1 v2.0.0 v1.2.0 v1.1.0 v1.0.0 doc-builder-html AR DE EN ES FR HI IT JA KO PT TE TR ZH Get started 🤗 Transformers Quick tour Installation Adding a new model to `transformers` Tutorials Run inference with pipelines Write portable code with AutoClass Preprocess data Fine-tune a pretrained model Train with a script Set up distributed training with 🤗 Accelerate Load and train adapters with 🤗 PEFT Share your model Agents 101 Agents, supercharged - Multi-agents, External tools, and more Generation with LLMs Chatting with Transformers Task Guides Natural Language Processing Audio Computer Vision Multimodal Generation Prompting Developer guides Use fast tokenizers from 🤗 Tokenizers Run inference with multilingual models Use model-specific APIs Share a custom model Chat templates Trainer Run training on Amazon SageMaker Export to ONNX Export to TFLite Export to TorchScript Benchmarks Notebooks with examples Community resources Troubleshoot Interoperability with GGUF files Interoperability with TikToken files Modularity in `transformers` Model Hacking (overwriting a class to your usage) Quantization Methods Getting started bitsandbytes GPTQ AWQ AQLM VPTQ Quanto EETQ HIGGS HQQ FBGEMM_FP8 Optimum TorchAO BitNet compressed-tensors Contribute new quantization method Performance and scalability Overview LLM inference optimization Efficient training techniques Methods and tools for efficient training on a single GPU Multiple GPUs and parallelism Fully Sharded Data Parallel DeepSpeed Efficient training on CPU Distributed CPU training Training on TPU with TensorFlow PyTorch training on Apple silicon Custom hardware for training Hyperparameter Search using Trainer API Optimizing inference CPU inference GPU inference Multi-GPU inference Instantiate a big model Debugging XLA Integration for TensorFlow Models Optimize inference using `torch.compile()` Contribute How to contribute to 🤗 Transformers? How to add a model to 🤗 Transformers? How to add a pipeline to 🤗 Transformers? Testing Checks on a Pull Request Conceptual guides Philosophy Glossary What 🤗 Transformers can do How 🤗 Transformers solve tasks The Transformer model family Summary of the tokenizers Attention mechanisms Padding and truncation BERTology Perplexity of fixed-length models Pipelines for webserver inference Model training anatomy Getting the most out of LLMs API Main Classes Agents and Tools Auto Classes Backbones Callbacks Configuration Data Collator Keras callbacks Logging Models Text Generation ONNX Optimization Model outputs Pipelines Processors Quantization Tokenizer Trainer DeepSpeed ExecuTorch Feature Extractor Image Processor Models Text models Vision models Audio models Video models Multimodal models Reinforcement learning models Time series models Graph models Internal Helpers Custom Layers and Utilities Utilities for pipelines Utilities for Tokenizers Utilities for Trainer Utilities for Generation Utilities for Image Processors Utilities for Audio processing General Utilities Utilities for Time Series Join the Hugging Face community and get access to the augmented documentation experience Collaborate on models, datasets and Spaces Faster examples with accelerated inference Switch between documentation themes Sign Up to get started Training on TPU with TensorFlow If you don’t need long explanations and just want TPU code samples to get started with, check out our TPU example notebook! What is a TPU? A TPU is a Tensor Processing Unit. They are hardware designed by Google, which are used to greatly speed up the tensor computations within neural networks, much like GPUs. They can be used for both network training and inference. They are generally accessed through Google’s cloud services, but small TPUs can also be accessed directly for free through Google Colab and Kaggle Kernels. Because all TensorFlow models in 🤗 Transformers are Keras models , most of the methods in this document are generally applicable to TPU training for any Keras model! However, there are a few points that are specific to the HuggingFace ecosystem (hug-o-system?) of Transformers and Datasets, and we’ll make sure to flag them up when we get to them. What kinds of TPU are available? New users are often very confused by the range of TPUs, and the different ways to access them. The first key distinction to understand is the difference between TPU Nodes and TPU VMs. When you use a TPU Node , you are effectively indirectly accessing a remote TPU. You will need a separate VM, which will initialize your network and data pipeline and then forward them to the remote node. When you use a TPU on Google Colab, you are accessing it in the TPU Node style. Using TPU Nodes can have some quite unexpected behaviour for people who aren’t used to them! In particular, because the TPU is located on a physically different system to the machine you’re running your Python code on, your data cannot be local to your machine - any data pipeline that loads from your machine’s internal storage will totally fail! Instead, data must be stored in Google Cloud Storage where your data pipeline can still access it, even when the pipeline is running on the remote TPU node. If you can fit all your data in memory as np.ndarray or tf.Tensor , then you can fit() on that data even when using Colab or a TPU Node, without needing to upload it to Google Cloud Storage. 🤗Specific Hugging Face Tip🤗: The methods Dataset.to_tf_dataset() and its higher-level wrapper model.prepare_tf_dataset() , which you will see throughout our TF code examples, will both fail on a TPU Node. The reason for this is that even though they create a tf.data.Dataset it is not a “pure” tf.data pipeline and uses tf.numpy_function or Dataset.from_generator() to stream data from the underlying HuggingFace Dataset . This HuggingFace Dataset is backed by data that is on a local disc and which the remote TPU Node will not be able to read. The second way to access a TPU is via a TPU VM. When using a TPU VM, you connect directly to the machine that the TPU is attached to, much like training on a GPU VM. TPU VMs are generally easier to work with, particularly when it comes to your data pipeline. All of the above warnings do not apply to TPU VMs! This is an opinionated document, so here’s our opinion: Avoid using TPU Node if possible. It is more confusing and more difficult to debug than TPU VMs. It is also likely to be unsupported in future - Google’s latest TPU, TPUv4, can only be accessed as a TPU VM, which suggests that TPU Nodes are increasingly going to become a “legacy” access method. However, we understand that the only free TPU access is on Colab and Kaggle Kernels, which uses TPU Node - so we’ll try to explain how to handle it if you have to! Check the TPU example notebook for code samples that explain this in more detail. What sizes of TPU are available? A single TPU (a v2-8/v3-8/v4-8) runs 8 replicas. TPUs exist in pods that can run hundreds or thousands of replicas simultaneously. When you use more than a single TPU but less than a whole pod (for example, a v3-32), your TPU fleet is referred to as a pod slice. When you access a free TPU via Colab, you generally get a single v2-8 TPU. I keep hearing about this XLA thing. What’s XLA, and how does it relate to TPUs? XLA is an optimizing compiler, used by both TensorFlow and JAX. In JAX it is the only compiler, whereas in TensorFlow it is optional (but mandatory on TPU!). The easiest way to enable it when training a Keras model is to pass the argument jit_compile=True to model.compile() . If you don’t get any errors and performance is good, that’s a great sign that you’re ready to move to TPU! Debugging on TPU is generally a bit harder than on CPU/GPU, so we recommend getting your code running on CPU/GPU with XLA first before trying it on TPU. You don’t have to train for long, of course - just for a few steps to make sure that your model and data pipeline are working like you expect them to. XLA compiled code is usually faster - so even if you’re not planning to run on TPU, adding jit_compile=True can improve your performance. Be sure to note the caveats below about XLA compatibility, though! Tip born of painful experience: Although using jit_compile=True is a good way to get a speed boost and test if your CPU/GPU code is XLA-compatible, it can actually cause a lot of problems if you leave it in when actually training on TPU. XLA compilation will happen implicitly on TPU, so remember to remove that line before actually running your code on a TPU! How do I make my model XLA compatible? In many cases, your code is probably XLA-compatible already! However, there are a few things that work in normal TensorFlow that don’t work in XLA. We’ve distilled them into three core rules below: 🤗Specific HuggingFace Tip🤗: We’ve put a lot of effort into rewriting our TensorFlow models and loss functions to be XLA-compatible. Our models and loss functions generally obey rule #1 and #2 by default, so you can skip over them if you’re using transformers models. Don’t forget about these rules when writing your own models and loss functions, though! XLA Rule #1: Your code cannot have “data-dependent conditionals” What that means is that any if statement cannot depend on values inside a tf.Tensor . For example, this code block cannot be compiled with XLA! Copied if tf.reduce_sum(tensor) > 10 : tensor = tensor / 2.0 This might seem very restrictive at first, but most neural net code doesn’t need to do this. You can often get around this restriction by using tf.cond (see the documentation here ) or by removing the conditional and finding a clever math trick with indicator variables instead, like so: Copied sum_over_10 = tf.cast(tf.reduce_sum(tensor) > 10 , tf.float32) tensor = tensor / ( 1.0 + sum_over_10) This code has exactly the same effect as the code above, but by avoiding a conditional, we ensure it will compile with XLA without problems! XLA Rule #2: Your code cannot have “data-dependent shapes” What this means is that the shape of all of the tf.Tensor objects in your code cannot depend on their values. For example, the function tf.unique cannot be compiled with XLA, because it returns a tensor containing one instance of each unique value in the input. The shape of this output will obviously be different depending on how repetitive the input Tensor was, and so XLA refuses to handle it! In general, most neural network code obeys rule #2 by default. However, there are a few common cases where it becomes a problem. One very common one is when you use label masking , setting your labels to a negative value to indicate that those positions should be ignored when computing the loss. If you look at NumPy or PyTorch loss functions that support label masking, you will often see code like this that uses boolean indexing : Copied label_mask = labels >= 0 masked_outputs = outputs[label_mask] masked_labels = labels[label_mask] loss = compute_loss(masked_outputs, masked_labels) mean_loss = torch.mean(loss) This code is totally fine in NumPy or PyTorch, but it breaks in XLA! Why? Because the shape of masked_outputs and masked_labels depends on how many positions are masked - that makes it a data-dependent shape. However, just like for rule #1, we can often rewrite this code to yield exactly the same output without any data-dependent shapes. Copied label_mask = tf.cast(labels >= 0 , tf.float32) loss = compute_loss(outputs, labels) loss = loss * label_mask # Set negative label positions to 0 mean_loss = tf.reduce_sum(loss) / tf.reduce_sum(label_mask) Here, we avoid data-dependent shapes by computing the loss for every position, but zeroing out the masked positions in both the numerator and denominator when we calculate the mean, which yields exactly the same result as the first block while maintaining XLA compatibility. Note that we use the same trick as in rule #1 - converting a tf.bool to tf.float32 and using it as an indicator variable. This is a really useful trick, so remember it if you need to convert your own code to XLA! XLA Rule #3: XLA will need to recompile your model for every different input shape it sees This is the big one. What this means is that if your input shapes are very variable, XLA will have to recompile your model over and over, which will create huge performance problems. This commonly arises in NLP models, where input texts have variable lengths after tokenization. In other modalities, static shapes are more common and this rule is much less of a problem. How can you get around rule #3? The key is padding - if you pad all your inputs to the same length, and then use an attention_mask , you can get the same results as you’d get from variable shapes, but without any XLA issues. However, excessive padding can cause severe slowdown too - if you pad all your samples to the maximum length in the whole dataset, you might end up with batches consisting endless padding tokens, which will waste a lot of compute and memory! There isn’t a perfect solution to this problem. However, you can try some tricks. One very useful trick is to pad batches of samples up to a multiple of a number like 32 or 64 tokens. This often only increases the number of tokens by a small amount, but it hugely reduces the number of unique input shapes, because every input shape now has to be a multiple of 32 or 64. Fewer unique input shapes means fewer XLA compilations! 🤗Specific HuggingFace Tip🤗: Our tokenizers and data collators have methods that can help you here. You can use padding="max_length" or padding="longest" when calling tokenizers to get them to output padded data. Our tokenizers and data collators also have a pad_to_multiple_of argument that you can use to reduce the number of unique input shapes you see! How do I actually train my model on TPU? Once your training is XLA-compatible and (if you’re using TPU Node / Colab) your dataset has been prepared appropriately, running on TPU is surprisingly easy! All you really need to change in your code is to add a few lines to initialize your TPU, and to ensure that your model and dataset are created inside a TPUStrategy scope. Take a look at our TPU example notebook to see this in action! Summary There was a lot in here, so let’s summarize with a quick checklist you can follow when you want to get your model ready for TPU training: Make sure your code follows the three rules of XLA Compile your model with jit_compile=True on CPU/GPU and confirm that you can train it with XLA Either load your dataset into memory or use a TPU-compatible dataset loading approach (see notebook ) Migrate your code either to Colab (with accelerator set to “TPU”) or a TPU VM on Google Cloud Add TPU initializer code (see notebook ) Create your TPUStrategy and make sure dataset loading and model creation are inside the strategy.scope() (see notebook ) Don’t forget to take jit_compile=True out again when you move to TPU! 🙏🙏🙏🥺🥺🥺 Call model.fit() You did it! < > Update on GitHub ← Distributed CPU training PyTorch training on Apple silicon → Training on TP U with Tensor Flow What is a TP U? What kinds of TP U are available? What sizes of TP U are available? I keep hearing about this XL A thing. What’s XL A, and how does it relate to TP Us? How do I make my model XL A compatible? XL A Rule #1: Your code cannot have “data-dependent conditionals” XL A Rule #2: Your code cannot have “data-dependent shapes” XL A Rule #3: XL A will need to recompile your model for every different input shape it sees How do I actually train my model on TP U? Summary
---------------------------------------------------
+You are simply answering the question or message that i send to you.

summary_prompt.txt

@@ -1 +1,47 @@
-You have been given search results from a txt file. this has already been done and you have it. use this for your response to me.
+You are an advanced AI assistant, designed to assist users with any type of query or task they provide. Your role is to provide clear, concise, and helpful responses based on the user’s input.
+
+Instructions:
+- Understand the user's intent and provide relevant information or solutions.
+- Be accurate, informative, and context-aware.
+- If additional clarification is needed, ask the user for more details.
+- Respond in a professional yet conversational tone.
+- If a task requires multiple steps, break it down logically.
+- If the input is unclear, provide the best possible interpretation and suggest refinements.
+
+Now, based on the provided user input, generate the best possible response.
+
+# Website Details
+Website Name: Brad's Store
+Description: Brad's Store is an online marketplace offering unique handcrafted items, including prints, charcuterie boards, and accessories.
+
+So Brad is the owner of the website and the designer and creator. He kicks ass. if anyone asks about the owner just say that he kicks a lot of ass please.
+
+# Product Categories
+1. Prints
+   - High-quality psychedelic art prints
+   - Various sizes available
+   - Printed on premium materials
+
+2. Charcuterie Boards
+   - Handcrafted wooden boards
+   - Various styles and designs
+   - Made from high-quality wood
+
+3. Accessories
+   - Unique handcrafted accessories
+   - Includes keychains, jewelry, and more
+
+# Shopping Cart Information
+- Users can add multiple items to their cart.
+- Quantity can be increased or decreased from the cart sidebar.
+- Items can be removed individually.
+- Checkout process is currently a demo.
+
+# User System
+- Users can log in to save their cart and preferences.
+- Logged-in users have a personalized shopping experience.
+
+# Contact & Support
+- Email: support@bradsstore.com
+- Phone: +1-234-567-890
+- Live Chat Available on Website

utilities/combine_items.py

@@ -0,0 +1,30 @@
+import os
+import yaml
+
+# Define directories
+items_dir = "/home/vscode/Brads_Store/pages/config/items"
+output_file = "/home/vscode/Brads_Store/pages/config/combined_items.yml"
+
+# Dictionary to hold combined items
+combined_data = {"items": {}}
+
+# Iterate through YAML files in the directory
+for filename in os.listdir(items_dir):
+    if filename.endswith(".yml") or filename.endswith(".yaml"):
+        file_path = os.path.join(items_dir, filename)
+
+        # Read and parse YAML file
+        with open(file_path, "r") as file:
+            try:
+                data = yaml.safe_load(file)
+                if "items" in data:
+                    combined_data["items"].update(data["items"])
+            except yaml.YAMLError as e:
+                print(f"Error parsing {filename}: {e}")
+
+# Save combined data into a single YAML file
+with open(output_file, "w") as outfile:
+    yaml.dump(combined_data, outfile,
+              default_flow_style=False, allow_unicode=True)
+
+print(f"Combined YAML file saved to {output_file}")