stop tracking symlink

.dockerignore

@@ -0,0 +1,2 @@
+.get
+output

.gitattributes

@@ -0,0 +1,38 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text
+*.png filter=lfs diff=lfs merge=lfs -text
+models/starling-lm-7b-alpha.Q8_0.gguf filter=lfs diff=lfs merge=lfs -text
+cuda_12.4.0_550.54.14_linux.run filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -1,7 +1,6 @@
 output/
 image_temp/
 MerchantBotCLI/
-models/
+models
 seed_images/
 cuda_12.4.0_550.54.14_linux.run
-/media/drakosfire/Shared/models

Dockerfile

@@ -0,0 +1,127 @@
+# Stage 1: Build Cuda toolkit
+FROM ubuntu:22.04 as cuda-setup
+
+
+ARG DEBIAN_FRONTEND=noninteractive
+
+# Install necessary libraries including libxml2
+RUN apt-get update && \
+    apt-get install -y gcc libxml2 && \
+    apt-get clean && \
+    rm -rf /var/lib/apt/lists/*
+
+COPY cuda_12.4.0_550.54.14_linux.run .
+
+# Install wget, download cuda-toolkit and run
+RUN chmod +x cuda_12.4.0_550.54.14_linux.run && \
+    ./cuda_12.4.0_550.54.14_linux.run --silent --toolkit --override
+
+# Second Stage: Copy necessary CUDA directories install flash-attn
+FROM ubuntu:22.04 as base-layer
+
+# Copy the CUDA toolkit from the first stage
+COPY --from=cuda-setup /usr/local/cuda-12.4 /usr/local/cuda-12.4
+
+# Set environment variables to enable CUDA commands
+ENV PATH=/usr/local/cuda-12.4/bin:${PATH}
+ENV LD_LIBRARY_PATH=/usr/local/cuda-12.4/lib64:${LD_LIBRARY_PATH}
+
+# Install Python, pip, and virtualenv
+RUN apt-get update && \ 
+    apt-get install -y python3 python3-pip python3-venv git && \
+    apt-get clean && \
+    rm -rf /var/lib/apt/lists/*
+
+# Create a virtual environment and install dependencies
+RUN python3 -m venv /venv
+ENV PATH="/venv/bin:$PATH"
+FROM ubuntu:22.04 as cuda-setup
+
+
+ARG DEBIAN_FRONTEND=noninteractive
+
+# Install necessary libraries including libxml2
+RUN apt-get update && \
+    apt-get install -y gcc libxml2 && \
+    apt-get clean && \
+    rm -rf /var/lib/apt/lists/*
+
+COPY cuda_12.4.0_550.54.14_linux.run .
+
+# Install wget, download cuda-toolkit and run
+RUN chmod +x cuda_12.4.0_550.54.14_linux.run && \
+    ./cuda_12.4.0_550.54.14_linux.run --silent --toolkit --override
+
+# Second Stage: Copy necessary CUDA directories install flash-attn
+FROM ubuntu:22.04 as base-layer
+
+# Copy the CUDA toolkit from the first stage
+COPY --from=cuda-setup /usr/local/cuda-12.4 /usr/local/cuda-12.4
+
+# Set environment variables to enable CUDA commands
+ENV PATH=/usr/local/cuda-12.4/bin:${PATH}
+ENV LD_LIBRARY_PATH=/usr/local/cuda-12.4/lib64:${LD_LIBRARY_PATH}
+
+# Install Python, pip, and virtualenv
+RUN apt-get update && \ 
+    apt-get install -y python3 python3-pip python3-venv git && \
+    apt-get clean && \
+    rm -rf /var/lib/apt/lists/*
+
+# Create a virtual environment and install dependencies
+RUN python3 -m venv /venv
+ENV PATH="/venv/bin:$PATH"
+
+# Llama.cpp requires the ENV variable be set to signal the CUDA build and be built with the CMAKE variables from pip for python use
+ENV LLAMA_CUBLAS=1
+RUN pip install --no-cache-dir torch packaging wheel && \
+    pip install flash-attn && \
+RUN pip install --no-cache-dir torch packaging wheel && \
+    pip install flash-attn && \
+    pip install gradio && \
+    CMAKE_ARGS="-DLLAMA_CUBLAS=on" pip install llama_cpp_python==0.2.55 && \
+    CMAKE_ARGS="-DLLAMA_CUBLAS=on" pip install llama_cpp_python==0.2.55 && \
+    pip install pillow && \ 
+    pip install diffusers && \
+    pip install accelerate && \
+    pip install transformers && \
+    pip install peft && \
+    pip install pip install PyGithub
+
+
+FROM ubuntu:22.04 as final-layer
+
+COPY --from=base-layer /usr/local/cuda-12.4 /usr/local/cuda-12.4
+COPY --from=base-layer /venv /venv
+
+ENV PATH=/usr/local/cuda-12.4/bin:/venv/bin:${PATH}
+ENV LD_LIBRARY_PATH=/usr/local/cuda-12.4/lib64:${LD_LIBRARY_PATH}
+ENV LLAMA_CPP_LIB=/venv/lib/python3.10/site-packages/llama_cpp/libllama.so
+ENV VIRTUAL_ENV=/venv
+
+# Install Python and create a user
+RUN apt-get update && apt-get install -y python3 python3-venv && apt-get clean && rm -rf /var/lib/apt/lists/* && \
+    useradd -m -u 1000 user
+    
+
+# Install Python and create a user
+RUN apt-get update && apt-get install -y python3 python3-venv && apt-get clean && rm -rf /var/lib/apt/lists/* && \
+    useradd -m -u 1000 user
+    
+ENV PATH="$VIRTUAL_ENV/bin:$PATH"
+# Set working directory and user
+COPY . /home/user/app
+# Set working directory and user
+COPY . /home/user/app
+WORKDIR /home/user/app
+RUN chown -R user:user /home/user/app/ && \
+    mkdir -p /home/user/app/output && \
+    chown -R user:user /home/user/app/image_temp && \
+    chown -R user:user /home/user/app/output 
+
+USER user
+    
+# Set the entrypoint
+EXPOSE 8000
+
+ENTRYPOINT ["python", "main.py"]

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Drakosfire
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -0,0 +1,8 @@
+---
+license: mit
+title: Collectible Card Generator
+short_description: Use LLM and SD to make custom collectible cards
+app_file: main.py
+sdk: docker
+app_port: 8000
+---

card_generator.py

@@ -0,0 +1,124 @@
+import render_card_text as rend
+from PIL import Image, ImageFilter
+import utilities as u
+import ast
+
+
+def save_image(image,item_key):
+    image.save(f"{item_key['Name']}.png")
+
+
+# Import Inventory 
+#shop_inventory = inv.inventory
+#purchased_item_key = shop_inventory['Shortsword']
+#border_path = './card_templates/Shining Sunset Border.png'
+
+sticker_path_dictionary = {'Default': './card_parts/Sizzek Sticker.png','Common': './card_parts/Common.png', 'Uncommon': './card_parts/Uncommon.png','Rare': './card_parts/Rare.png','Very Rare':'./card_parts/Very Rare.png','Legendary':'./card_parts/Legendary.png'}
+blank_overlay_path = "./card_parts/white-fill-title-detail-value-transparent.png"
+value_overlay_path = "./card_parts/Value_box_transparent.png"
+test_item = {'Name': 'Pustulent Raspberry', 'Type': 'Fruit', 'Value': '1 cp', 'Properties': ['Unusual Appearance', 'Rare Taste'], 'Weight': '0.2 lb', 'Description': 'This small fruit has a pustulent appearance, with bumps and irregular shapes covering its surface. Its vibrant colors and strange texture make it an oddity among other fruits.', 'Quote': 'A fruit that defies expectations, as sweet and sour as life itself.', 'SD Prompt': 'A small fruit with vibrant colors and irregular shapes, bumps covering its surface.'}
+
+
+
+# Function that takes in an image url and a dictionary and uses the values to print onto a card.
+def paste_image_and_resize(base_image,sticker_path, x_position, y_position,img_width, img_height, purchased_item_key = None):
+    
+    # Check for if item has a Rarity string that is in the dictionary of sticker paths
+    if purchased_item_key:
+        if sticker_path[purchased_item_key]:
+            sticker_path = sticker_path[purchased_item_key]
+        else: sticker_path = sticker_path['Default']
+    
+    # Load the image to paste
+    image_to_paste = Image.open(sticker_path)
+
+    # Define the new size (scale) for the image you're pasting
+    
+    new_size = (img_width, img_height)
+
+    # Resize the image to the new size
+    image_to_paste_resized = image_to_paste.resize(new_size)
+
+    # Specify the top-left corner where the resized image will be pasted
+    paste_position = (x_position, y_position)  # Replace x and y with the coordinates
+
+    # Paste the resized image onto the base image
+    base_image.paste(image_to_paste_resized, paste_position, image_to_paste_resized)
+
+def render_text_on_card(image_path, item_name,
+                                    item_type,
+                                    item_rarity,
+                                    item_value,
+                                    item_properties,
+                                    item_damage,
+                                    item_weight,
+                                    item_description,
+                                    item_quote) : 
+    # Card Properties 
+    image_list = []
+    item_properties = ast.literal_eval(item_properties)
+    item_properties = '\n'.join(item_properties)
+    output_image_path = f"./{item_name}.png"
+    print(f"Saving image to {output_image_path}")
+    font_path = "./fonts/Balgruf.ttf"
+    italics_font_path = './fonts/BalgrufItalic.ttf'
+    initial_font_size = 50
+
+    # Title Properties
+    title_center_position = (395, 55)
+    title_area_width = 600 # Maximum width of the text box
+    title_area_height = 60  # Maximum height of the text box
+
+    # Type box properties
+    type_center_position = (384, 545)
+    type_area_width = 600 
+    type_area_height = 45 
+    type_text = item_type
+    if len(item_weight) >= 1: 
+        type_text = type_text + ' '+ item_weight
+
+    if len(item_damage) >= 1 : 
+        type_text = type_text + ' '+ item_damage
+
+    # Description box properties
+    description_position = (105, 630)
+    description_area_width = 590
+    description_area_height = 215
+
+    # Value box properties (This is good, do not change unless underlying textbox layout is changing)
+    value_position = (660,905)
+    value_area_width = 125
+    value_area_height = 50
+
+    # Quote test properties
+    quote_position = (110,885)
+    quote_area_width = 470
+    quote_area_height = 60                     
+
+    # open image and render text
+    image = u.open_image_from_url(image_path)
+    image = rend.render_text_with_dynamic_spacing(image, item_name, title_center_position, title_area_width, title_area_height,font_path,initial_font_size)
+    image = rend.render_text_with_dynamic_spacing(image,type_text , type_center_position, type_area_width, type_area_height,font_path,initial_font_size)
+    image = rend.render_text_with_dynamic_spacing(image, item_description + '\n\n' + item_properties, description_position, description_area_width, description_area_height,font_path,initial_font_size, description = True)
+    paste_image_and_resize(image, value_overlay_path,x_position= 0,y_position=0, img_width= 768, img_height= 1024)
+    image = rend.render_text_with_dynamic_spacing(image, item_value, value_position, value_area_width, value_area_height,font_path,initial_font_size)
+    image = rend.render_text_with_dynamic_spacing(image, item_quote, quote_position, quote_area_width, quote_area_height,italics_font_path,initial_font_size, quote = True)
+    #Paste Sizzek Sticker
+    paste_image_and_resize(image, sticker_path_dictionary,x_position= 0,y_position=909, img_width= 115, img_height= 115, purchased_item_key= item_rarity)
+
+    # Add blur, gives it a less artificial look, put into list and return the list since gallery requires lists
+    image = image.filter(ImageFilter.GaussianBlur(.5))
+    image_list.append(image)
+   
+    image = image.save(f"./output/{item_name}.png")
+    
+    
+
+    return image_list
+    
+
+#render_text_on_card('./card_templates/Shining Sunset Border.png',test_item )
+
+
+
+

fonts/balgruf-font/info.txt

@@ -0,0 +1,2 @@
+license: SIL Open Font License (OFL)
+link: https://www.fontspace.com/balgruf-font-f59539

img2img.py

@@ -0,0 +1,77 @@
+from diffusers import (StableDiffusionXLImg2ImgPipeline, AutoencoderKL)                   
+from diffusers.utils import load_image
+import torch
+import time
+import utilities as u
+import card_generator as card
+from PIL import Image
+
+pipe = None
+start_time = time.time()
+torch.backends.cuda.matmul.allow_tf32 = True
+model_path = ("./models/stable-diffusion/card-generator-v1.safetensors")
+lora_path = "./models/stable-diffusion/Loras/blank-card-template-5.safetensors"
+detail_lora_path = "./models/stable-diffusion/Loras/add-detail-xl.safetensors"
+mimic_lora_path = "./models/stable-diffusion/Loras/EnvyMimicXL01.safetensors"
+temp_image_path = "./image_temp/"
+card_pre_prompt = " blank magic card,high resolution, detailed intricate high quality border, textbox, high quality detailed magnum opus drawing of a "
+negative_prompts = "text, words, numbers, letters"
+image_list = []
+
+
+def load_img_gen(prompt, item, mimic = None):
+    prompt = card_pre_prompt + item + ' ' + prompt
+    print(prompt)
+    # image_path = f"{user_input_template}"
+    # init_image = load_image(image_path).convert("RGB")
+    
+    pipe = StableDiffusionXLImg2ImgPipeline.from_single_file(model_path,
+                                                       custom_pipeline="low_stable_diffusion",                                                       
+                                                         torch_dtype=torch.float16, 
+                                                         variant="fp16").to("cuda")  
+    # Load LoRAs for controlling image
+    #pipe.load_lora_weights(lora_path, weight_name = "blank-card-template-5.safetensors",adapter_name = 'blank-card-template')    
+    pipe.load_lora_weights(detail_lora_path, weight_name = "add-detail-xl.safetensors", adapter_name = "add-detail-xl")
+    
+    # If mimic keyword has been detected, load the mimic LoRA and set adapter values
+    if mimic:
+        pipe.load_lora_weights(mimic_lora_path, weight_name = "EnvyMimicXL01.safetensors", adapter_name = "EnvyMimicXL")
+        pipe.set_adapters(['blank-card-template', "add-detail-xl", "EnvyMimicXL"], adapter_weights = [0.9,0.9,1.0])
+    else : 
+        pipe.set_adapters([ "add-detail-xl"], adapter_weights = [0.9])       
+    pipe.enable_vae_slicing()
+    return pipe, prompt
+
+def preview_and_generate_image(x,pipe, prompt, user_input_template, item):    
+    img_start = time.time()   
+    image = pipe(prompt=prompt,
+                strength = .9,
+                guidance_scale = 5,
+                image= user_input_template,
+                negative_promt = negative_prompts,
+                num_inference_steps=40,
+                height = 1024, width = 768).images[0]
+    
+    image = image.save(temp_image_path+str(x) + f"{item}.png")
+    output_image_path = temp_image_path+str(x) + f"{item}.png"
+    img_time = time.time() - img_start
+    img_its = 50/img_time
+    print(f"image gen time = {img_time} and {img_its} it/s")
+        
+    # Delete the image variable to keep VRAM open to load the LLM
+    del image
+    print(f"Memory after del {torch.cuda.memory_allocated()}")
+    print(image_list)
+    total_time = time.time() - start_time
+    print(total_time)
+
+    return output_image_path
+
+
+
+
+
+
+
+
+          

item_dict_gen.py

@@ -0,0 +1,368 @@
+from llama_cpp import Llama
+import ast
+import gc
+import torch
+
+model_path = "./models/starling-lm-7b-alpha.Q8_0.gguf"
+
+def load_llm(user_input):
+  llm = Llama(
+  model_path=model_path,
+  n_ctx=8192,  # The max sequence length to use - note that longer sequence lengths require much more resources
+  n_threads=8,            # The number of CPU threads to use, tailor to your system and the resulting performance
+  n_gpu_layers=32 # The number of layers to offload to GPU, if you have GPU acceleration available
+  )
+  return llm(
+  f"GPT4 User: {prompt_instructions}  the item is {user_input}: <|end_of_turn|>GPT4 Assistant:", # Prompt
+  max_tokens=768,  # Generate up to 512 tokens
+  stop=["</s>"],   # Example stop token - not necessarily correct for this specific model! Please check before using.
+  echo=False        # Whether to echo the prompt
+  )
+
+def call_llm_and_cleanup(user_input):
+    # Call the LLM and store its output
+    llm_output = load_llm(user_input)
+    print(llm_output['choices'][0]['text'])
+    gc.collect()
+    if torch.cuda.is_available():
+        torch.cuda.empty_cache()  # Clear VRAM allocated by PyTorch
+    
+    # llm_output is still available for use here
+    
+    return llm_output
+
+def convert_to_dict(string):
+  # Evaluate if string is dictionary literal
+    try: 
+        result = ast.literal_eval(string)
+        if isinstance(result, dict):
+            print("Item dictionary is valid")
+            return result
+        # If not, modify by attempting to add brackets to where they tend to fail to generate.
+        else: 
+            modified_string = '{' + string
+            if isinstance(modified_string, dict):  
+                return modified_string
+            modified_string = string + '}'
+            if isinstance(modified_string, dict):  
+                return modified_string
+            modified_string = '{' + string + '}'
+            if isinstance(modified_string, dict):  
+                return modified_string
+    except (ValueError, SyntaxError) :
+        print("Dictionary not valid")
+        return None
+  
+
+# Instructions past 4 are not time tested and may need to be removed.
+### Meta prompted : 
+prompt_instructions = """ **Purpose**: Generate a structured inventory entry for a specific item as a hashmap. Follow the format provided in the examples below.
+
+**Instructions**:
+1. Replace `{item}` with the name of the user item, DO NOT CHANGE THE USER ITEM NAME enclosed in single quotes (e.g., `'Magic Wand'`).
+2. Ensure your request is formatted as a hashmap. 
+3. Weapons MUST have a key 'Damage' 
+4. The description should be brief and puncy, or concise and thoughtful.
+5. The quote and SD Prompt MUST be inside double quotations ie " ".
+6. The quote is from the perspective of someone commenting on the impact of the {item} on their life
+7. Value should be assigned as an integer of copper pieces (cp), silver pieces (sp), electrum pieces (ep), gold pieces (gp), and platinum pieces (pp). 
+8. Use this table for reference on value : 
+1 cp 	1 lb. of wheat
+2 cp 	1 lb. of flour or one chicken
+5 cp 	1 lb. of salt
+1 sp 	1 lb. of iron or 1 sq. yd. of canvas
+5 sp 	1 lb. of copper or 1 sq. yd. of cotton cloth
+1 gp 	1 lb. of ginger or one goat
+2 gp 	1 lb. of cinnamon or pepper, or one sheep
+3 gp 	1 lb. of cloves or one pig
+5 gp 	1 lb. of silver or 1 sq. yd. of linen
+10 gp 	1 sq. yd. of silk or one cow
+15 gp 	1 lb. of saffron or one ox
+50 gp 	1 lb. of gold
+500 gp 	1 lb. of platinum
+
+
+300 gp +1 Melee or Ranged Weapon 
+2000 gp +2 Melee or Ranged Weapon 
+10000 gp  +3 Melee or Ranged Weapon 
+300 gp +1 Armor Uncommon
+2000 gp +2 Armor Rare
+10000 gp +3 Armor Very Rare
+300 gp +1 Shield Uncommon
+2000 gp +2 Shield Rare
+10000 gp +3 Shield Very Rare
+
+9. Examples of Magical Scroll Value:
+    Common: 50-100 gp
+    Uncommon: 101-500 gp
+    Rare: 501-5000 gp
+    Very rare: 5001-50000 gp
+    Legendary: 50001+ gp
+
+A scroll's rarity depends on the spell's level:
+    Cantrip-1: Common
+    2-3: Uncommon
+    4-5: Rare
+    6-8: Very rare
+    9: Legendary
+
+10. Explanation of Mimics:
+Mimics are shapeshifting predators able to take on the form of inanimate objects to lure creatures to their doom. In dungeons, these cunning creatures most often take the form of doors and chests, having learned that such forms attract a steady stream of prey.
+Imitative Predators. Mimics can alter their outward texture to resemble wood, stone, and other basic materials, and they have evolved to assume the appearance of objects that other creatures are likely to come into contact with. A mimic in its altered form is nearly unrecognizable until potential prey blunders into its reach, whereupon the monster sprouts pseudopods and attacks.
+When it changes shape, a mimic excretes an adhesive that helps it seize prey and weapons that touch it. The adhesive is absorbed when the mimic assumes its amorphous form and on parts the mimic uses to move itself.
+Cunning Hunters. Mimics live and hunt alone, though they occasionally share their feeding grounds with other creatures. Although most mimics have only predatory intelligence, a rare few evolve greater cunning and the ability to carry on simple conversations in Common or Undercommon. Such mimics might allow safe passage through their domains or provide useful information in exchange for food.
+
+11. 
+**Format Example**:
+- **Dictionary Structure**:
+    
+    {"{item}": {
+    'Name': "{item name}",
+    'Type': '{item type}',
+    'Rarity': '{item rarity},
+    'Value': '{item value}',
+    'Properties': ["{property1}", "{property2}", ...],
+    'Damage': '{damage formula} , '{damage type}',
+    'Weight': '{weight}',
+    'Description': "{item description}",
+    'Quote': "{item quote}",
+    'SD Prompt': "{special description for the item}"
+    } }
+    
+- **Input Placeholder**:
+    - "{item}": Replace with the item name, ensuring it's wrapped in single quotes.
+
+**Output Examples**:
+1. Cloak of Whispering Shadows Entry:
+    
+    {"Cloak of Whispering Shadows": {
+    'Name': 'Cloak of Whispering Shadows',
+    'Type': 'Cloak',
+    'Rarity': 'Very Rare', 
+    'Value': '7500 gp',
+    'Properties': ["Grants invisibility in dim light or darkness","Allows communication with shadows for gathering information"],
+    'Weight': '1 lb',
+    'Description': "A cloak woven from the essence of twilight, blending its wearer into the shadows. Whispers of the past and present linger in its folds, offering secrets to those who listen.",
+    'Quote': "In the embrace of night, secrets surface in the silent whispers of the dark.",
+    'SD Prompt': " Cloak of deep indigo almost black, swirling patterns that shift and move with every step. As it drapes over one's shoulders, an eerie connection forms between the wearer and darkness itself." 
+    } }   
+    
+2. Health Potion Entry:
+    
+    {"Health Potion": {
+    'Name' : "Health Portion",
+    'Type' : 'Potion',
+    'Rarity' : 'Common',
+    'Value': '50 gp',
+    'Properties': ["Quafable", "Restores 1d4 + 2 HP upon consumption"],
+    'Weight': '0.5 lb',
+    'Description': "Contained within this small vial is a crimson liquid that sparkles when shaken, a life-saving elixir for those who brave the unknown.",
+    'Quote': "To the weary, a drop of hope; to the fallen, a chance to stand once more.",
+    'SD Prompt' : " a small, delicate vial containing a sparkling crimson liquid. Emit a soft glow, suggesting its restorative properties. The vial is set against a dark, ambiguous background." 
+    } }     
+    
+3. Wooden Shield Entry:
+    
+    {"Wooden Shield": {
+    'Name' : "Wooden Shield",
+    'Type' : 'Armor, Shield',
+    'Rarity': 'Common',
+    'Value': '10 gp',
+    'Properties': ["+2 AC"],
+    'Weight': '6 lb',
+    'Description': "Sturdy and reliable, this wooden shield is a simple yet effective defense against the blows of adversaries.",
+    'Quote': "In the rhythm of battle, it dances - a barrier between life and defeat.",
+    'SD Prompt': " a sturdy wooden shield, a symbol of defense, with a simple yet solid design. The shield, has visible grain patterns and a few battle scars. It stands as a steadfast protector, embodying the essence of a warrior's resilience in the face of adversity." 
+    } }
+     
+4.  Helmet of Perception Entry:
+    
+    {"Helmet of Perception": {
+    'Name' : "Helmet of Perception",
+    'Type' : 'Magical Item (armor, helmet)',
+    'Rarity': 'Very Rare', 
+    'Value': '3000 gp',
+    'Properties': ["+ 1 to AC", "Grants the wearer advantage on perception checks", "+5 to passive perception"],
+    'Weight': '3 lb',
+    'Description': "Forged from mystic metals and enchanted with ancient spells, this helmet offers protection beyond the physical realm.",
+    'Quote': "A crown not of royalty, but of unyielding vigilance, warding off the unseen threats that lurk in the shadows.",
+    'SD Prompt': " a mystical helmet crafted from enchanted metals, glowing with subtle runes.  imbued with spells, radiates a mystical aura, symbolizing enhanced perception and vigilance,elegant,formidable" 
+    } }
+    
+5. Longbow Entry:
+    
+    {"Longbow": {
+    'Name': "Longbow",
+    'Type': 'Ranged Weapon (martial, longbow)',
+    'Rarity': 'Common',
+    'Value': '50 gp',
+    'Properties': ["2-handed", "Range 150/600", "Loading"],
+    'Damage': '1d8 + Dex, piercing',
+    'Weight': '6 lb',
+    'Description': "With a sleek and elegant design, this longbow is crafted for speed and precision, capable of striking down foes from a distance.",
+    'Quote': "From the shadows it emerges, a silent whisper of steel that pierces the veil of darkness, bringing justice to those who dare to trespass.",
+    'SD Prompt' : "a longbow with intricate carvings and stone inlay with a black string" 
+    } }
+    
+
+6. Mace Entry:
+    
+    {"Mace": {
+    'Name': "Mace",
+    'Type': 'Melee Weapon (martial, bludgeoning)',
+    'Rarity': 'Common',
+    'Value': '25 gp',
+    'Properties': ["Bludgeoning", "One-handed"],
+    'Damage': '1d6 + str, bludgeoning',
+    'Weight': '6 lb', 
+    'Description': "This mace is a fearsome sight, its head a heavy and menacing ball of metal designed to crush bone and break spirits.", 
+    'Quote': "With each swing, it sings a melody of pain and retribution, an anthem of justice to those who wield it.", 
+    'SD Prompt': "a menacing  metal spike ball mace, designed for bludgeoning, with a heavy, intimidating head, embodying a tool for bone-crushing and spirit-breaking." 
+    } }
+    
+7. Flying Carpet Entry:
+    
+    {"Flying Carpet": {
+    'Name': "Flying Carpet", 
+    'Type': 'Magical Item (transportation)', 
+    'Rarity': 'Very Rare',
+    'Value': '3000 gp', 
+    'Properties': ["Flying", "Personal Flight", "Up to 2 passengers", Speed : 60 ft], 
+    'Weight': '50 lb', 
+    'Description': "This enchanted carpet whisks its riders through the skies, providing a swift and comfortable mode of transport across great distances.",
+    'Quote': "Soar above the mundane, and embrace the winds of adventure with this magical gift from the heavens.", 
+    'SD Prompt': "a vibrant, intricately patterned flying carpet soaring high in the sky, with clouds and a clear blue backdrop, emphasizing its magical essence and freedom of flight" 
+    } }
+    
+8. Tome of Endless Stories Entry:
+    
+    {"Tome of Endless Stories": {
+    'Name': "Tome of Endless Stories",
+    'Type': 'Book',
+    'Rarity': 'Uncommon'
+    'Value': '500 gp',
+    'Properties': [
+        "Generates a new story or piece of lore each day",
+        "Reading a story grants insight or a hint towards solving a problem or puzzle"
+    ],
+    'Weight': '3 lbs',
+    'Description': "An ancient tome bound in leather that shifts colors like the sunset. Its pages are never-ending, filled with tales from worlds both known and undiscovered.",
+    'Quote': "Within its pages lie the keys to a thousand worlds, each story a doorway to infinite possibilities.",
+    'SD Prompt': "leather-bound with gold and silver inlay, pages appear aged but are incredibly durable, magical glyphs shimmer softly on the cover." 
+    } }    
+    
+9. Ring of Miniature Summoning Entry:
+    
+    {"Ring of Miniature Summoning": {
+    'Name': "Ring of Miniature Summoning",
+    'Type': 'Ring',
+    'Rarity': 'Rare',
+    'Value': '1500 gp',
+    'Properties': ["Summons a miniature beast ally once per day", "Beast follows commands and lasts for 1 hour", "Choice of beast changes with each dawn"],
+    'Weight': '0 lb',
+    'Description': "A delicate ring with a gem that shifts colors. When activated, it brings forth a small, loyal beast companion from the ether.",
+    'Quote': "Not all companions walk beside us. Some are summoned from the depths of magic, small in size but vast in heart.",
+    'SD Prompt': "gemstone with changing colors, essence of companionship and versatility." 
+    } } 
+     
+
+10. Spoon of Tasting Entry:
+    
+    {"Spoon of Tasting": {
+    'Name': "Spoon of Tasting",
+    'Type': 'Spoon',
+    'Rarity': 'Uncommon',
+    'Value': '200 gp',
+    'Properties': ["When used to taste any dish, it can instantly tell you all the ingredients", "Provides exaggerated compliments or critiques about the dish"],
+    'Weight': '0.2 lb',
+    'Description': "A culinary critic’s dream or nightmare. This spoon doesn’t hold back its opinions on any dish it tastes.",
+    'Quote': "A spoonful of sugar helps the criticism go down.",
+    'SD Prompt': "Looks like an ordinary spoon, but with a mouth that speaks more than you’d expect."
+    } }
+    
+11. Infinite Scroll Entry: 
+    
+    {"Infinite Scroll": {
+    'Name': "Infinite Scroll",
+    'Type': 'Magical Scroll',
+    'Rarity': 'Legendary',
+    'Value': '25000',
+    'Properties': [
+        "Endlessly Extends with New Knowledge","Reveals Content Based on Reader’s Need or Desire","Cannot be Fully Transcribed"],
+    'Weight': '0.5 lb',
+    'Description': "This scroll appears to be a standard parchment at first glance. However, as one begins to read, it unrolls to reveal an ever-expanding tapestry of knowledge, lore, and spells that seems to have no end.",
+    'Quote': "In the pursuit of knowledge, the horizon is ever receding. So too is the content of this scroll, an endless journey within a parchment’s bounds.",
+    'SD Prompt': "A seemingly ordinary scroll that extends indefinitely" 
+    } }
+    
+12. Mimic Treasure Chest Entry:
+    
+    {"Mimic Treasure Chest": {
+    'Name': "Mimic Treasure Chest",
+    'Type': 'Trap',
+    'Rarity': 'Rare',
+    'Value': '1000 gp',  # Increased value reflects its dangerous and rare nature
+    'Properties': ["Deceptively inviting","Springs to life when interacted with","Capable of attacking unwary adventurers"],
+    'Weight': '50 lb',  # Mimics are heavy due to their monstrous nature
+    'Description': "This enticing treasure chest is a deadly Mimic, luring adventurers with the promise of riches only to unleash its monstrous true form upon those who dare to approach, turning their greed into a fight for survival.",
+    'SD Prompt': "A seemingly ordinary treasure chest that glimmers with promise. Upon closer inspection, sinister, almost living edges move with malice, revealing its true nature as a Mimic, ready to unleash fury on the unwary."
+    } }
+    
+13. Hammer of Thunderbolts Entry:
+    
+    {'Hammer of Thunderbolts': {
+    'Name': 'Hammer of Thunderbolts',
+    'Type': 'Melee Weapon (maul, bludgeoning)',
+    'Rarity': 'Legendary',
+    'Value': '16000',
+    'Damage': '2d6 + 1 (martial, bludgeoning)',
+    'Properties': ["requires attunement","Giant's Bane","must be wearing a belt of giant strength and gauntlets of ogre power","Str +4","Can excees 20 but not 30","20 against giant, DC 17 save against death","5 charges, expend 1 to make a range attack 20/60","ranged attack releases thunderclap on hit, DC 17 save against stunned 30 ft","regain 1d4+1 charges at dawn"],
+    'Weight': 15 lb',
+    'Description': "God-forged and storm-bound, a supreme force, its rune-etched head blazing with power. More than a weapon, it's a symbol of nature's fury, capable of reshaping landscapes and commanding elements with every strike.",
+    'Quote': "When the skies rage and the earth trembles, know that the Hammer of Thunderbolts has found its mark. It is not merely a weapon, but the embodiment of the storm\'s wrath wielded by those deemed worthy.",
+    'SD Prompt': "It radiates with electric energy, its rune-etched head and storm-weathered leather grip symbolizing its dominion over storms. In its grasp, it pulses with the potential to summon the heavens' fury, embodying the tempest's raw power."
+    } }
+
+14. Shadow Lamp Entry:  
+
+    {'Shadow Lamp': {
+    'Name': 'Shadow Lamp',
+    'Type': 'Magical Item',
+    'Rarity': 'Uncommon',
+    'Value': '500 gp',
+    'Properties': ["Provides dim light in a 20-foot radius", "Invisibility to darkness-based senses", "Can cast Darkness spell once per day"],
+    'Weight': '1 lb',
+    'Description': "A small lamp carved from obsidian and powered by a mysterious force, it casts an eerie glow that illuminates its surroundings while making the wielder invisible to those relying on darkness-based senses.",
+    'Quote': "In the heart of shadow lies an unseen light, casting away darkness and revealing what was once unseen.",
+    'SD Prompt': "Glass lantern filled with inky swirling shadows, black gaseous clouds flow out, blackness flows from it, spooky, sneaky"
+    } }
+
+15. Dark Mirror:
+
+    {'Dark Mirror': {
+    'Name': 'Dark Mirror',
+    'Type': 'Magical Item',
+    'Rarity': 'Rare',
+    'Value': '600 gp',
+    'Properties': ["Reflects only darkness when viewed from one side", "Grants invisibility to its reflection", "Can be used to cast Disguise Self spell once per day"],
+    'Weight': '2 lb',
+    'Description': "An ordinary-looking mirror with a dark, almost sinister tint. It reflects only darkness and distorted images when viewed from one side, making it an ideal tool for spies and those seeking to hide their true identity.",
+    'Quote': "A glass that hides what lies within, a surface that reflects only darkness and deceit.",
+    'SD Prompt': "Dark and mysterious black surfaced mirror with an obsidian flowing center with a tint of malice, its surface reflecting nothing but black and distorted images, swirling with tendrils, spooky, ethereal"
+    } }
+
+16. Moon-Touched Greatsword Entry:
+    
+    {'Moon-Touched Greatsword':{
+    'Name': 'Moontouched Greatsword',
+    'Type': 'Melee Weapon (greatsword, slashing)',
+    'Rarity': 'Very Rare',
+    'Value': '8000 gp',
+    'Damage': '2d6 + Str slashing',
+    'Properties': ["Adds +2 to attack and damage rolls while wielder is under the effects of Moonbeam or Daylight spells", "Requires attunement"],
+    'Weight': '6 lb',
+    'Description': "Forged from lunar metal and imbued with celestial magic, this greatsword gleams like a silver crescent moon, its edge sharp enough to cut through the darkest shadows.",
+    'Quote': "With each swing, it sings a melody of light that pierces the veil of darkness, a beacon of hope and justice.",
+    'SD Prompt': "A silver greatsword with a crescent moon-shaped blade that reflects a soft glow, reminiscent of the moon's radiance. The hilt is wrapped in silvery leather, and the metal seems to shimmer and change with the light, reflecting the lunar cycles."
+    } }
+"""

main.py

@@ -0,0 +1,303 @@
+
+import img2img 
+import card_generator as card
+import utilities as u
+import ctypes
+import user_input as useri
+import gradio as gr
+import template_builder as tb
+
+# This is a fix for the way that python doesn't release system memory back to the OS and it was leading to locking up the system
+libc = ctypes.cdll.LoadLibrary("libc.so.6")
+M_MMAP_THRESHOLD = -3
+
+# Set malloc mmap threshold.
+libc.mallopt(M_MMAP_THRESHOLD, 2**20)
+initial_name = "A Crowbar"
+
+with gr.Blocks() as demo:
+    
+    # Functions and State Variables
+    # Build functions W/in the Gradio format, because it only allows modification within it's context
+    # Define inputs to match what is called on click, and output of the function as a list that matches the list of outputs
+    textbox_default_dict = {'Name':'', \
+                            'Type': '',
+                            'Rarity':'',
+                            'Value':'',
+                            'Properties':'',
+                            'Damage':'',
+                            'Weight':'',
+                            'Description':'',
+                            'Quote':'',
+                            'SD Prompt':''
+                            }
+    
+    item_name_var = gr.State()
+    item_type_var = gr.State()
+    item_rarity_var = gr.State()
+    item_value_var = gr.State()
+    item_properties_var = gr.State()
+    item_damage_var = gr.State()
+    item_weight_var = gr.State()
+    item_description_var = gr.State()
+    item_quote_var = gr.State()
+    item_sd_prompt_var = gr.State('')
+
+    selected_border_image = gr.State('./card_templates/Moonstone Border.png')
+    num_image_to_generate = gr.State(4)
+    generated_image_list = gr.State([])
+    selected_generated_image = gr.State()
+    selected_seed_image = gr.State()
+    built_template = gr.State()  
+    mimic = None
+
+    def set_textbox_defaults(textbox_default_dict, key):
+        item_name = textbox_default_dict[key]
+        return item_name
+
+    # Function called when user generates item info, then assign values of dictionary to variables, output once to State, twice to textbox
+    def generate_text_update_textboxes(user_input):
+        u.reclaim_mem()
+
+        llm_output=useri.call_llm(user_input)
+        item_key = list(llm_output.keys())
+        
+        item_key_values = list(llm_output[item_key[0]].keys())
+        item_name = llm_output[item_key[0]]['Name']
+        item_type = llm_output[item_key[0]]['Type']
+        item_rarity = llm_output[item_key[0]]['Rarity']            
+        item_value = llm_output[item_key[0]]['Value']
+        item_properties = llm_output[item_key[0]]['Properties']
+        
+        if 'Damage' in item_key_values: 
+            item_damage = llm_output[item_key[0]]['Damage']
+        else: item_damage = ''
+
+        item_weight = llm_output[item_key[0]]['Weight']
+        item_description = llm_output[item_key[0]]['Description']
+        item_quote = llm_output[item_key[0]]['Quote']
+        sd_prompt = llm_output[item_key[0]]['SD Prompt']
+
+        return [item_name, item_name,
+                item_type, item_type,
+                item_rarity, item_rarity,
+                item_value, item_value,
+                item_properties, item_properties,
+                item_damage, item_damage,
+                item_weight, item_weight,
+                item_description, item_description,
+                item_quote, item_quote,
+                sd_prompt, sd_prompt]
+    
+    # Called on user selecting an image from the gallery, outputs the path of the image
+    def assign_img_path(evt: gr.SelectData):          
+        img_dict = evt.value
+        print(img_dict)
+        selected_image_path = img_dict['image']['url']
+        print(selected_image_path)
+        return selected_image_path   
+    
+     # Make a list of files in image_temp and delete them
+    def delete_temp_images():
+        image_list = u.directory_contents('./image_temp')
+        u.delete_files(image_list)
+        img2img.image_list.clear()
+    
+    # Called when pressing button to generate image, updates gallery by returning the list of image URLs
+    def generate_image_update_gallery(num_img, sd_prompt,item_name, built_template):
+        delete_temp_images()
+        print(type(built_template))
+        image_list = []
+        img_gen, prompt = img2img.load_img_gen(sd_prompt, item_name)
+        for x in range(num_img):
+            preview = img2img.preview_and_generate_image(x,img_gen, prompt, built_template, item_name)
+            image_list.append(preview)
+            yield image_list
+            #generate_gallery.change(image_list)
+        del preview
+        u.reclaim_mem()
+
+        #generated_image_list = img2img.generate_image(num_img,sd_prompt,item_name,selected_border)
+        return image_list
+    
+    def build_template(selected_border, selected_seed_image):
+        image_list = tb.build_card_template(selected_border, selected_seed_image)
+        return image_list, image_list
+   
+
+    # Beginning of UI Page
+    gr.HTML(""" <div id="inner"> <header>
+            <h1>Item Card Generator</h1>
+            <p>
+            With this AI driven tool you will build a collectible style card of a fantasy flavored item with details.
+            </p>
+            </div>""")
+    
+    gr.HTML(""" <div id="inner"> <header>
+            <h2><b>First:</b> Build a Card Template</h2>
+                </div>""")
+    with gr.Row():
+        with gr.Column():
+
+        # Template Gallery instructions
+            gr.HTML(""" <div id="inner"> <header>
+                    <h3>1. Click a border from the 'Card Template Gallery'</h3> 
+                    </div>""")
+            
+            border_gallery = gr.Gallery(label = "Card Template Gallery", 
+                                            scale = 2,
+                                            value = useri.index_image_paths("Drakosfire/CardGenerator", "seed_images/card_templates"),
+                                            show_label = True,
+                                            columns = [3], rows = [3],
+                                            object_fit = "contain",
+                                            height = "auto",
+                                            elem_id = "Template Gallery")
+        with gr.Column():
+            gr.HTML(""" <div id="inner"> <header>
+                        <h3>2. Click a image from the Seed Image Gallery</h3><br>
+                        </div>""")
+            
+            border_gallery.select(assign_img_path, outputs = selected_border_image)
+            seed_image_gallery = gr.Gallery(label= " Image Seed Gallery",
+                                            scale = 2,
+                                            value = useri.index_image_paths("Drakosfire/CardGenerator", "seed_images/item_seeds"),
+                                            show_label = True,
+                                            columns = [3], rows = [3],
+                                            object_fit = "contain",
+                                            height = "auto",
+                                            elem_id = "Template Gallery",
+                                            interactive=True)                 
+
+    gr.HTML(""" <div id="inner"> <header><h4> -Or- Upload your own seed image, by dropping it into the 'Generated Template Gallery' </h4><br>
+                <h3>3. Click 'Generate Card Template'</h3><br>
+            </div>""")
+    
+    built_template_gallery = gr.Gallery(label= "Generated Template Gallery",
+                                        scale = 1,
+                                        value = None,
+                                        show_label = True,
+                                        columns = [4], rows = [4],
+                                        object_fit = "contain",
+                                        height = "auto",
+                                        elem_id = "Template Gallery",
+                                        interactive=True) 
+    
+    seed_image_gallery.select(assign_img_path, outputs = selected_seed_image)
+    built_template_gallery.upload(u.receive_upload, inputs=built_template_gallery, outputs= selected_seed_image)
+    build_card_template_button = gr.Button(value = "Generate Card Template")
+    build_card_template_button.click(build_template, inputs = [selected_border_image, selected_seed_image], outputs = [built_template_gallery, built_template]) 
+        
+    gr.HTML(""" <div id="inner"> <header>
+                    <h2><b>Second:</b> Generate Item Text </h2>
+                   </div>""")  
+    gr.HTML(""" <div id="inner"> <header>
+                        <h3>1. Use a few words to describe the item then click 'Generate Text' </h3>
+                        </div>""")
+    with gr.Row():
+        user_input =  gr.Textbox(label = 'Item', lines =1, placeholder= "Flaming Magical Sword", elem_id= "Item", scale =4)
+        item_text_generate = gr.Button(value = "Generate item text", scale=1)
+
+    gr.HTML(""" <div id="inner"> <header>
+                <h3> 2. Review and Edit the text</h3>
+                </div>""") 
+    with gr.Row():
+
+    # Build text boxes for the broken up item dictionary values         
+        with gr.Column(scale = 1):
+            item_name_output = gr.Textbox(value = set_textbox_defaults(textbox_default_dict, 'Name'),label = 'Name', lines = 1, interactive=True, elem_id='Item Name')
+            item_type_output = gr.Textbox(value = set_textbox_defaults(textbox_default_dict, 'Type'),label = 'Type', lines = 1, interactive=True, elem_id='Item Type')
+            item_rarity_output = gr.Textbox(value = set_textbox_defaults(textbox_default_dict, 'Rarity'),label = 'Rarity : [Common, Uncommon, Rare, Very Rare, Legendary]', lines = 1, interactive=True, elem_id='Item Rarity')
+            item_value_output = gr.Textbox(value = set_textbox_defaults(textbox_default_dict, 'Value'),label = 'Value', lines = 1, interactive=True, elem_id='Item Value')
+                        
+                # Pass the user input and border template to the generator
+        with gr.Column(scale = 1):    
+            item_damage_output = gr.Textbox(value = set_textbox_defaults(textbox_default_dict, 'Damage'),label = 'Damage', lines = 1, interactive=True, elem_id='Item Damage')
+            item_weight_output = gr.Textbox(value = set_textbox_defaults(textbox_default_dict, 'Weight'),label = 'Weight', lines = 1, interactive=True, elem_id='Item Weight')
+            item_description_output = gr.Textbox(value = set_textbox_defaults(textbox_default_dict, 'Description'),label = 'Description', lines = 1, interactive=True, elem_id='Item Description')
+            item_quote_output = gr.Textbox(value = set_textbox_defaults(textbox_default_dict, 'Quote'),label = 'Quote', lines = 1, interactive=True, elem_id='Item quote')
+    item_properties_output = gr.Textbox(value = set_textbox_defaults(textbox_default_dict, 'Properties'),label = 'Properties : [List of comma seperated values]', lines = 1, interactive=True, elem_id='Item Properties')
+    
+    gr.HTML(""" <div id="inner"> <header>
+                <h3> 3. This text will be used to generate the card's image.</h3>
+                </div>""") 
+    item_sd_prompt_output = gr.Textbox(label = 'Putting words or phrases in parenthesis adds weight. Example: (Flaming Magical :1.0) Sword.', value = set_textbox_defaults(textbox_default_dict, 'SD Prompt'), lines = 1, interactive=True, elem_id='SD Prompt')
+         
+    gr.HTML(""" <div id="inner"> <header>
+                <h2> <b>Third:</b> Click 'Generate Cards' to generate 4 cards to choose from. </h2>
+                </div>""")          
+    card_gen_button = gr.Button(value = "Generate Cards", elem_id="Generate Card Button")
+           
+    # No longer Row Context, in context of entire Block
+    gr.HTML(""" <div id="inner"> <header>
+                <h2> <b>Fourth:</b> Click your favorite card then add text, or click 'Generate Four Card Options' again.<br>
+                 </h2>
+                </div>""")       
+
+    with gr.Row():
+        generate_gallery = gr.Gallery(label = "Generated Cards",
+                                    value = [],
+                                    show_label= True,
+                                    scale= 5,
+                                    columns =[2], rows = [2],
+                                    object_fit= "fill",
+                                    height = "768",
+                                    elem_id = "Generated Cards Gallery"
+                                    )
+        generate_final_item_card = gr.Button(value = "Add Text", elem_id = "Generate user card")
+    
+    card_gen_button.click(fn = generate_image_update_gallery, inputs =[num_image_to_generate,item_sd_prompt_output,item_name_output,built_template], outputs= generate_gallery)
+    generate_gallery.select(assign_img_path, outputs = selected_generated_image)
+
+        # Button logice calls function when button object is pressed, passing inputs and passing output to components
+    llm_output = item_text_generate.click(generate_text_update_textboxes, 
+                                                inputs = [user_input], 
+                                                outputs= [item_name_var, 
+                                                        item_name_output,
+                                                        item_type_var,
+                                                        item_type_output, 
+                                                        item_rarity_var,
+                                                        item_rarity_output,
+                                                        item_value_var,
+                                                        item_value_output,
+                                                        item_properties_var,
+                                                        item_properties_output,
+                                                        item_damage_var,
+                                                        item_damage_output,
+                                                        item_weight_var,
+                                                        item_weight_output,
+                                                        item_description_var,
+                                                        item_description_output,
+                                                        item_quote_var,
+                                                        item_quote_output,                                                     
+                                                        item_sd_prompt_var,
+                                                        item_sd_prompt_output])          
+        
+    generate_final_item_card.click(card.render_text_on_card, inputs = [selected_generated_image,
+                                                                        item_name_output, 
+                                                                        item_type_output, 
+                                                                        item_rarity_output, 
+                                                                        item_value_output,
+                                                                        item_properties_output, 
+                                                                        item_damage_output,
+                                                                        item_weight_output,
+                                                                        item_description_output,
+                                                                        item_quote_output
+                                                                        ], 
+                                                                        outputs = generate_gallery )
+    
+if __name__ == '__main__':
+    demo.launch(server_name = "0.0.0.0", server_port = 8000, share = False, allowed_paths = ["/media/drakosfire/Shared/","/media/drakosfire/Shared/MerchantBot/card_templates"])
+        
+
+
+
+
+
+
+
+    
+
+
+   
+
+

render_card_text.py

@@ -0,0 +1,97 @@
+from PIL import Image, ImageDraw, ImageFont
+
+ # Function for managing longer bodies of text and breaking into a list of lines to be printed based on input arguments   
+def split_text_into_lines(text, font, max_width, draw):
+    blocks = text.split('\n')  
+    lines = []
+    for block in blocks:
+        words = block.split()
+        current_line = ''
+
+        for word in words:
+            # Check width with new word added
+            test_line = f"{current_line} {word}".strip()
+            test_width = draw.textlength(text = test_line, font=font)
+            if test_width <= max_width:
+                current_line = test_line
+            else:
+                #If the line with the new word exceeds the max width, start a new line
+                lines.append(current_line)
+                current_line = word
+    # add the last line
+        lines.append(current_line)
+    return lines
+# Function for calculating the height of the text at the current font setting
+       
+
+def adjust_font_size_lines_and_spacing(text, font_path, initial_font_size, max_width, area_height, image) :    
+    font_size = initial_font_size
+    optimal_font_size = font_size
+    optimal_lines = []
+    line_spacing_factor = 1.2 # multiple of font size that will get added between each line
+    
+    while font_size > 10: # Set minimum font size
+        font = ImageFont.truetype(font_path, font_size)
+        draw = ImageDraw.Draw(image)
+        # Fitting text into box dimensions
+        lines = split_text_into_lines(text, font, max_width, draw)
+        # Calculate total height with dynamic line spacing
+        single_line_height = draw.textbbox((0, 0), "Ay", font=font)[3] - draw.textbbox((0, 0), "Ay", font=font)[1]  # Height of 'Ay'
+        line_spacing = int(single_line_height * line_spacing_factor) - single_line_height
+        total_text_height = len(lines) * single_line_height + (len(lines) - 1) * line_spacing # Estimate total height of all lines by multiplying number of lines by font height plus number of lines -1 times line spacing
+
+        if total_text_height <= area_height : 
+            optimal_font_size = font_size
+            optimal_lines = lines
+            break # Exit loop font fits in contraints
+
+        else: 
+            font_size -= 1 # Reduce font by 1 to check if it fits             
+        
+    return optimal_font_size, optimal_lines, line_spacing     
+# Function that takes in an image,text and properties for textfrom card_generator 
+def render_text_with_dynamic_spacing(image, text, center_position, max_width, area_height,font_path, initial_font_size,description = None, quote = None):
+    
+
+    optimal_font_size, optimal_lines, line_spacing = adjust_font_size_lines_and_spacing(
+        text, font_path, initial_font_size, max_width, area_height, image)
+    # create an object to draw on 
+    
+    font = ImageFont.truetype(font_path, optimal_font_size)
+    draw = ImageDraw.Draw(image)
+
+     # Shadow settings
+    shadow_offset = (1, 1)  # X and Y offset for shadow
+    shadow_color = 'grey'  # Shadow color
+
+    # Unsure about the following line, not sure if I want y_offset to be dynamic
+    y_offset = center_position[1]         
+    
+    if description or quote : 
+        for line in optimal_lines:
+            line_width = draw.textlength(text = line, font=font)
+            x = center_position[0] 
+            # Draw Shadow first
+            shadow_position = (x + shadow_offset[0], y_offset + shadow_offset[1])
+            draw.text(shadow_position, line, font=font, fill=shadow_color)
+            #Draw text
+            draw.text((x, y_offset), line, font=font, fill = 'black', align = "left" )
+            y_offset += optimal_font_size + line_spacing  # Move to next line
+        return image  
+
+    for line in optimal_lines:
+        line_width = draw.textlength(text = line, font=font)
+        x = center_position[0] - (line_width / 2)
+        # Draw Shadow first
+        shadow_position = (x + shadow_offset[0], y_offset + shadow_offset[1])
+        draw.text(shadow_position, line, font=font, fill=shadow_color)
+        #Draw text
+        draw.text((x, y_offset), line, font=font, fill = 'black', align = "left" )
+        y_offset += optimal_font_size + line_spacing  # Move to next line
+    return image   
+
+# Function to put the description objects together, this will be the complicated bit, I think iterate through keys excluding title, type and cost
+
+
+
+

template_builder.py

@@ -0,0 +1,73 @@
+from PIL import Image, ImageDraw, ImageFont
+import utilities as u
+
+# Function to initialize image canvas
+
+# Function to scale the seed image
+
+# Paste seed image onto blank canvas at specific location
+
+# Paste the selected border on top
+
+# Save and return
+
+# Function that takes in an image url and a dictionary and uses the values to print onto a card.
+
+# Seed Image starting x,y
+seed_x = 56
+seed_y = 128
+seed_width = 657
+seed_height = 422
+
+def paste_image_and_resize(base_image,sticker, x_position, y_position,img_width, img_height):    
+            
+    # Load the image to paste
+    # image_to_paste = Image.open(sticker_path)
+
+    # Define the new size (scale) for the image you're pasting
+    
+    new_size = (img_width, img_height)
+
+    # Resize the image to the new size
+    sticker = sticker.resize(new_size)
+
+    # Specify the top-left corner where the resized image will be pasted
+    paste_position = (x_position, y_position)  # Replace x and y with the coordinates
+
+    # Paste the resized image onto the base image
+    base_image.paste(sticker, paste_position)
+    
+    return base_image
+
+def build_card_template(selected_border, selected_seed_image):
+    print(selected_seed_image)
+    print(type(selected_seed_image))
+    selected_border = u.open_image_from_url(selected_border)
+    if type(selected_seed_image) == str:      
+        print(f"String : {selected_seed_image}")      
+        selected_seed_image = u.open_image_from_url(selected_seed_image)
+    
+    mask = selected_border.split()[3]
+    
+    image_list = []
+
+    # Image size parameters
+    width = 768
+    height = 1024
+
+    # Set canvas as transparent
+
+    background_color = (0,0,0,0)
+
+    #initialize canvas
+    canvas = Image.new('RGB', (width, height), background_color)
+    
+    canvas = paste_image_and_resize(canvas, selected_seed_image,seed_x,seed_y, seed_width, seed_height)
+    
+    canvas.paste(selected_border,(0,0), mask = mask)
+
+    image_list.append(canvas)
+
+    return image_list
+
+ 

user_input.py

@@ -0,0 +1,103 @@
+import item_dict_gen as igen 
+import img2img 
+import card_generator as card
+import utilities as u
+import sys
+import tempfile
+from PIL import Image
+from github import Github
+
+image_path = str
+end_phrase = """<|end_of_turn|>"""
+# Indexing the contents of Card templates and temp images
+card_template_path = "./card_templates/"
+temp_image_path = "./image_temp"
+
+def index_image_paths(repo_name,directory_path):
+    g = Github()  # No token needed for public repos
+    repo = g.get_repo(repo_name)
+    contents = repo.get_contents(directory_path)
+
+    files = []
+    for content_file in contents:
+        if content_file.type == "file":
+            files.append(content_file.download_url)  # Or content_file.path for just the path
+    
+    return files
+
+user_pick_template_prompt = "Pick a template number from this list : "
+user_pick_image_prompt = "Select an image : "
+
+# Check if the user wants to exit the chatbot
+
+def user_exit_question(user_input):
+    if user_input.lower() in ['exit', 'quit']:
+        print("Chatbot session ended.")
+        sys.exit()
+# Process the list of files in the card_template directory and print with corresponding numbers to index    
+def process_list_for_user_response(list_of_items):
+    x = 0
+    for item in list_of_items:
+        print(f"{x} : {item}")
+        x += 1
+
+def user_pick_item(user_prompt,list_of_items):
+    process_list_for_user_response(list_of_items)
+    user_input = input(user_prompt)
+    # Check if the user wants to exit the chatbot
+    user_exit_question(user_input)
+    return list_of_items[int(user_input)]
+
+def call_llm(user_input):
+    # Process the query and get the response
+    llm_call = igen.call_llm_and_cleanup(user_input)
+    response = llm_call['choices'][0]['text']
+        
+        # Find the index of the phrase
+    index = response.find(end_phrase)
+    print(f"index = {index}")
+    if index != -1:
+        # Slice the string from the end of the phrase onwards
+        response = response[index + len(end_phrase):]
+    else:
+        # Phrase not found, optional handling
+        response = response
+    
+    response = response.replace("GPT4 Assistant: ", "")
+    print(response)
+    response = igen.convert_to_dict(response)
+    if not response:
+        response = call_llm(user_input)
+    del llm_call
+    return response
+
+def prompt_user_input():
+    mimic = None
+    while True:
+        user_input_item = input("Provide an item : ")
+        user_exit_question(user_input_item) 
+            
+        if 'mimic' in user_input_item.lower():
+            mimic = True
+
+        #user_input_template = input(f"Pick a template number from this list : {process_list_for_user_response(list_of_card_templates)}")
+        
+        user_input_template = user_pick_item(user_pick_template_prompt,list_of_card_templates)
+        response = call_llm(user_input_item)        
+        print(response[u.keys_list(response,0)])
+        output_dict = response[u.keys_list(response,0)]
+        u.reclaim_mem()
+        item_name = response[u.keys_list(response,0)]['Name']
+        sd_prompt = response[u.keys_list(response,0)]['SD Prompt']    
+        image_path = img2img.generate_image(4,sd_prompt,item_name,user_input_template, mimic)
+        user_card_image = user_pick_item(user_pick_image_prompt, image_path)
+        
+        print(image_path)
+        
+        card.render_text_on_card(user_card_image, output_dict)
+        u.delete_files(img2img.image_list)
+
+
+
+
+

utilities.py

@@ -0,0 +1,62 @@
+# Create a list of hashmap key values .
+import torch
+import time
+import gc
+from io import BytesIO
+import requests
+import os
+from PIL import Image
+from pathlib import Path
+# Utility Functions to be called from all modules
+
+# Function to return a list of keys of a nested dictionary using it's key value (item or creature)
+def keys_list(dict, index):
+    keys_list=list(dict.keys())
+    return keys_list[index]
+
+# Function to clear model from VRAM to make space for other model
+def reclaim_mem():
+    
+    print(f"Memory before del {torch.cuda.memory_allocated()}")
+    torch.cuda.ipc_collect()
+    gc.collect()
+    torch.cuda.empty_cache()
+    time.sleep(0.01)
+    print(f"Memory after del {torch.cuda.memory_allocated()}")
+
+#def del_object(object):
+ #       del object
+  #      gc.collect()
+
+# Create a list of a directory if directory exists
+def directory_contents(directory_path):
+    if os.path.isdir(directory_path) :
+          contents = os.listdir(directory_path)
+          return contents
+    else : pass
+
+# Delete a list of file 
+def delete_files(file_paths):
+     
+    for file_path in file_paths:
+        try:
+            os.remove(f"./image_temp/{file_path}")
+            print(f"Remove : ./image_temp/{file_path}")
+        except OSError as e:
+            print(f"Error: {file_path} : {e.strerror}")
+    file_paths.clear()
+    
+
+def open_image_from_url(image_url):
+    response = requests.get(image_url)
+    image_data = BytesIO(response.content)
+    image = Image.open(image_data)
+    return image
+
+def receive_upload(image_file):
+        
+    image = Image.open(image_file[0][0])
+
+    print(image)
+    return image
+