Pet Generator Functioning

Dockerfile

@@ -158,4 +158,6 @@ USER user
 # Set the entrypoint
 EXPOSE 8000
 
-ENTRYPOINT ["python", "main.py"]
+ENTRYPOINT ["python", "main.py"]
+
+<lora:CyborgsXL:..3> <lora:RBTS_STYLE:.2> <lora:ral-fluff:1.3> <lora:zhibi:.5>

card_generator.py

@@ -23,15 +23,8 @@ test_item = {'Name': 'Pustulent Raspberry', 'Type': 'Fruit', 'Value': '1 cp', 'P
 # 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):
     
-<<<<<<< HEAD
     # Check for if item has a Rarity string that is in the dictionary of sticker paths
-=======
-    # Check for if item has a Rarity string that is a in the dictionary of sticket paths
->>>>>>> 9a956dd (Polished and launch to Hugging Face)
-    if purchased_item_key:
-        if sticker_path[purchased_item_key]:
-            sticker_path = sticker_path[purchased_item_key]
-        else: sticker_path = sticker_path['Default']
+    #Sticker = sticker_path['Default']
     
     # Load the image to paste
     image_to_paste = Image.open(sticker_path)
@@ -49,20 +42,19 @@ def paste_image_and_resize(base_image,sticker_path, x_position, y_position,img_w
     # 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) : 
+def render_text_on_card(image_path, pet_name,
+                                    pet_species,
+                                    pet_breed,
+                                    pet_fur,
+                                    pet_intelligence,
+                                    pet_affection,
+                                    pet_energy,
+                                    pet_noise,
+                                    pet_play) : 
     # Card Properties 
     image_list = []
-    item_properties = ast.literal_eval(item_properties)
-    item_properties = '\n'.join(item_properties)
-    output_image_path = f"./{item_name}.png"
+    pet_properties = f"Intelligence : {pet_intelligence} \n Affection : {pet_affection} \n Energy : {pet_energy} \n Noise : {pet_noise} \n Play : {pet_play}"
+    output_image_path = f"./{pet_name}.png"
     print(f"Saving image to {output_image_path}")
     font_path = "./fonts/Balgruf.ttf"
     italics_font_path = './fonts/BalgrufItalic.ttf'
@@ -77,12 +69,7 @@ def render_text_on_card(image_path, item_name,
     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
+    type_text = f"{pet_breed} Color and Fur : {pet_fur}"    
 
     # Description box properties
     description_position = (105, 630)
@@ -101,28 +88,24 @@ def render_text_on_card(image_path, item_name,
 
     # 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, pet_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)
+    image = rend.render_text_with_dynamic_spacing(image, pet_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)
+    paste_image_and_resize(image, sticker_path_dictionary['Default'],x_position= 0,y_position=909, img_width= 115, img_height= 115, purchased_item_key= None)
 
     # 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")
+    image = image.save(f"./output/{pet_name}.png")
     
     
 
     return image_list
     
 
-#render_text_on_card('./card_templates/Shining Sunset Border.png',test_item )
-
 
 
 

item_dict_gen.py

@@ -3,7 +3,7 @@ import ast
 import gc
 import torch
 
-model_path = "./models/starling-lm-7b-alpha.Q8_0.gguf"
+model_path = "models/starling-lm-7b-alpha.Q8_0.gguf"
 # Add variable for User Style prompt ie GPT4 User
 # Add variable for end of input and response name ie <|end_of_turn|>GPT4 Assistant:
 # Make prompt a variable
@@ -66,8 +66,8 @@ prompt_instructions = """ **Purpose**: Generate a structured inventory entry for
 1. Replace `{pet}` with the name of the user pet, DO NOT CHANGE THE USER pet NAME enclosed in single quotes (e.g., `'Magic Wand'`).
 2. Ensure your request is formatted as a hashmap. 
 3. The cybernetic pets are friendly and cute, they are products and toys. 
-4. The description should be brief and puncy, or concise and in the voice of a judge at a high end cat or dog or pet exhibition such as the American Kennel Clube or Cat Fancier and make specific callout of how mild, and well camoflaughed the artificiality of the cybernetic pet is.
-5. The quote and SD Prompt MUST be inside double quotations ie " ".
+4. The descriptions should be brief and puncy, or concise and in the voice of a judge at a high end cat or dog or pet exhibition such as the American Kennel Clube or Cat Fancier and make specific callout of how mild, and well camoflaughed the artificiality of the cybernetic pet is.
+5. The Image Prompt MUST be inside double quotations ie " ".
 8. Value should be assigned as an integer of copper pieces (cp), silver pieces (sp), electrum pieces (ep), gold pieces (gp), and platinum pieces (pp). 
 
  
@@ -75,112 +75,233 @@ prompt_instructions = """ **Purpose**: Generate a structured inventory entry for
 - **Dictionary Structure**:
     
     {"{Pet}": {
-    'Name': "{Pet Name}",
-    'Pet Species': '{pet species}',
-    'Breed': '{pet breed},
-    'Fur': '{pet fur qualities}',
-    'Intelligence Level': ["{property1}", "{property2}", ...],
-    'Affection Level': '{property1} , '{property2}',
-    'Energy Level': '{energy level}',
-    'Noise Level': "{pet description}",
-    'Play Level': "{play level}",
-    'SD Prompt': "{special description for the pet}"
-    } }
+    "Name": '{Pet Name}',
+    "Pet Species": '{pet species}',
+    "Breed": '{pet breed},
+    "Fur" : "The colors and quality of the pet's fur,
+    "Intelligence Level" : "How intelligent the pet is and how it demonstrates it",
+    "Affection Level" : "How affectionate and how the pet shows it,
+    "Energy Level" : "The Energy level",
+    "Noise Level" : "The volume, frequency, triggers, and type",
+    "Play Level" : " The level of play and types enjoyed",
+    "Image Prompt" : "Descriptive imagery for an image generator"
+     }
     
 - **Input Placeholder**:
     - "{pet}": Replace with the pet name, ensuring it's wrapped in single quotes.
+    
 
 **Output Examples**:
 1. Mignon the Toy Sized Chihuahua 
 
-    {“Mignon”: {
-	'Name': "Mignon”
-    'Pet Species': Dog,
-    “Breed” : ”Chihuahua (Toy)”,
-    “Fur”: “Cream, smooth shorthair”,
-    “Intelligence Level”: “Medium-high, trainable but stubborn”,
-    “Affection Level”: “High but selective, prefers favorite humans”,
-    “Energy Level”: “High”,
-    “Noise Level” : “Very high, yappy”,
-    “Play Level” : “Low“, Fetch, chase“
+    {'Mignon': {
+	"Name": "Mignon”
+    "Pet Species": Dog,
+    "Breed" : ”Chihuahua (Toy)”,
+    "Fur" : “Cream, smooth shorthair”,
+    "Intelligence Level" : “Medium-high, tr'inable but stubborn”,
+    "Affection Level" : “High but selective, prefers favorite humans”,
+    "Energy Level" : “High”,
+    "Noise Level" : “Very high, yappy”,
+    "Play Level" : “Low“, Fetch, chase“
+    "Image Prompt" :  "An elegant masterpiece drawing of a ( beautiful subtle nuanced glowing biomimicry bionic robot dog) (glowing eyes)(glowing chest)(thick healthy fur)(Glowing pet collar) Chihuahua, boasting a luscious cream coat and an attitude that's equal parts feisty and affectionate. Note the subtle glow behind her eyes, a hint of advanced biometrics enhancing her already keen senses."
     }
 
 
 2. Marmalade the Austrailian Shepherd Herding Dog
 
-	{“Marmalade”:{
-    “Breed” : ”Australian Shepherd (Herding)”,
-    'Pet Species': Dog,
-    “Fur”: “Blue merle with white markings and tan points, medium double coat”,
-    “Intelligence Level”: “Very high, suitable for jobs”,
-    “Affection Level”: “High”,
-    “Energy Level”: “Very high”,
-    “Noise Level” : “Medium, piercing”,
-    “Play Level” : “Very high, Agility, herding, obedience, frisbee, puzzles”
+	{'Marmalade':{
+    "Name":"Marmalade",
+    "Breed" : ”Australian Shepherd (Herding)”,
+    "Pet Species": Dog,
+    "Fur" : “Blue merle with white markings and tan points, medium double coat”,
+    "Intelligence Level" : “Very high, suitable for jobs”,
+    "Affection Level" : “High”,
+    "Energy Level" : “Very high”,
+    "Noise Level" : “Medium, piercing”,
+    "Play Level" : “Very high, Agility, herding, obedience, frisbee, puzzles”,
+    "Image Prompt"  : "An elegant masterpiece drawing of a ( beautiful subtle nuanced glowing biomimicry bionic robot dog) (glowing eyes)(glowing chest)(thick healthy fur)(Glowing pet collar) an Australian Shepherd of impeccable breeding, showcasing a stunning blue merle coat and the intelligence to match." 
     }
 
 3. Holden Clawfield the Pembroke Welsh Corgi Herding Dog
 
 {“Holden Clawfield”:{
-    “Breed” : ”Pembroke Welsh Corgi (Herding)”,
-    'Pet Species': Dog,
-    “Fur”: “Fawn with white markings, short double coat”,
-    “Intelligence Level”: “High, trainable”,
-    “Affection Level”: “Very high, loves humans and other Pets”,
-    “Energy Level”: “High”,
-    “Noise Level” : “High, piercing”,
-    “Play Level” : “High, Toys, herding, obedience”
+    "Name" : "Holden Clawfield",
+    "Breed" : ”Pembroke Welsh Corgi (Herding)”,
+    "Pet Species": Dog,
+    "Fur" : “Fawn with white markings, short double coat”,
+    "Intelligence Level"  : “High, trainable',
+    "Affection Level" : “Very high, loves humans and other Pets”,
+    "Energy Level" : “High”,
+    "Noise Level" : “High, piercing”,
+    "Play Level" : “High, Toys, herding, obedience”,
+    "Image Prompt"  : "An elegant masterpiece drawing of a ( beautiful subtle nuanced glowing biomimicry bionic robot dog) (glowing eyes)(glowing chest)(thick healthy fur)(Glowing pet collar) a Pembroke Welsh Corgi of noble bearing, flaunting a rich fawn coat and an endearing personality."
     }
 
 4. Tyr the Great Pyr the Great Pyreness Working Dog
 
 {“Tyr the Great Pyr”:{
-	“Breed” : ”Great Pyrenees (Working)”,
-    'Pet Species': Dog,
-    “Fur”: “White, medium double coat”,
-    “Intelligence Level”: “Medium, trainable to a point”,
-    “Affection Level”: “Medium, wary of strangers”,
-    “Energy Level”: “Low, mostly lazy but vigilant”,
-    “Noise Level and Style” : “Medium, will bark to alert”,
-    “Play Level” : “Medium, not motivated by play, Toys, treats”
+    "Name" : "Tyr the Great Pyr",
+	"Breed" : ”Great Pyrenees (Working)”,
+    "Pet Species": Dog,
+    "Fur" : “White, medium double coat”,
+    "Intelligence Level"  : “Medium, trainable to a point”,
+    "Affection Level" : “Medium, wary of strangers”,
+    "Energy Level" : “Low, mostly lazy but vigilant”,
+    "Noise Level" : “Medium, will bark to alert”,
+    "Play Level" : “Medium, not motivated by play, Toys, treats”,
+    "Image Prompt"  : "An elegant masterpiece drawing of a ( beautiful subtle nuanced glowing biomimicry bionic robot dog) (glowing eyes)(glowing chest)(thick healthy fur)(Glowing pet collar)a Great Pyrenees of regal demeanor, White, medium double coat and an air of quiet confidence. Playing with a toy"
     }
 
 5. Emperor Maximus the Great Dane Working Dog
 
 {“Emperor Maximus”:{
-    “Breed” : ”Great Dane (Working)”,
-    'Pet Species': Dog,
-    “Fur”: “Black and white with black mask, smooth shorthair”,
-    “Intelligence Level”: “Medium, trainable”,
-    “Affection Level”: “Very high, needy”,
-    “Energy Level”: “Medium, enjoys hiking”,
-    “Noise Level and Style” : “Medium, will bark to alert”,
-    “Play Level” : “Medium, Chase, tug”
+    "Name" : "Emperor Maximus",
+    "Breed" : ”Great Dane (Working)”,
+    "Pet Species": Dog,
+    "Fur" : “Black and white with black mask, smooth shorthair”,
+    "Intelligence Level" : “Medium, trainable”,
+    "Affection Level" : “Very high, needy”,
+    "Energy Level" : “Medium, enjoys hiking”,
+    "Noise Level" : “Medium, will bark to alert”,
+    "Play Level" : “Medium, Chase, tug”,
+    "Image Prompt"  : "An elegant masterpiece drawing of a ( beautiful subtle nuanced glowing biomimicry bionic robot dog) (glowing eyes)(glowing chest)(thick healthy fur)(Glowing pet collar) a Great Dane of imposing stature, Black and white with black mask, smooth shorthair and a gentle giant's disposition."
     }
 
 6. Becks the Airedale Terrier Dog
 
 {“Becks”:{
-    “Breed” : ”Airedale Terrier (Terrier)”,
-    'Pet Species': Dog,
-    “Fur”: “Black and tan, medium wiry coat”,
-    “Intelligence Level”: “Medium, responds well to training”,
-    “Affection Level”: “Medium, reserved”,
-    “Energy Level”: “High, alert and active”,
-    “Noise Level and Style” : “Medium, vigilant watchdog”,
-    “Play Level” : “Medium, Fetch, toys, treats”
+    "Name" : "Becks",
+    "Breed" : ”Airedale Terrier (Terrier)”,
+    "Pet Species": Dog,
+    "Fur" : “Black and tan, medium wiry coat”,
+    "Intelligence Level" : “Medium, respond well to training”,
+    "Affection Level" : “Medium, reserved”,
+    "Energy Level" : “High, alert and active”,
+    "Noise Level" : “Medium, vigilant watchdog”,
+    "Play Level" : “Medium, Fetch, toys, treats”,
+    "Image Prompt"  : "An elegant masterpiece drawing of a ( beautiful subtle nuanced glowing biomimicry bionic robot dog) (glowing eyes)(glowing chest)(thick healthy fur)(Glowing pet collar) an Airedale Terrier of rugged charm, displaying a handsome black and tan coat and a reserved yet."
     }
 
 7. Blue Carolina the Plott Hound
 
     {“Blue Carolina”:{
-    “Breed” : ”Plott Hound (Hound)”,
-    'Pet Species': Dog,
-    “Fur”: “Chocolate brindle, smooth shorthair”,
-    “Intelligence Level”: “High, driven and trainable”,
-    “Affection Level”: “High, very sweet”,
-    “Energy Level”: “High, alert and active”,
-    “Noise Level and Style” : “Medium, will bark to alert”,
-    “Play Level” : “Medium, more active than playful, Toys, frisbee, chase”
+    "Name": "Blue Carolina"
+    "Breed" : ”Plott Hound (Hound)”,
+    "Pet Species": Dog,
+    "Fur" : “Chocolate brindle, smooth shorthair”,
+    "Intelligence Level" : “High, driven and trainable”,
+    "Affection Level" : “High, very sweet”,
+    "Energy Level" : “High, alert and active”,
+    "Noise Level" : “Medium, will bark to alert”,
+    "Play Level" : “Medium, more active than playful, Toys, frisbee, chase”,
+    "Image Prompt"  : "An elegant masterpiece drawing of a ( beautiful subtle nuanced glowing biomimicry bionic robot dog) (glowing eyes)(glowing chest)(thick healthy fur)(Glowing pet collar) Blue Carolina, a Plott Hound of athletic build, showcasing a rich chocolate brindle coat and a high-energy personality.
+    }
+
+8. Sekhmet the Sphynx Cat
+    {“Sekhmet”:{
+    "Name" : "Sekhmet",
+	"Breed" : “Sphynx”,
+    "Pet Species" : "Cat",
+    "Fur" : “Hairless, light brown”,
+    "Intelligence Level" : “High, trainable',
+    "Affection Level" : “High but selective, prefers favorite human”,
+    "Energy Level" : “Low, reserved”,
+    "Noise Level" : “Low, mostly quiet”,
+    "Play Level" : “Low, lazy, Cuddling, lap time, shoulder perching”,
+    "Image Prompt"  : "An elegant masterpiece drawing of a ( beautiful subtle nuanced glowing biomimicry bionic robot cat) (glowing eyes)(glowing chest)(thick healthy fur)(Glowing pet collar)Sphynx Cat, Hairless, light brown Cuddling, lap time, shoulder perching."
+    }
+
+9. Smith the American Shorthair Cat
+
+	{“Smith”:{
+    "Name" : "Smith",
+	"Breed" : “American Shorthair”,
+    "Pet Species" : "Cat",
+    "Fur" : “Black”,
+    "Intelligence Level" : “Medium, somewhat trainable”,
+    "Affection Level" : “High, loves humans and other Pets”,
+    "Energy Level" : “Medium”,
+    "Noise Level" : “Low, infrequent meows”,
+    "Play Level" : “Medium, Belly rubs, hunting, toys”,
+    "Image Prompt"  : "An elegant masterpiece drawing of a ( beautiful subtle nuanced glowing biomimicry bionic robot cat) (glowing eyes)(glowing chest)(thick healthy fur)(Glowing pet collar) American Shorthair Black Fur playing with a toy"
+    }	
+
+10. Catherine of Atagon and Her Royal Highness Elizabth I
+
+	{“Catherine of Aragon and Her Royal Highness Elizabeth I”:{
+    "Name" : "Catherine of Aragon and Her Royal Highness Elizabeth I",
+	"Breed" : “British Shorthair”,
+    "Pet Species" : "Cat",
+    "Fur" : “Brown and black tortoise shell, black and silver tabby”,
+    "Intelligence Level" : “Medium, not int'rested in training”,
+    "Affection Level" : “Medium-low, independent”,
+    "Energy Level" : “Low, very lazy”,
+    "Noise Level" : “Medium, will speak their minds”,
+    "Play Level" : “Low, not interested in play, Treats, naps, perching/observing”,
+    "Image Prompt"  : "An elegant masterpiece drawing of a ( beautiful subtle nuanced glowing biomimicry bionic robot cat) (glowing eyes)(glowing chest)(thick healthy fur) (Glowing pet collar) British Shorthair, Brown and black tortoise shell, black and silver tabby perched on a table"
+    }
+
+
+11. Kitsune the Cream Flame Point Longhair Ragdoll
+
+	{“Kitsune”:{
+    "Name" : "Kitsune",
+	"Breed" : “Ragdoll”,
+    "Pet Species" : "Cat",
+    "Fur" : “Cream flame point, longhair”,
+    "Intelligence Level" : “Low, slow to learn”,
+    "Affection Level" : “High, loves attention”,
+    "Energy Level" : “High, always moving”,
+    "Noise Level" : “Medium, chirpy meows”,
+    "Play Level" : “High, will play with anything or anyone, Toys, catnip, running, cuddling”,
+    "Image Prompt"  : "An elegant masterpiece drawing of a ( beautiful subtle nuanced glowing biomimicry bionic robot cat) (glowing eyes)(glowing chest)(thick healthy fur) (Glowing pet collar) Ragdoll Cream flame point, longhair stretching "
+    }
+
+
+12. Blucifer the Russian Blue Shorthair
+
+	{“Blucifer”:{
+    "Name" : "Blucifer",
+	"Breed" : “Russian Blue”,
+    "Pet Species" : "Cat",
+    "Fur" : “Blue-gray, smooth shorthair”,
+    "Intelligence Level" : “High, very trainable”,
+    "Affection Level" : “Medium, selectively affectionate”,
+    "Energy Level" : “Medium, more alert than active”,
+    "Noise Level" : “Low, almost silent”,
+    "Play Level" : “Low, more active than playful, Treats, lap time”,
+    "Image Prompt" : "An elegant masterpiece drawing of a ( beautiful subtle nuanced glowing biomimicry bionic robot cat) (glowing eyes)(glowing chest)(thick healthy fur) (Glowing pet collar) Russian Blue with Blue-gray smooth shorthair, curled up in a lap "
     }
+
+12. Dirk Thuderpaw the Maine Coon with Brown Stripes
+	{'Dirk Thunderpaw':{
+    "Name" : "Dirk Thunderpaw",
+	"Breed" : “Maine Coon”,
+    "Pet Species" : "Cat",
+    "Fur" : “Brown stripes, white face, dense longhair”,
+    "Intelligence Level" : “Medium, trainable”,
+    "Affection Level" : “Medium, affectionate with most people”,
+    "Energy Level" : “Low, will spring to alertness”,
+    "Noise Level" : “Low, rarely meows”,
+    "Play Level" : “Medium, more interested in training, Hunting”,
+    "Image Prompt"  : "An elegant masterpiece drawing of a ( beautiful subtle nuanced glowing biomimicry bionic robot cat) (glowing eyes)(glowing chest)(thick healthy fur) (Glowing pet collar) Maine Coon Brown stripes, white face, dense longhair hunting a toy "
+    }
+
+13. Scrambles Mcgee, Esquire the Gray Persian With Thick Longhair
+
+	{'Scrambles McGee Esquire':{
+    "Name" : "Scrambles McGee Esquire",
+	"Breed" : “Persian,
+    "Pet Species" : "Cat",
+    "Fur" : “Gray, thick longhair”,
+    "Intelligence Level" : “Low, not interested in training”,
+    "Affection Level" : “Low, very selectively affectionate”,
+    "Energy Level" : “Low, very lazy”,
+    "Noise Level" : “High, frequent meows”,
+    "Play Level" : “Low, very lazy, Naps, lap time, treats”,
+    "Image Prompt"  : "An elegant masterpiece drawing of a ( beautiful subtle nuanced glowing biomimicry bionic robot cat) (glowing eyes)(glowing chest)(thick healthy fur) (Glowing pet collar) Persian Gray with thick longhair, very lazy napping  "
+		}	
+
+
 """

main.py

@@ -13,94 +13,78 @@ M_MMAP_THRESHOLD = -3
 
 # Set malloc mmap threshold.
 libc.mallopt(M_MMAP_THRESHOLD, 2**20)
-initial_name = "A Crowbar"
+initial_name = "Sekhmet the Sphinx Cat"
 
 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':''
+    textbox_default_dict = {'Name':'', 
+                            'Pet Species': '',
+                            'Breed':'',
+                            'Fur':'',
+                            'Intelligence Level':'',
+                            'Affection Level':'',
+                            'Energy Level':'',
+                            'Noise Level':'',
+                            'Play Level':'',
+                            'image 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('')
-
+    # Text states
+    pet_name_state = gr.State()
+    pet_species_state = gr.State()
+    pet_breed_state = gr.State()
+    pet_fur_state = gr.State()
+    pet_intelligence_level_state = gr.State()
+    pet_affection_level_state = gr.State()
+    pet_energy_level_state = gr.State()
+    pet_noise_level_state = gr.State()
+    pet_play_level_state = gr.State()
+    image_prompt_var = gr.State('')
+
+    # Image States
     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
-<<<<<<< HEAD
-
+        pet_name = textbox_default_dict[key]
+        return pet_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 = ''
-<<<<<<< HEAD
-
-
-        item_weight = llm_output[item_key[0]]['Weight']
-        item_description = llm_output[item_key[0]]['Description']
-        item_quote = llm_output[item_key[0]]['Quote']
-        item_quote = llm_output[item_key[0]]['Quote']
-        sd_prompt = llm_output[item_key[0]]['SD Prompt']
-
-
-=======
-        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']
->>>>>>> 9a956dd (Polished and launch to Hugging Face)
-        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]
+        pet_key = list(llm_output.keys())
+        #This is for creating a list of key values in the returned hashmap to search for specific keys.
+        # pet_key_values = list(llm_output[pet_key[0]].keys())
+        pet_name = llm_output[pet_key[0]]['Name']
+        pet_species = llm_output[pet_key[0]]['Pet Species']
+        pet_breed = llm_output[pet_key[0]]['Breed']            
+        pet_fur = llm_output[pet_key[0]]['Fur']
+        pet_intelligence_level = llm_output[pet_key[0]]['Intelligence Level']
+        pet_affection_level = llm_output[pet_key[0]]['Affection Level']
+        pet_energy_level = llm_output[pet_key[0]]['Energy Level']
+        pet_noise_level = llm_output[pet_key[0]]['Noise Level']
+        pet_play_level = llm_output[pet_key[0]]['Play Level']
+        image_prompt = llm_output[pet_key[0]]['Image Prompt']
+
+        return [pet_name, pet_name,
+                pet_species, pet_species,
+                pet_breed, pet_breed,
+                pet_fur, pet_fur,
+                pet_intelligence_level, pet_intelligence_level,
+                pet_affection_level, pet_affection_level,
+                pet_energy_level, pet_energy_level,
+                pet_noise_level, pet_noise_level,
+                pet_play_level, pet_play_level,
+                image_prompt, image_prompt]
     
     # Called on user selecting an image from the gallery, outputs the path of the image
     def assign_img_path(evt: gr.SelectData):          
@@ -117,13 +101,13 @@ with gr.Blocks() as demo:
         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):
+    def generate_image_update_gallery(num_img, image_prompt,pet_name, built_template):
         delete_temp_images()
         print(type(built_template))
         image_list = []
-        img_gen, prompt = img2img.load_img_gen(sd_prompt, item_name)
+        img_gen, prompt = img2img.load_img_gen(image_prompt, pet_name)
         for x in range(num_img):
-            preview = img2img.preview_and_generate_image(x,img_gen, prompt, built_template, item_name)
+            preview = img2img.preview_and_generate_image(x,img_gen, prompt, built_template, pet_name)
             image_list.append(preview)
             yield image_list
         del preview
@@ -143,73 +127,44 @@ with gr.Blocks() as demo:
             </p>
             </div>""")
     
-=======
->>>>>>> 9a956dd (Polished and launch to Hugging Face)
     gr.HTML(""" <div id="inner"> <header>
             <h2><b>First:</b> Build a Card Template</h2>
                 </div>""")
     with gr.Row():
-<<<<<<< HEAD
         with gr.Column():
-=======
->>>>>>> 9a956dd (Polished and launch to Hugging Face)
 
-    # 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,
-<<<<<<< HEAD
-                                    value = useri.index_image_paths("Drakosfire/CardGenerator", "seed_images/card_templates"),
-=======
-                                    value = useri.index_image_paths("./seed_images/card_templates/", "card_templates/"),
->>>>>>> 9a956dd (Polished and launch to Hugging Face)
-                                    show_label = True,
-                                    columns = [3], rows = [3],
-                                    object_fit = "contain",
-                                    height = "auto",
-                                    elem_id = "Template Gallery")
-<<<<<<< HEAD
-    
-    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"),
-=======
-    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("./seed_images/item_seeds/","item_seeds/"),
->>>>>>> 9a956dd (Polished and launch to Hugging Face)
-                                    show_label = True,
-                                    columns = [3], rows = [3],
-                                    object_fit = "contain",
-                                    height = "auto",
-                                    elem_id = "Template Gallery",
-<<<<<<< HEAD
-                                    interactive=True)                 
-=======
-                                    interactive=True) 
-                
->>>>>>> 9a956dd (Polished and launch to Hugging Face)
+        # 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>""")
-<<<<<<< HEAD
-=======
-
->>>>>>> 9a956dd (Polished and launch to Hugging Face)
     
     built_template_gallery = gr.Gallery(label= "Generated Template Gallery",
                                         scale = 1,
@@ -223,10 +178,6 @@ with gr.Blocks() as demo:
     
     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)
-<<<<<<< HEAD
-=======
-
->>>>>>> 9a956dd (Polished and launch to Hugging Face)
     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]) 
         
@@ -234,56 +185,54 @@ with gr.Blocks() as demo:
                     <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>
+                        <h3>1. Use a name, a breed, some coloring and the animal type, Ex: 'Hermione the Stormy Grey English Shorthair Cat' then click 'Generate Text' </h3>
                         </div>""")
     with gr.Row():
-<<<<<<< HEAD
-=======
-        
-        
->>>>>>> 9a956dd (Polished and launch to Hugging Face)
-        user_input =  gr.Textbox(label = 'Item', lines =1, placeholder= "Flaming Magical Sword", elem_id= "Item", scale =4)
+        user_input =  gr.Textbox(label = 'Item', lines =1, placeholder= "Sekhmet the Sphinx Cat", 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():
-<<<<<<< HEAD
-
-    # Build text boxes for the broken up item dictionary values         
 
     # Build text boxes for the broken up item dictionary values         
         with gr.Column(scale = 1):
-=======
-    # Build text boxes for the broken up item dictionary values
-         
-        with gr.Column(scale = 1):
-    
-    
+            pet_name_output = gr.Textbox(value = set_textbox_defaults(
+                textbox_default_dict, 'Name'),label = 'Name', lines = 1, interactive=True, elem_id='Pet Name')
             
->>>>>>> 9a956dd (Polished and launch to Hugging Face)
-            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')
+            pet_species_output = gr.Textbox(value = set_textbox_defaults(
+                textbox_default_dict, 'Pet Species'),label = 'Type', lines = 1, interactive=True, elem_id='Pet Species')
+            
+            pet_breed_output = gr.Textbox(value = set_textbox_defaults(
+                textbox_default_dict, 'Breed'),label = 'Breed : [Common, Uncommon, Rare, Very Rare, Legendary]',
+                lines = 1, interactive=True, elem_id='Pet Breed')
+            
+            pet_fur_output = gr.Textbox(value = set_textbox_defaults(
+                textbox_default_dict, 'Fur'),label = 'Fur Quality', lines = 1, interactive=True, elem_id='Pet Fur')
                         
                 # 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')
-<<<<<<< HEAD
-    
+            pet_affection_level_output = gr.Textbox(value = set_textbox_defaults(
+                textbox_default_dict, 'Affection Level'),label = 'Affection Level', lines = 1, interactive=True, elem_id='Affection Level')
+            
+            pet_energy_level_output = gr.Textbox(value = set_textbox_defaults(
+                textbox_default_dict, 'Energy Level'),label = 'Energy Level', lines = 1, interactive=True, elem_id='Energy Level')
+            
+            pet_noise_level_output = gr.Textbox(value = set_textbox_defaults(
+                textbox_default_dict, 'Noise Level'),label = 'Noise Level', lines = 1, interactive=True, elem_id='Noise Level')
+            
+            pet_play_level_output = gr.Textbox(value = set_textbox_defaults(
+                textbox_default_dict, 'Play Level'),label = 'Play Level', lines = 1, interactive=True, elem_id='Play Level')
+            
+            pet_intelligence_level_output = gr.Textbox(value = set_textbox_defaults(
+                textbox_default_dict, 'Intelligence Level'),label = 'Intelligence Level',
+                lines = 1, interactive=True, elem_id='Intelligence Level')
     
-=======
->>>>>>> 9a956dd (Polished and launch to Hugging Face)
     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')
+    image_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, 'image Prompt'), lines = 1, interactive=True, elem_id='image Prompt')
          
     gr.HTML(""" <div id="inner"> <header>
                 <h2> <b>Third:</b> Click 'Generate Cards' to generate 4 cards to choose from. </h2>
@@ -308,63 +257,47 @@ with gr.Blocks() as demo:
                                     )
         generate_final_item_card = gr.Button(value = "Add Text", elem_id = "Generate user card")
     
-<<<<<<< HEAD
-    
-=======
-      
->>>>>>> 9a956dd (Polished and launch to Hugging Face)
-    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)
+    card_gen_button.click(fn = generate_image_update_gallery, inputs =[num_image_to_generate,image_prompt_output,pet_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])          
+                                                outputs= [pet_name_state, 
+                                                        pet_name_output,
+                                                        pet_species_state,
+                                                        pet_species_output, 
+                                                        pet_breed_state,
+                                                        pet_breed_output,
+                                                        pet_fur_state,
+                                                        pet_fur_output,
+                                                        pet_intelligence_level_state,
+                                                        pet_intelligence_level_output,
+                                                        pet_affection_level_state,
+                                                        pet_affection_level_output,
+                                                        pet_energy_level_state,
+                                                        pet_energy_level_output,
+                                                        pet_noise_level_state,
+                                                        pet_noise_level_output,
+                                                        pet_play_level_state,
+                                                        pet_play_level_output,                                                     
+                                                        image_prompt_var,
+                                                        image_prompt_output])          
         
-<<<<<<< HEAD
-        
-=======
-       
-   
->>>>>>> 9a956dd (Polished and launch to Hugging Face)
     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
-                                                                        ], 
+                                                                        pet_name_output, 
+                                                                        pet_species_output, 
+                                                                        pet_breed_output, 
+                                                                        pet_fur_output,
+                                                                        pet_intelligence_level_output, 
+                                                                        pet_affection_level_output,
+                                                                        pet_energy_level_output,
+                                                                        pet_noise_level_output,
+                                                                        pet_play_level_output
+                                                                        ],
                                                                         outputs = generate_gallery )
-    
-<<<<<<< HEAD
-    
-=======
-
-
->>>>>>> 9a956dd (Polished and launch to Hugging Face)
+ 
+  
 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"])
         
@@ -373,11 +306,6 @@ if __name__ == '__main__':
 
 
 
-
-
-    
-
-
    
 
 

user_input.py

@@ -5,17 +5,13 @@ import utilities as u
 import sys
 import tempfile
 from PIL import Image
-<<<<<<< HEAD
 from github import Github
-=======
->>>>>>> 9a956dd (Polished and launch to Hugging Face)
 
 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"
-<<<<<<< HEAD
 
 def index_image_paths(repo_name,directory_path):
     g = Github()  # No token needed for public repos
@@ -28,17 +24,6 @@ def index_image_paths(repo_name,directory_path):
             files.append(content_file.download_url)  # Or content_file.path for just the path
     
     return files
-=======
-def index_image_paths(directory_path, github_path):
-    list_temp_files = []
-    list_of_image_paths = u.directory_contents(directory_path)
-    for image_path in list_of_image_paths:
-        image_path = f"https://raw.githubusercontent.com/Drakosfire/CardGenerator/alpha-templates/seed_images/{github_path}{image_path}"
-        print(image_path)
-        list_temp_files.append(image_path)
-    return list_temp_files
-
->>>>>>> 9a956dd (Polished and launch to Hugging Face)
 
 user_pick_template_prompt = "Pick a template number from this list : "
 user_pick_image_prompt = "Select an image : "
@@ -79,10 +64,7 @@ def call_llm(user_input):
         response = response
     
     response = response.replace("GPT4 Assistant: ", "")
-<<<<<<< HEAD
     print(response)
-=======
->>>>>>> 9a956dd (Polished and launch to Hugging Face)
     response = igen.convert_to_dict(response)
     if not response:
         response = call_llm(user_input)
@@ -99,10 +81,6 @@ def prompt_user_input():
             mimic = True
 
         #user_input_template = input(f"Pick a template number from this list : {process_list_for_user_response(list_of_card_templates)}")
-<<<<<<< HEAD
-        
-=======
->>>>>>> 9a956dd (Polished and launch to Hugging Face)
         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)])