Upload 15 files

.gitattributes

@@ -106,3 +106,4 @@ Danbooru[[:space:]]Prompt[[:space:]]Selector/csv2023_explicit.csv filter=lfs dif
 Danbooru[[:space:]]Prompt[[:space:]]Selector/csv2023_nsfw.csv filter=lfs diff=lfs merge=lfs -text
 Danbooru[[:space:]]Prompt[[:space:]]Selector/csv2023_safeimage.csv filter=lfs diff=lfs merge=lfs -text
 Danbooru[[:space:]]Prompt[[:space:]]Selector/csv2023_sensitive.csv filter=lfs diff=lfs merge=lfs -text
+Danbooru[[:space:]]Prompt[[:space:]]Selector/TEST2024/NAIA_1231_console_testv1.exe filter=lfs diff=lfs merge=lfs -text

Danbooru Prompt Selector/TEST2024/NAIA_1231_console_testv1.exe

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ba5622ba32c6c8c7cf4123933bfa4ea9bb68c05b6d722feb95ae2f40dd089a5f
+size 837859752

Danbooru Prompt Selector/TEST2024/NAIA_Login.py

@@ -0,0 +1,32 @@
+from base64 import urlsafe_b64encode
+from hashlib import blake2b
+import argon2
+import requests
+
+BASE_URL="https://api.novelai.net"
+
+def argon_hash(email: str, password: str, size: int, domain: str) -> str:
+    pre_salt = f"{password[:6]}{email}{domain}"
+    # salt
+    blake = blake2b(digest_size=16)
+    blake.update(pre_salt.encode())
+    salt = blake.digest()
+    raw = argon2.low_level.hash_secret_raw(
+        password.encode(),
+        salt,
+        2,
+        int(2000000 / 1024),
+        1,
+        size,
+        argon2.low_level.Type.ID,
+    )
+    hashed = urlsafe_b64encode(raw).decode()
+    return hashed
+
+def login(key) -> str:
+    response = requests.post(f"{BASE_URL}/user/login", json={ "key": key })
+    # catch any errors
+    return response.json()["accessToken"]
+
+def get_access_key(email: str, password: str) -> str:
+    return argon_hash(email, password, 64, "novelai_data_access_key")[:64]

Danbooru Prompt Selector/TEST2024/NAIA_generation.py

@@ -0,0 +1,260 @@
+import requests
+import random
+from PIL import Image, ImageOps, ImageTk
+from datetime import datetime
+import time
+from pathlib import Path
+import io
+import zipfile
+
+BASE_URL="https://api.novelai.net"
+
+def make_turbo_prompt(gen_request):
+    lines = gen_request['prompt']
+    result = {
+        "boys": False,
+        "girls": False,
+        "1girl": False,
+        "1boy": False,
+        "1other": False,
+        "others": False
+    }
+    state = {
+        "nude,": False,
+        "pov,": False,
+        "cum,": False,
+        "after ": False,
+        "pussy juice": False,
+        "barefoot": False,
+        "breasts": False,
+        "ejaculation": False,
+    }
+
+    def insert_spaces(source_list, reference_list):
+            modified_list = source_list.copy()
+            for index, keyword in enumerate(reference_list):
+                if keyword not in source_list:
+                    space_count = len(keyword)  # 키워드 길이만큼의 공백 문자
+                    modified_list.insert(index, ' ' * space_count)
+            return modified_list
+
+    keywords = gen_request['prompt'].split(', ')
+    filtered_keywords = []
+    removed_indices = []
+    positive0, positive1, positive2, positive3 = gen_request.copy(),gen_request.copy(),gen_request.copy(),gen_request.copy()
+
+    for word in result.keys():
+        if word in lines:
+            result[word] = True
+    for word in state.keys():
+        if word in gen_request['prompt']:
+            state[word] = True
+
+    key_index = int((len(keywords)/2)-1)
+
+    if(result["1boy"]) or (result["boys"]):
+            if(result["1girl"]):
+                if('sex,' in gen_request['prompt']):
+                    sex_pos_keywords  = ['stomach bulge','insertion', 'fucked silly', 'x-ray', 'orgasm', 'cross-section', 'uterus', 'overflow', 'rape', 'vaginal', 'anal']
+                    facial_keywords = ['tongue','ahegao']
+                    temp_sex_pos = []
+                    temp_facial = []
+                    cum_events = []
+                    explicit_check = []
+                    if 'open mouth' in keywords: keywords.remove('open mouth')
+                    if 'closed mouth' in keywords: keywords.remove('closed mouth')
+                    if 'after rape' in keywords: 
+                        keywords.remove('after rape')
+                        explicit_check.append('after rape')
+                    for keyword in keywords:
+                            if ('sex' not in keyword and 'cum' not in keyword and 'ejaculation' not in keyword and 'vaginal' not in keyword and 'penetration' not in keyword) and all(sex_pos not in keyword for sex_pos in sex_pos_keywords) and all(facial not in keyword for facial in facial_keywords):
+                                filtered_keywords.append(keyword)
+                            elif 'sex' in keyword:
+                                removed_indices.append(keyword)
+                            elif 'penetration' in keyword:
+                                removed_indices.append(keyword)
+                            elif 'cum' in keyword and keyword != 'cum':
+                                cum_events.append(keyword)
+                            elif any(sex_pos in keyword for sex_pos in sex_pos_keywords):
+                                for sex_pos in sex_pos_keywords:
+                                    if sex_pos in keyword:
+                                        temp_sex_pos.append(sex_pos)
+                            elif any(facial not in keyword for facial in facial_keywords):
+                                for facial in facial_keywords:
+                                    if facial in keyword:
+                                        temp_facial.append(facial)
+                    filtered_keywords.insert(int((len(filtered_keywords)/2)-1), ' no penetration, imminent penetration')
+                    filtered_keywords_positive0 = filtered_keywords.copy()
+                    filtered_keywords.remove(' no penetration, imminent penetration')
+                    #0 imminent penetration, imminent sex
+                    for i, keyword in enumerate(filtered_keywords):
+                        if 'pantyhose' in keyword:
+                            filtered_keywords[i] = 'torn ' + filtered_keywords[i]
+                    #1 default
+                    key_index = int((len(filtered_keywords)/2)-1)
+                    if 'pussy' in filtered_keywords: key_index = filtered_keywords.index('pussy')
+                    if 'penis' in filtered_keywords: key_index = filtered_keywords.index('penis')
+                    filtered_keywords[key_index:key_index] = ['motion lines', 'surprised']
+                    for keyword in removed_indices:
+                        if 'cum' not in keyword and 'ejaculation' not in keyword:
+                            filtered_keywords.insert(key_index,keyword)
+                    if(temp_sex_pos): filtered_keywords[key_index:key_index] = temp_sex_pos
+                    if('clothed sex' in filtered_keywords and not 'bottomless' in filtered_keywords): filtered_keywords.insert(filtered_keywords.index('clothed sex')+1, 'bottomless')
+                    pos1_copied_keywords = filtered_keywords.copy()
+                    for i, keyword in enumerate(pos1_copied_keywords):
+                        if 'closed eyes' in keyword:
+                            rand_num = random.randint(0,2)
+                            if(rand_num == 0): pos1_copied_keywords[i] = 'half-' + pos1_copied_keywords[i]
+                            elif(rand_num == 1 and 'closed eyes' in pos1_copied_keywords): 
+                                pos1_copied_keywords.remove('closed eyes')
+                                filtered_keywords[i] = 'half-closed eyes'
+                    filtered_keywords_positive1 = pos1_copied_keywords.copy()
+                    #2 ejaculation,cum in pussy
+                    key_index = filtered_keywords.index('surprised')
+                    filtered_keywords.remove('surprised')
+                    filtered_keywords[key_index:key_index] = ["ejaculation","cum"]
+                    for keyword in removed_indices:
+                        if 'cum' in keyword:
+                            filtered_keywords.insert(key_index,keyword)
+                    if(temp_facial): filtered_keywords[key_index:key_index] =temp_facial
+                    filtered_keywords_positive2 = filtered_keywords.copy()
+                    #3 after sex, after ejaculation
+                    for i, keyword in enumerate(filtered_keywords):
+                        if 'closed eyes' in keyword:
+                            rand_num = random.randint(0,2)
+                            if(rand_num == 0 and  filtered_keywords[i] != 'half-closed eyes'): filtered_keywords[i] = 'half-' + filtered_keywords[i]
+                            elif(rand_num == 1): filtered_keywords[i] = 'empty eyes'
+                            else: filtered_keywords[i] = 'empty eyes, half-closed eyes'
+                    if 'sex' in filtered_keywords:
+                        key_index = filtered_keywords.index('sex')
+                    elif 'group sex' in filtered_keywords:
+                        key_index = filtered_keywords.index('group sex')
+                    filtered_keywords.remove('ejaculation')
+                    filtered_keywords[key_index:key_index] = ['cum drip', 'erection'] + cum_events
+                    if(explicit_check): filtered_keywords[key_index:key_index] = explicit_check
+                    if 'sex' in filtered_keywords and 'group sex' not in filtered_keywords:
+                        if('pussy' in filtered_keywords and not 'anal' in filtered_keywords): filtered_keywords.insert(filtered_keywords.index('sex')+1, 'after vaginal, spread pussy')
+                        elif('anal' in filtered_keywords): filtered_keywords.insert(filtered_keywords.index('sex')+1, 'after anus, cum in ass')
+                        filtered_keywords.insert(filtered_keywords.index('sex'), 'after sex')
+                        filtered_keywords.remove('sex')
+                    elif 'group sex' in filtered_keywords:
+                        if('vaginal' in filtered_keywords and not 'anal' in filtered_keywords): 
+                            filtered_keywords.insert(filtered_keywords.index('group sex')+1, 'after vaginal, spread pussy')
+                            if 'multiple penises' in filtered_keywords: filtered_keywords.insert(filtered_keywords.index('group sex')+3, 'cum on body, bukkake')
+                        elif('anal' in filtered_keywords): 
+                            filtered_keywords.insert(filtered_keywords.index('group sex')+1, 'after anus, cum in ass')
+                            if 'multiple penises' in filtered_keywords: filtered_keywords.insert(filtered_keywords.index('group sex')+3, 'cum on body, bukkake')
+                        else: filtered_keywords.insert(filtered_keywords.index('group sex')+1, 'cum on body, {bukkake}')
+                    temp_post_keyword = []
+                    for keyword in sex_pos_keywords:
+                        if not (keyword == 'orgasm' or keyword == 'overflow'):
+                            if keyword in filtered_keywords:
+                                temp_post_keyword.append(keyword)
+                    for keyword in temp_post_keyword:
+                        filtered_keywords.remove(keyword)
+
+                    positive0['prompt'] = ', '.join(insert_spaces(filtered_keywords_positive0, filtered_keywords)).strip()
+                    positive1['prompt'] = ', '.join(insert_spaces(filtered_keywords_positive1, filtered_keywords)).strip()
+                    positive2['prompt'] = ', '.join(insert_spaces(filtered_keywords_positive2, filtered_keywords)).strip()
+                    positive3['prompt'] = ', '.join(filtered_keywords).strip()
+                    positive0["type"] = "turbo"
+                    positive1["type"] = "turbo"
+                    positive2["type"] = "turbo"
+                    positive3["type"] = "turbo"
+    return positive0, positive1, positive2, positive3
+
+def generate_image(access_token, prompt, model, action, parameters):
+    data = {
+        "input": prompt,
+        "model": model,
+        "action": action,
+        "parameters": parameters,
+    }
+
+    response = requests.post(f"{BASE_URL}/ai/generate-image", json=data, headers={ "Authorization": f"Bearer {access_token}" })
+    # catch any errors
+    return response.content
+
+def generate(gen_request):
+
+    params = {
+        "legacy": False,
+        "quality_toggle": True if gen_request["quality_toggle"] == 1 else False,
+        "width": gen_request["width"],
+        "height": gen_request["height"],
+        "n_samples": 1,
+        "seed": gen_request["seed"],
+        "extra_noise_seed": random.randint(0,9999999999),
+        "sampler": gen_request["sampler"],
+        "steps": 28,
+        "scale": gen_request["scale"],
+        "uncond_scale": 1.0,
+        "negative_prompt": gen_request["negative"],
+        "sm" : gen_request["sema"],
+        "sm_dyn" : gen_request["sema_dyn"],
+        "decrisper": False,
+        "controlnet_strength": 1.0,
+        "add_original_image": False,
+        "cfg_rescale": gen_request["cfg_rescale"],
+        "noise_schedule": "native"
+        }
+    
+    # 와일드카드 기능 만들어야함
+    positive = gen_request["prompt"]
+
+    filename_rule = gen_request["png_rule"]
+    save_folder = gen_request["save_folder"]
+
+    access_token = gen_request["access_token"]
+    additional_folder = ""
+
+    def resize_and_fill(image, max_size=None):
+        if max_size is None:
+            max_size = gen_request["user_screen_size"]
+        original_width, original_height = image.size
+        if original_width > max_size or original_height > max_size:
+            # 비율을 유지하면서 크기 조정
+            image.thumbnail((max_size, max_size))
+
+            # 새 이미지 크기 계산
+            width, height = image.size
+            new_image = Image.new("RGB", (max_size, max_size), "black")
+            new_image.paste(image, ((max_size - width) // 2, (max_size - height) // 2))
+            return new_image
+        else:
+            return image
+
+    def log_error(e, output_file_path="output_file_path"):
+        # 현재 시간을 얻습니다
+        current_time = datetime.now().strftime("%m/%d %H:%M:%S")
+
+        # 에러 로그 메시지
+        error_message = f"#### Error occured at {current_time} ####\nError: {e}\n############################################\n"
+
+        # 지정된 출력 폴더의 error_log.txt 파일에 쓰기
+        with open(f"error_log.txt", "a") as file:
+            file.write(error_message)
+
+    try:
+        zipped_bytes = generate_image(access_token, positive, "nai-diffusion-3", "generate", params)
+        if gen_request["png_rule"] == "count":
+            additional_folder = "/" + gen_request["start_time"]
+        if gen_request["type"] == "turbo":
+            additional_folder += "/turbo"
+        d = Path(save_folder + additional_folder)
+        d.mkdir(parents=True, exist_ok=True)
+        zipped = zipfile.ZipFile(io.BytesIO(zipped_bytes))
+        image_bytes = zipped.read(zipped.infolist()[0])
+        if gen_request["png_rule"] == "count": 
+            _count = gen_request["count"]
+            filename = (d / f"{_count:05}.png" )
+        else: filename = (d / f"{datetime.now().strftime('%Y%m%d_%H%M%S')}.png" )
+        filename.write_bytes(image_bytes)
+        i = Image.open(io.BytesIO(image_bytes))
+        i = ImageOps.exif_transpose(i).convert("RGB")
+        i_resized = resize_and_fill(i)
+        #tk_image = ImageTk.PhotoImage(i_resized)
+        return i_resized, positive, params['seed'], i.info, str(filename)
+    except Exception as e:
+        log_error(zipped_bytes.decode('utf-8')[2:-2], "path_to_output_folder")
+        return None, zipped_bytes.decode('utf-8')[2:-2], params['seed'], None, None

Danbooru Prompt Selector/TEST2024/NAIA_random_function_core.py

@@ -0,0 +1,70 @@
+import pandas
+import numpy as np
+
+def find_keyword_index(general):
+    # boys와 girls 리스트의 원소가 있는지 확인 및 인덱스 저장
+    boys = ["1boy", "2boys", "3boys", "4boys", "5boys", "6+boys"]
+    girls = ["1girl", "2girls", "3girls", "4girls", "5girls", "6+girls"]
+    #others = ["1other", "2others", "3others", "4others", "5others", "6+others"]
+    boys_indices = [i for i, item in enumerate(general[:6]) if item in boys]
+    girls_indices = [i for i, item in enumerate(general[:6]) if item in girls]
+
+    # case 1과 case 2: girls 리스트의 원소 찾기
+    if girls_indices:
+        return girls_indices[0]+1
+    
+    # case 3: boys 리스트의 원소 찾기
+    if boys_indices:
+        return boys_indices[0]+1
+
+    # case 4: 해당 사항 없음
+    return 2
+
+def RFP(popped_row, fix_prompt, after_prompt, auto_hide_prompt, rm_a, rm_s, rm_c, nsfw, data, magic_word):
+    boys = ["1boy", "2boys", "3boys", "4boys", "5boys", "6+boys"]
+    girls = ["1girl", "2girls", "3girls", "4girls", "5girls", "6+girls"]
+    general = [item.strip() for item in popped_row['general'].split(',')]
+    if nsfw == 1:
+        nsfw_word = []
+        for keyword in general:
+            if keyword in data.qe_word or keyword in data.bag_of_tags or "horns" in keyword or "(" in keyword or keyword in boys or keyword in girls:
+                nsfw_word.append(keyword)
+        general = nsfw_word
+    if rm_c == 1:
+        temp_general = []
+        for keyword in general:
+            if keyword in data.bag_of_tags:
+                temp_general.append(keyword)
+        for keyword in temp_general:
+            general.remove(keyword)
+    fix = [item.strip() for item in fix_prompt[:-1].split(',')]
+    if rm_s == 0:
+        series = [item.strip() for item in popped_row['copyright'].split(',')]
+        fix = fix + series
+    after = [item.strip() for item in after_prompt[:-1].split(',')]
+    auto_hide = [item.strip() for item in auto_hide_prompt[:-1].split(',')]
+    fix_index = find_keyword_index(general)
+    processed = general.copy()
+    temp_hide_prompt = []
+    processed[fix_index:fix_index] = fix
+    processed += after
+    for keyword in processed:
+        if keyword in auto_hide:
+            temp_hide_prompt.append(keyword)
+    for keyword in temp_hide_prompt:
+        processed.remove(keyword)
+
+    if rm_c == 0:
+        if popped_row['character']:
+            character = [item.strip() for item in popped_row['character'].split(',')]
+            processed[fix_index:fix_index] = character
+            fix_index+=len(character)
+    if rm_a == 0:
+        if popped_row['artist']:
+            artists = [item.strip() for item in popped_row['artist'].split(',')]
+            artist = ["artist:" + _artist for _artist in artists]
+            processed[fix_index:fix_index] = artist
+    if magic_word["random_artist"] == True:
+        processed.insert(fix_index, magic_word["random_artist_name"])
+        
+    return ', '.join(processed)

Danbooru Prompt Selector/TEST2024/NAIA_search.py

@@ -0,0 +1,158 @@
+import customtkinter
+import pandas as pd
+
+# 모든 키워드를 포함하는 행만 필터링하는 함수
+def filter_rows_containing_all_keywords(df, keywords):
+    # 모든 키워드에 대한 boolean mask 초기화, df의 인덱스를 사용
+    final_mask = pd.Series([True] * len(df), index=df.index)
+
+    # 각 키워드에 대해 DataFrame의 모든 열을 검사하고 boolean mask 생성 및 저장
+    for keyword in keywords:
+        keyword_mask = pd.Series([False] * len(df), index=df.index)
+
+        for column in ['copyright', 'character', 'artist', 'meta', 'general']:
+            if df[column].dtype == 'object':
+                keyword_mask |= df[column].str.contains(keyword, na=False)
+
+        final_mask &= keyword_mask
+
+    return df[final_mask]
+
+def filter_rows_not_containing_all_keywords(df, keywords):
+    # 모든 키워드를 포함하지 않는 행을 필터링하기 위한 boolean mask 초기화, df의 인덱스를 사용
+    final_mask = pd.Series([True] * len(df), index=df.index)
+
+    # 각 키워드에 대해 DataFrame의 모든 열을 검사하고 boolean mask 생성 및 저장
+    for keyword in keywords:
+        keyword_mask = pd.Series([False] * len(df), index=df.index)
+
+        for column in ['copyright', 'character', 'artist', 'meta', 'general']:
+            if df[column].dtype == 'object':
+                keyword_mask |= df[column].str.contains(keyword, na=False)
+
+        # 모든 키워드를 포함하는 행에 대한 mask를 반전시켜 final_mask에 저장
+        final_mask &= ~keyword_mask
+
+    return df[final_mask]
+
+def process_asterisk_group(df, asterisk_group):
+    # 각 키워드 앞의 '*'를 제거하고 맨 뒤에 ',' 추가
+    asterisk_keywords = [keyword.lstrip('*') + ',' for keyword in asterisk_group]
+
+    # 각 행에 대해 임시 문자열 search_string을 만들고 검색 수행
+    df['search_string'] = df[['copyright', 'character', 'artist', 'meta', 'general']].apply(lambda x: ' ' + ', '.join(x.astype(str)) + ',', axis=1)
+    for keyword in asterisk_keywords:
+        df = df[df['search_string'].str.contains(keyword, na=False)]
+    df.drop('search_string', axis=1, inplace=True)
+
+    return df
+
+def process_perfect_negative_group(df, perfect_negative_group):
+    # 각 키워드 앞의 '~'를 제거하고 맨 뒤에 ',' 추가
+    perfect_negative_keywords = [keyword.lstrip('~') + ',' for keyword in perfect_negative_group]
+
+    # 각 행에 대해 임시 문자열 search_string을 만듦
+    df['search_string'] = df[['copyright', 'character', 'artist', 'meta', 'general']].apply(lambda x: ' ' + ', '.join(x.astype(str)) + ',', axis=1)
+
+    # 모든 키워드에 대한 검색 결과를 하나의 boolean Series로 결합
+    combined_mask = pd.Series([True] * len(df), index=df.index)
+    for keyword in perfect_negative_keywords:
+        keyword_mask = df['search_string'].str.contains(keyword, na=False)
+        combined_mask &= ~keyword_mask
+
+    # 최종적으로 일치하지 않는 행만 필터링
+    df = df[combined_mask]
+
+    # search_string 열 제거
+    df.drop('search_string', axis=1, inplace=True)
+
+    return df
+
+def search(df, search_request, exclude_request, E, N, S, G):
+    if(E == 0):
+        df = df[~(df['rating'] == 'e')]
+    if(N == 0):
+        df = df[~(df['rating'] == 'q')]
+    if(S == 0):
+        df = df[~(df['rating'] == 's')]
+    if(G == 0):
+        df = df[~(df['rating'] == 'g')]
+    if(len(df) == 0):
+        return None
+    
+    #search_request에 대한 처리
+    #처리순서 normal -> curly -> asterisk
+    split_requests = [item.strip() for item in search_request.split(',')]
+
+    curly_brace_group = [item for item in split_requests if item.startswith('{') and item.endswith('}')]
+    asterisk_group = [item for item in split_requests if item.startswith('*')]
+    normal_group = [item for item in split_requests if item not in curly_brace_group + asterisk_group]
+
+    negative_split_requests = [item.strip() for item in exclude_request.split(',')]
+    perfect_negative_group = [item for item in negative_split_requests if item.startswith('~')]
+    negative_group = [item for item in negative_split_requests if item not in perfect_negative_group]
+
+    if '' in split_requests:
+        split_requests.remove('')
+    if '' in negative_split_requests:
+        negative_split_requests.remove('')
+
+    #포지티브
+    if split_requests:
+        #normal 처리
+        if normal_group:
+            df = filter_rows_containing_all_keywords(df, normal_group)
+            if(len(df) == 0):
+                return None
+
+        #OR 처리
+        if curly_brace_group:
+            for keyword in curly_brace_group:
+                or_search_keyword = [item.strip() for item in keyword[1:-1].split('|')]
+                results = pd.DataFrame()
+                for keyword in or_search_keyword:
+                    if keyword.startswith('*'):
+                        keyword = keyword[1:]
+                    for column in ['copyright', 'character', 'artist', 'meta', 'general']:
+                        matched_rows = df[df[column].str.contains(keyword, na=False)]
+                        if not matched_rows.empty:
+                            results = pd.concat([results, matched_rows])
+                            break
+                del[[df]]
+                df = results.copy()
+                del[[results]]
+            if(len(df) == 0):
+                return None
+        
+        #Perfect Matching 처리
+        if asterisk_group:
+            df = process_asterisk_group(df,asterisk_group)
+            if(len(df) == 0):
+                return None
+    
+    #Exclude 처리
+    if negative_split_requests:
+        if negative_group:
+            df = filter_rows_not_containing_all_keywords(df, negative_group)
+            if(len(df) == 0):
+                return None
+        
+        if perfect_negative_group:
+            df = process_perfect_negative_group(df, perfect_negative_group)
+            if(len(df) == 0):
+                return None
+    return df
+    
+
+
+
+
+
+
+
+
+
+
+
+
+