"""

def __init__(self):

self.cache: dict[str, tuple[list[str], dict[str, float], float]] = {}

self.active = False

def get(self, key: str, default=None) -> tuple[list[str], dict[str, float], float]:

if not self.active:

return default

return self.cache.get(key, default)

def set(self, key: str, value: tuple[list[str], dict[str, float], float]) -> None:

if self.active:

self.cache[key] = value

def clear(self):

self.cache.clear()

def __enter__(self):

self.active = True

return self

def __exit__(self, exc_type, exc_value, traceback):

self.active = False

"""

if not name or not isinstance(name, str):

raise ValueError("System user name cannot be empty")

if not name.replace("_", "").isalnum():

raise ValueError(f"Invalid system user name: '{name}'")

if name.startswith("_"):

raise ValueError("System user name should not start with underscore")

"""

if not user_id or not isinstance(user_id, str):

return None

if user_id.startswith(SYSTEM_USER_PREFIX):

return None

if type_name == "output":

return get_output_directory()

if type_name == "temp":

return get_temp_directory()

if type_name == "input":

return get_input_directory()

"""

global extension_mimetypes_cache

result = []

for file in files:

extension = file.split('.')[-1]

if extension not in extension_mimetypes_cache:

mime_type, _ = mimetypes.guess_type(file, strict=False)

if not mime_type:

continue

content_type = mime_type.split('/')[0]

extension_mimetypes_cache[extension] = content_type

else:

content_type = extension_mimetypes_cache[extension]

if content_type in content_types:

result.append(file)

if name.endswith("[output]"):

base_dir = get_output_directory()

name = name[:-9]

elif name.endswith("[input]"):

base_dir = get_input_directory()

name = name[:-8]

elif name.endswith("[temp]"):

base_dir = get_temp_directory()

name = name[:-7]

else:

return name, None

'text/html', 'text/html-sandboxed', 'application/xhtml+xml',

'text/javascript', 'application/javascript', 'application/x-javascript',

'application/ecmascript', 'text/css',

'image/svg+xml', 'application/xml', 'text/xml',

# message/rfc822 (.mht/.mhtml) can carry script in some browsers.

'message/rfc822',

"""Return True if a browser may execute or render `content_type` inline.

if not content_type:

return False

normalized = content_type.split(';', 1)[0].strip().lower()

if normalized in DANGEROUS_CONTENT_TYPES:

return True

"""Return True if a dangerous `content_type` is safe to serve inline anyway.

if sec_fetch_dest != 'image':

return False

"""Return True if `target` resolves to a path inside `directory`.

try:

directory = os.path.realpath(directory)

target = os.path.realpath(target)

return os.path.commonpath((directory, target)) == directory

except ValueError:

# ValueError is raised by realpath() on a path with an embedded null

# byte, and by commonpath() on Windows when the paths are on different

# drives. In either case the target is not safely within the directory.

name, base_dir = annotated_filepath(name)

if base_dir is None:

if default_dir is not None:

base_dir = default_dir

else:

base_dir = get_input_directory() # fallback path

filepath = os.path.abspath(os.path.join(base_dir, name))

# Prevent path traversal: the resolved path must stay within base_dir.

# repr() the name in the message so a crafted value can't inject log lines.

if not is_within_directory(base_dir, filepath):

raise ValueError("Invalid file path: {!r}".format(name))

name, base_dir = annotated_filepath(name)

if base_dir is None:

base_dir = get_input_directory() # fallback path

filepath = os.path.abspath(os.path.join(base_dir, name))

# Treat traversal attempts as non-existent rather than probing the filesystem.

if not is_within_directory(base_dir, filepath):

return False

global folder_names_and_paths

folder_name = map_legacy(folder_name)

if folder_name in folder_names_and_paths:

paths, _exts = folder_names_and_paths[folder_name]

if full_folder_path in paths:

if is_default and paths[0] != full_folder_path:

# If the path to the folder is not the first in the list, move it to the beginning.

paths.remove(full_folder_path)

paths.insert(0, full_folder_path)

else:

if is_default:

paths.insert(0, full_folder_path)

else:

paths.append(full_folder_path)

else:

if not os.path.isdir(directory):

return [], {}

if excluded_dir_names is None:

excluded_dir_names = []

result = []

dirs = {}

# Attempt to add the initial directory to dirs with error handling

try:

dirs[directory] = os.path.getmtime(directory)

except FileNotFoundError:

logging.warning(f"Warning: Unable to access {directory}. Skipping this path.")

logging.debug("recursive file list on directory {}".format(directory))

dirpath: str

subdirs: list[str]

filenames: list[str]

for dirpath, subdirs, filenames in os.walk(directory, followlinks=True, topdown=True):

subdirs[:] = [d for d in subdirs if d not in excluded_dir_names]

for file_name in filenames:

try:

relative_path = os.path.relpath(os.path.join(dirpath, file_name), directory)

result.append(relative_path)

except:

logging.warning(f"Warning: Unable to access {file_name}. Skipping this file.")

continue

for d in subdirs:

path: str = os.path.join(dirpath, d)

try:

dirs[path] = os.path.getmtime(path)

except FileNotFoundError:

logging.warning(f"Warning: Unable to access {path}. Skipping this path.")

continue

logging.debug("found {} files".format(len(result)))

"""

global folder_names_and_paths

folder_name = map_legacy(folder_name)

if folder_name not in folder_names_and_paths:

return None

folders = folder_names_and_paths[folder_name]

filename = os.path.relpath(os.path.join("/", filename), "/")

for x in folders[0]:

full_path = os.path.join(x, filename)

if os.path.isfile(full_path):

return full_path

elif os.path.islink(full_path):

logging.warning("WARNING path {} exists but doesn't link anywhere, skipping.".format(full_path))

"""

full_path = get_full_path(folder_name, filename)

if full_path is None:

raise FileNotFoundError(f"Model in folder '{folder_name}' with filename '{filename}' not found.")

folder_name = map_legacy(folder_name)

global folder_names_and_paths

output_list = set()

folders = folder_names_and_paths[folder_name]

output_folders = {}

for x in folders[0]:

files, folders_all = recursive_search(x, excluded_dir_names=[".git"])

output_list.update(filter_files_extensions(files, folders[1]))

output_folders = {**output_folders, **folders_all}

strong_cache = cache_helper.get(folder_name)

if strong_cache is not None:

return strong_cache

global filename_list_cache

global folder_names_and_paths

folder_name = map_legacy(folder_name)

if folder_name not in filename_list_cache:

return None

out = filename_list_cache[folder_name]

for x in out[1]:

time_modified = out[1][x]

folder = x

if os.path.getmtime(folder) != time_modified:

return None

folders = folder_names_and_paths[folder_name]

for x in folders[0]:

if os.path.isdir(x):

if x not in out[1]:

return None

folder_name = map_legacy(folder_name)

out = cached_filename_list_(folder_name)

if out is None:

out = get_filename_list_(folder_name)

global filename_list_cache

filename_list_cache[folder_name] = out

cache_helper.set(folder_name, out)

def map_filename(filename: str) -> tuple[int, str]:

prefix_len = len(os.path.basename(filename_prefix))

prefix = filename[:prefix_len + 1]

try:

remainder = filename[prefix_len + 1:]

base_remainder = remainder.split('.')[0]

digits = int(base_remainder.split('_')[0])

except:

digits = 0

return digits, prefix

def compute_vars(input: str, image_width: int, image_height: int) -> str:

input = input.replace("%width%", str(image_width))

input = input.replace("%height%", str(image_height))

now = time.localtime()

input = input.replace("%year%", str(now.tm_year))

input = input.replace("%month%", str(now.tm_mon).zfill(2))

input = input.replace("%day%", str(now.tm_mday).zfill(2))

input = input.replace("%hour%", str(now.tm_hour).zfill(2))

input = input.replace("%minute%", str(now.tm_min).zfill(2))

input = input.replace("%second%", str(now.tm_sec).zfill(2))

return input

if "%" in filename_prefix:

filename_prefix = compute_vars(filename_prefix, image_width, image_height)

subfolder = os.path.dirname(os.path.normpath(filename_prefix))

filename = os.path.basename(os.path.normpath(filename_prefix))

full_output_folder = os.path.join(output_dir, subfolder)

if not is_within_directory(output_dir, full_output_folder):

err = "**** ERROR: Saving image outside the output folder is not allowed." + \

"\n full_output_folder: " + os.path.abspath(full_output_folder) + \

"\n output_dir: " + output_dir

logging.error(err)

raise Exception(err)

try:

counter = max(filter(lambda a: os.path.normcase(a[1][:-1]) == os.path.normcase(filename) and a[1][-1] == "_", map(map_filename, os.listdir(full_output_folder))))[0] + 1

except ValueError:

counter = 1

except FileNotFoundError:

os.makedirs(full_output_folder, exist_ok=True)

counter = 1

"""Returns a list of all subfolder paths in the input directory, recursively.

input_dir = get_input_directory()

folders = []

try:

if not os.path.exists(input_dir):

return []

for root, dirs, _ in os.walk(input_dir):

rel_path = os.path.relpath(root, input_dir)

if rel_path != ".": # Only include non-root directories

# Normalize path separators to forward slashes

folders.append(rel_path.replace(os.sep, '/'))

return sorted(folders)

except FileNotFoundError: