sssnake/dark_hal
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

first commit

Browse Source
This commit is contained in:
DigiJ
2026-03-13 12:56:43 -07:00
commit 159cf9fcfe
309 changed files with 64584 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

867
settings_manager.py Normal file
View File

@@ -0,0 +1,867 @@
import json
import os
from pathlib import Path
from typing import Dict, Any, Optional
import tkinter as tk
from tkinter import ttk, messagebox, filedialog
class SettingsManager:
"""Manages application settings with JSON persistence."""
def __init__(self, settings_file: str = "settings.json"):
self.settings_file = settings_file
self.default_settings = {
"api": {
"huggingface_token": "",
"use_env_token": True,
"use_organization": False,
"organization": ""
},
"paths": {
"models_directory": "./models",
"downloads_directory": "./downloads",
"last_model_path": "",
"last_lora_path": ""
},
"model_settings": {
"default_n_ctx": 4096,
"default_n_gpu_layers": 0,
"default_max_tokens": 256,
"stream_by_default": True,
"temperature": 0.7,
"top_p": 0.9,
"repetition_penalty": 1.1,
"no_repeat_ngram_size": 0,
"min_p": 0.0,
"typical_p": 1.0
},
"search_preferences": {
"default_search_type": "Models",
"default_sort": "downloads",
"search_limit": 50,
"auto_filter_gguf": True
},
"ui_preferences": {
"window_width": 1200,
"window_height": 700,
"theme": "default",
"show_tooltips": True
},
"library": {
"root_folder": "",
"max_depth": 3,
"auto_scan_on_startup": False,
"watch_for_changes": False
},
"download_settings": {
"max_concurrent_downloads": 3,
"max_download_speed": 0,
"min_download_speed": 0,
"retry_attempts": 3,
"timeout_seconds": 30
}
}
self.settings = self.load_settings()
def load_settings(self) -> Dict[str, Any]:
"""Load settings from file or create default."""
if os.path.exists(self.settings_file):
try:
with open(self.settings_file, 'r') as f:
loaded = json.load(f)
# Merge with defaults to handle new keys
return self._merge_settings(self.default_settings, loaded)
except Exception as e:
print(f"Error loading settings: {e}")
return self.default_settings.copy()
return self.default_settings.copy()
def _merge_settings(self, defaults: Dict, loaded: Dict) -> Dict:
"""Merge loaded settings with defaults, preserving user values."""
result = defaults.copy()
for key, value in loaded.items():
if key in result:
if isinstance(result[key], dict) and isinstance(value, dict):
result[key] = self._merge_settings(result[key], value)
else:
result[key] = value
else:
result[key] = value
return result
def save_settings(self):
"""Save current settings to file."""
try:
with open(self.settings_file, 'w') as f:
json.dump(self.settings, f, indent=2)
return True
except Exception as e:
print(f"Error saving settings: {e}")
return False
def get(self, path: str, default: Any = None) -> Any:
"""Get a setting value using dot notation (e.g., 'api.huggingface_token')."""
keys = path.split('.')
value = self.settings
for key in keys:
if isinstance(value, dict) and key in value:
value = value[key]
else:
return default
return value
def set(self, path: str, value: Any):
"""Set a setting value using dot notation."""
keys = path.split('.')
target = self.settings
for key in keys[:-1]:
if key not in target:
target[key] = {}
target = target[key]
target[keys[-1]] = value
def reset_to_defaults(self):
"""Reset all settings to defaults."""
self.settings = self.default_settings.copy()
self.save_settings()
class SettingsDialog:
"""Settings dialog window for the application."""
def __init__(self, parent: tk.Tk, settings_manager: SettingsManager):
self.parent = parent
self.settings = settings_manager
self.dialog = tk.Toplevel(parent)
self.dialog.title("Settings")
self.dialog.geometry("700x500")
self.dialog.resizable(True, True)
# Make dialog modal
self.dialog.transient(parent)
self.dialog.grab_set()
# Variables for settings
self.vars = {}
self._create_variables()
# Build UI
self._build_ui()
# Load current settings into UI
self._load_current_settings()
# Center the dialog
self._center_window()
def _create_variables(self):
"""Create tkinter variables for settings."""
self.vars = {
# API Settings
'hf_token': tk.StringVar(),
'use_env_token': tk.BooleanVar(),
'use_organization': tk.BooleanVar(),
'organization': tk.StringVar(),
# Path Settings
'models_dir': tk.StringVar(),
'downloads_dir': tk.StringVar(),
# Model Settings
'default_n_ctx': tk.IntVar(),
'default_n_gpu': tk.IntVar(),
'default_max_tokens': tk.IntVar(),
'stream_default': tk.BooleanVar(),
'temperature': tk.DoubleVar(),
'top_p': tk.DoubleVar(),
'repetition_penalty': tk.DoubleVar(),
'no_repeat_ngram_size': tk.IntVar(),
'min_p': tk.DoubleVar(),
'typical_p': tk.DoubleVar(),
# Search Settings
'search_type': tk.StringVar(),
'default_sort': tk.StringVar(),
'search_limit': tk.IntVar(),
'auto_filter_gguf': tk.BooleanVar(),
# UI Settings
'show_tooltips': tk.BooleanVar(),
'theme': tk.StringVar(),
# Library Settings
'library_root': tk.StringVar(),
'library_depth': tk.IntVar(),
'auto_scan': tk.BooleanVar(),
'watch_changes': tk.BooleanVar(),
# Download Settings
'max_downloads': tk.IntVar(),
'max_speed': tk.IntVar(),
'min_speed': tk.IntVar(),
'retry_attempts': tk.IntVar(),
'timeout_seconds': tk.IntVar()
}
def _build_ui(self):
"""Build the settings dialog UI."""
# Create notebook for tabs
notebook = ttk.Notebook(self.dialog)
notebook.pack(fill=tk.BOTH, expand=True, padx=10, pady=10)
# API Settings Tab
api_frame = ttk.Frame(notebook)
notebook.add(api_frame, text="API")
self._build_api_tab(api_frame)
# Paths Tab
paths_frame = ttk.Frame(notebook)
notebook.add(paths_frame, text="Paths")
self._build_paths_tab(paths_frame)
# Model Settings Tab
model_frame = ttk.Frame(notebook)
notebook.add(model_frame, text="Model Defaults")
self._build_model_tab(model_frame)
# Search Settings Tab
search_frame = ttk.Frame(notebook)
notebook.add(search_frame, text="Search")
self._build_search_tab(search_frame)
# UI Preferences Tab
ui_frame = ttk.Frame(notebook)
notebook.add(ui_frame, text="Interface")
self._build_ui_tab(ui_frame)
# Library Settings Tab
library_frame = ttk.Frame(notebook)
notebook.add(library_frame, text="Library")
self._build_library_tab(library_frame)
# Download Settings Tab
download_frame = ttk.Frame(notebook)
notebook.add(download_frame, text="Downloads")
self._build_download_tab(download_frame)
# Buttons at bottom
button_frame = ttk.Frame(self.dialog)
button_frame.pack(fill=tk.X, padx=10, pady=(0, 10))
ttk.Button(button_frame, text="Save", command=self._save_settings).pack(side=tk.RIGHT, padx=5)
ttk.Button(button_frame, text="Cancel", command=self.dialog.destroy).pack(side=tk.RIGHT)
ttk.Button(button_frame, text="Reset to Defaults", command=self._reset_defaults).pack(side=tk.LEFT)
def _build_api_tab(self, parent: ttk.Frame):
"""Build API settings tab."""
# Main container with scrollbar
canvas = tk.Canvas(parent)
scrollbar = ttk.Scrollbar(parent, orient="vertical", command=canvas.yview)
scrollable_frame = ttk.Frame(canvas)
scrollable_frame.bind(
"<Configure>",
lambda e: canvas.configure(scrollregion=canvas.bbox("all"))
)
canvas.create_window((0, 0), window=scrollable_frame, anchor="nw")
canvas.configure(yscrollcommand=scrollbar.set)
# API Token Frame
token_frame = ttk.LabelFrame(scrollable_frame, text="API Token Management", padding=10)
token_frame.pack(fill=tk.BOTH, expand=True, padx=10, pady=10)
# Use environment token checkbox
ttk.Checkbutton(token_frame, text="Use token from HUGGINGFACE.env file",
variable=self.vars['use_env_token'],
command=self._toggle_token_entry).grid(row=0, column=0, columnspan=3, sticky=tk.W, pady=5)
# API Token entry
ttk.Label(token_frame, text="API Token:").grid(row=1, column=0, sticky=tk.W, pady=5)
self.token_entry = ttk.Entry(token_frame, textvariable=self.vars['hf_token'], width=40, show="*")
self.token_entry.grid(row=1, column=1, sticky=tk.W, pady=5)
# Token action buttons
token_buttons = ttk.Frame(token_frame)
token_buttons.grid(row=1, column=2, padx=5)
self.show_token_btn = ttk.Button(token_buttons, text="View", width=8,
command=self._toggle_token_visibility)
self.show_token_btn.pack(side=tk.LEFT, padx=2)
ttk.Button(token_buttons, text="Change", width=8,
command=self._change_token).pack(side=tk.LEFT, padx=2)
ttk.Button(token_buttons, text="Test", width=8,
command=self._test_api_key).pack(side=tk.LEFT, padx=2)
# Organization Frame
org_frame = ttk.LabelFrame(scrollable_frame, text="Organization Settings", padding=10)
org_frame.pack(fill=tk.BOTH, expand=True, padx=10, pady=10)
# Use organization checkbox
ttk.Checkbutton(org_frame, text="Use as HuggingFace organization member",
variable=self.vars['use_organization'],
command=self._toggle_organization).grid(row=0, column=0, columnspan=3, sticky=tk.W, pady=5)
# Organization dropdown
ttk.Label(org_frame, text="Organization:").grid(row=1, column=0, sticky=tk.W, pady=5)
self.org_combo = ttk.Combobox(org_frame, textvariable=self.vars['organization'],
state="disabled", width=30)
self.org_combo.grid(row=1, column=1, sticky=tk.W, pady=5)
ttk.Button(org_frame, text="Fetch Organizations",
command=self._fetch_organizations).grid(row=1, column=2, padx=5)
# Organizations list (for display)
self.org_listbox = tk.Listbox(org_frame, height=5, width=50)
self.org_listbox.grid(row=2, column=0, columnspan=3, pady=10)
self.org_listbox.bind('<<ListboxSelect>>', self._on_org_select)
# Info labels
info_frame = ttk.Frame(scrollable_frame)
info_frame.pack(fill=tk.X, padx=10, pady=10)
info_text = ("• API tokens can be obtained from: https://huggingface.co/settings/tokens\n"
"• Organizations allow you to access private repos and team resources\n"
"• Test your API key to verify it's working correctly")
ttk.Label(info_frame, text=info_text, foreground="gray").pack(anchor=tk.W)
# API Status label
self.api_status_label = ttk.Label(info_frame, text="", foreground="green")
self.api_status_label.pack(anchor=tk.W, pady=5)
canvas.pack(side=tk.LEFT, fill=tk.BOTH, expand=True)
scrollbar.pack(side=tk.RIGHT, fill=tk.Y)
def _build_paths_tab(self, parent: ttk.Frame):
"""Build paths settings tab."""
frame = ttk.LabelFrame(parent, text="Default Directories", padding=10)
frame.pack(fill=tk.BOTH, expand=True, padx=10, pady=10)
# Models directory
ttk.Label(frame, text="Models Directory:").grid(row=0, column=0, sticky=tk.W, pady=5)
ttk.Entry(frame, textvariable=self.vars['models_dir'], width=40).grid(row=0, column=1, pady=5)
ttk.Button(frame, text="Browse",
command=lambda: self._browse_directory('models_dir')).grid(row=0, column=2, padx=5)
# Downloads directory
ttk.Label(frame, text="Downloads Directory:").grid(row=1, column=0, sticky=tk.W, pady=5)
ttk.Entry(frame, textvariable=self.vars['downloads_dir'], width=40).grid(row=1, column=1, pady=5)
ttk.Button(frame, text="Browse",
command=lambda: self._browse_directory('downloads_dir')).grid(row=1, column=2, padx=5)
# Create directories checkbox
self.create_dirs_var = tk.BooleanVar(value=True)
ttk.Checkbutton(frame, text="Create directories if they don't exist",
variable=self.create_dirs_var).grid(row=2, column=0, columnspan=3, pady=10)
def _build_model_tab(self, parent: ttk.Frame):
"""Build model defaults tab."""
frame = ttk.LabelFrame(parent, text="Default Model Settings", padding=10)
frame.pack(fill=tk.BOTH, expand=True, padx=10, pady=10)
# Context size
ttk.Label(frame, text="Default Context Size (n_ctx):").grid(row=0, column=0, sticky=tk.W, pady=5)
ctx_spin = tk.Spinbox(frame, from_=512, to=32768, increment=512,
textvariable=self.vars['default_n_ctx'], width=15)
ctx_spin.grid(row=0, column=1, sticky=tk.W, pady=5)
# GPU layers
ttk.Label(frame, text="Default GPU Layers:").grid(row=1, column=0, sticky=tk.W, pady=5)
gpu_spin = tk.Spinbox(frame, from_=0, to=100, increment=1,
textvariable=self.vars['default_n_gpu'], width=15)
gpu_spin.grid(row=1, column=1, sticky=tk.W, pady=5)
# Max tokens
ttk.Label(frame, text="Default Max Tokens:").grid(row=2, column=0, sticky=tk.W, pady=5)
tokens_spin = tk.Spinbox(frame, from_=16, to=8192, increment=16,
textvariable=self.vars['default_max_tokens'], width=15)
tokens_spin.grid(row=2, column=1, sticky=tk.W, pady=5)
# Stream by default
ttk.Checkbutton(frame, text="Stream output by default",
variable=self.vars['stream_default']).grid(row=3, column=0, columnspan=2, pady=10)
# Temperature
ttk.Label(frame, text="Temperature:").grid(row=4, column=0, sticky=tk.W, pady=5)
temp_spin = tk.Spinbox(frame, from_=0.0, to=2.0, increment=0.1,
textvariable=self.vars['temperature'], width=15, format="%.1f")
temp_spin.grid(row=4, column=1, sticky=tk.W, pady=5)
# Top P
ttk.Label(frame, text="Top P:").grid(row=5, column=0, sticky=tk.W, pady=5)
top_p_spin = tk.Spinbox(frame, from_=0.0, to=1.0, increment=0.1,
textvariable=self.vars['top_p'], width=15, format="%.1f")
top_p_spin.grid(row=5, column=1, sticky=tk.W, pady=5)
# Repetition Penalty
ttk.Label(frame, text="Repetition Penalty:").grid(row=6, column=0, sticky=tk.W, pady=5)
rep_pen_spin = tk.Spinbox(frame, from_=0.5, to=2.0, increment=0.1,
textvariable=self.vars['repetition_penalty'], width=15, format="%.1f")
rep_pen_spin.grid(row=6, column=1, sticky=tk.W, pady=5)
# No Repeat N-gram Size
ttk.Label(frame, text="No Repeat N-gram Size:").grid(row=7, column=0, sticky=tk.W, pady=5)
ngram_spin = tk.Spinbox(frame, from_=0, to=10, increment=1,
textvariable=self.vars['no_repeat_ngram_size'], width=15)
ngram_spin.grid(row=7, column=1, sticky=tk.W, pady=5)
# Min P
ttk.Label(frame, text="Min P:").grid(row=8, column=0, sticky=tk.W, pady=5)
min_p_spin = tk.Spinbox(frame, from_=0.0, to=1.0, increment=0.01,
textvariable=self.vars['min_p'], width=15, format="%.2f")
min_p_spin.grid(row=8, column=1, sticky=tk.W, pady=5)
# Typical P
ttk.Label(frame, text="Typical P:").grid(row=9, column=0, sticky=tk.W, pady=5)
typical_p_spin = tk.Spinbox(frame, from_=0.0, to=1.0, increment=0.1,
textvariable=self.vars['typical_p'], width=15, format="%.1f")
typical_p_spin.grid(row=9, column=1, sticky=tk.W, pady=5)
def _build_search_tab(self, parent: ttk.Frame):
"""Build search settings tab."""
frame = ttk.LabelFrame(parent, text="Search Preferences", padding=10)
frame.pack(fill=tk.BOTH, expand=True, padx=10, pady=10)
# Default search type
ttk.Label(frame, text="Default Search Type:").grid(row=0, column=0, sticky=tk.W, pady=5)
ttk.Combobox(frame, textvariable=self.vars['search_type'],
values=["Models", "Datasets"], state="readonly", width=20).grid(row=0, column=1, sticky=tk.W, pady=5)
# Default sort
ttk.Label(frame, text="Default Sort By:").grid(row=1, column=0, sticky=tk.W, pady=5)
ttk.Combobox(frame, textvariable=self.vars['default_sort'],
values=["downloads", "likes", "lastModified"], state="readonly", width=20).grid(row=1, column=1, sticky=tk.W, pady=5)
# Search limit
ttk.Label(frame, text="Results Limit:").grid(row=2, column=0, sticky=tk.W, pady=5)
limit_spin = tk.Spinbox(frame, from_=10, to=200, increment=10,
textvariable=self.vars['search_limit'], width=20)
limit_spin.grid(row=2, column=1, sticky=tk.W, pady=5)
# Auto filter GGUF
ttk.Checkbutton(frame, text="Automatically filter for GGUF files when downloading models",
variable=self.vars['auto_filter_gguf']).grid(row=3, column=0, columnspan=2, pady=10)
def _build_ui_tab(self, parent: ttk.Frame):
"""Build UI preferences tab."""
frame = ttk.LabelFrame(parent, text="Interface Settings", padding=10)
frame.pack(fill=tk.BOTH, expand=True, padx=10, pady=10)
# Theme selection
ttk.Label(frame, text="Theme:").grid(row=0, column=0, sticky=tk.W, pady=5)
ttk.Combobox(frame, textvariable=self.vars['theme'],
values=["default", "dark", "light"], state="readonly", width=20).grid(row=0, column=1, sticky=tk.W, pady=5)
# Show tooltips
ttk.Checkbutton(frame, text="Show tooltips",
variable=self.vars['show_tooltips']).grid(row=1, column=0, columnspan=2, pady=10)
# Note about themes
ttk.Label(frame, text="Note: Theme changes will take effect after restart",
foreground="gray").grid(row=2, column=0, columnspan=2, pady=5)
def _build_library_tab(self, parent: ttk.Frame):
"""Build library settings tab."""
frame = ttk.LabelFrame(parent, text="Model Library Settings", padding=10)
frame.pack(fill=tk.BOTH, expand=True, padx=10, pady=10)
# Library root folder
ttk.Label(frame, text="Library Root Folder:").grid(row=0, column=0, sticky=tk.W, pady=5)
root_frame = ttk.Frame(frame)
root_frame.grid(row=0, column=1, columnspan=2, sticky=tk.W, pady=5)
ttk.Entry(root_frame, textvariable=self.vars['library_root'], width=40).pack(side=tk.LEFT)
ttk.Button(root_frame, text="Browse",
command=lambda: self._browse_directory('library_root')).pack(side=tk.LEFT, padx=5)
# Scan depth
ttk.Label(frame, text="Maximum Scan Depth:").grid(row=1, column=0, sticky=tk.W, pady=5)
depth_frame = ttk.Frame(frame)
depth_frame.grid(row=1, column=1, columnspan=2, sticky=tk.W, pady=5)
depth_scale = ttk.Scale(depth_frame, from_=1, to=10, variable=self.vars['library_depth'],
orient=tk.HORIZONTAL, length=200)
depth_scale.pack(side=tk.LEFT)
depth_label = ttk.Label(depth_frame, textvariable=self.vars['library_depth'])
depth_label.pack(side=tk.LEFT, padx=10)
ttk.Label(depth_frame, text="levels").pack(side=tk.LEFT)
# Auto scan options
ttk.Checkbutton(frame, text="Auto-scan library on startup",
variable=self.vars['auto_scan']).grid(row=2, column=0, columnspan=3, sticky=tk.W, pady=5)
ttk.Checkbutton(frame, text="Watch for file system changes (experimental)",
variable=self.vars['watch_changes']).grid(row=3, column=0, columnspan=3, sticky=tk.W, pady=5)
# Info text
info_text = ("The library scanner searches for model files in the specified folder.\n"
"Scan depth controls how many subdirectory levels to search.\n"
"Supported formats: .gguf, .bin, .safetensors, .pt, .pth, .onnx")
ttk.Label(frame, text=info_text, foreground="gray").grid(row=4, column=0, columnspan=3, pady=10)
def _build_download_tab(self, parent: ttk.Frame):
"""Build download settings tab."""
# Download limits frame
limits_frame = ttk.LabelFrame(parent, text="Download Limits", padding=10)
limits_frame.pack(fill=tk.X, padx=10, pady=10)
# Max concurrent downloads
ttk.Label(limits_frame, text="Maximum Concurrent Downloads:").grid(row=0, column=0, sticky=tk.W, pady=5)
concurrent_spin = tk.Spinbox(limits_frame, from_=1, to=10, increment=1,
textvariable=self.vars['max_downloads'], width=15)
concurrent_spin.grid(row=0, column=1, sticky=tk.W, pady=5)
ttk.Label(limits_frame, text="(1-10 downloads)").grid(row=0, column=2, sticky=tk.W, padx=5)
# Speed limits frame
speed_frame = ttk.LabelFrame(parent, text="Speed Limits (KB/s)", padding=10)
speed_frame.pack(fill=tk.X, padx=10, pady=10)
# Max download speed
ttk.Label(speed_frame, text="Maximum Download Speed:").grid(row=0, column=0, sticky=tk.W, pady=5)
max_speed_spin = tk.Spinbox(speed_frame, from_=0, to=100000, increment=100,
textvariable=self.vars['max_speed'], width=15)
max_speed_spin.grid(row=0, column=1, sticky=tk.W, pady=5)
ttk.Label(speed_frame, text="(0 = unlimited)").grid(row=0, column=2, sticky=tk.W, padx=5)
# Min download speed
ttk.Label(speed_frame, text="Minimum Download Speed:").grid(row=1, column=0, sticky=tk.W, pady=5)
min_speed_spin = tk.Spinbox(speed_frame, from_=0, to=10000, increment=10,
textvariable=self.vars['min_speed'], width=15)
min_speed_spin.grid(row=1, column=1, sticky=tk.W, pady=5)
ttk.Label(speed_frame, text="(0 = no minimum)").grid(row=1, column=2, sticky=tk.W, padx=5)
# Connection settings frame
conn_frame = ttk.LabelFrame(parent, text="Connection Settings", padding=10)
conn_frame.pack(fill=tk.X, padx=10, pady=10)
# Retry attempts
ttk.Label(conn_frame, text="Retry Attempts:").grid(row=0, column=0, sticky=tk.W, pady=5)
retry_spin = tk.Spinbox(conn_frame, from_=0, to=10, increment=1,
textvariable=self.vars['retry_attempts'], width=15)
retry_spin.grid(row=0, column=1, sticky=tk.W, pady=5)
ttk.Label(conn_frame, text="(number of retries on failure)").grid(row=0, column=2, sticky=tk.W, padx=5)
# Timeout
ttk.Label(conn_frame, text="Connection Timeout:").grid(row=1, column=0, sticky=tk.W, pady=5)
timeout_spin = tk.Spinbox(conn_frame, from_=5, to=300, increment=5,
textvariable=self.vars['timeout_seconds'], width=15)
timeout_spin.grid(row=1, column=1, sticky=tk.W, pady=5)
ttk.Label(conn_frame, text="(seconds)").grid(row=1, column=2, sticky=tk.W, padx=5)
# Info text
info_text = ("• Speed limits help manage bandwidth usage\n"
"• Concurrent downloads should be balanced with your internet connection\n"
"• Higher timeout values help with slow connections")
ttk.Label(parent, text=info_text, foreground="gray").pack(anchor=tk.W, padx=10, pady=10)
def _toggle_token_entry(self):
"""Enable/disable token entry based on checkbox."""
if self.vars['use_env_token'].get():
self.token_entry.config(state="disabled")
else:
self.token_entry.config(state="normal")
def _toggle_token_visibility(self):
"""Toggle token visibility."""
if self.token_entry['show'] == "*":
self.token_entry.config(show="")
self.show_token_btn.config(text="Hide")
else:
self.token_entry.config(show="*")
self.show_token_btn.config(text="View")
def _change_token(self):
"""Open dialog to change API token."""
import tkinter.simpledialog as simpledialog
new_token = simpledialog.askstring(
"Change API Token",
"Enter new HuggingFace API token:",
parent=self.dialog,
show='*'
)
if new_token:
self.vars['hf_token'].set(new_token)
self.vars['use_env_token'].set(False)
self._toggle_token_entry()
self.api_status_label.config(text="Token updated. Click Test to verify.", foreground="blue")
def _test_api_key(self):
"""Test the API key."""
import requests
# Get the token to test
if self.vars['use_env_token'].get():
import os
from dotenv import load_dotenv
load_dotenv("HUGGINGFACE.env")
token = os.getenv("HF_API_KEY")
else:
token = self.vars['hf_token'].get()
if not token:
self.api_status_label.config(text="No API token configured", foreground="red")
return
try:
# Test API by fetching user info
# Ensure token is properly stripped of whitespace and newlines
clean_token = token.strip().replace('\n', '').replace('\r', '')
headers = {"Authorization": f"Bearer {clean_token}"}
response = requests.get("https://huggingface.co/api/whoami", headers=headers)
if response.status_code == 200:
user_data = response.json()
username = user_data.get('name', 'Unknown')
self.api_status_label.config(
text=f"✓ API key valid. Logged in as: {username}",
foreground="green"
)
# Update organizations if found
orgs = user_data.get('orgs', [])
if orgs:
org_names = [org.get('name', '') for org in orgs]
self.org_listbox.delete(0, tk.END)
for org in org_names:
self.org_listbox.insert(tk.END, org)
self.org_combo['values'] = org_names
elif response.status_code == 401:
self.api_status_label.config(text="✗ Invalid API token", foreground="red")
else:
self.api_status_label.config(
text=f"✗ API test failed: {response.status_code}",
foreground="red"
)
except Exception as e:
self.api_status_label.config(text=f"✗ Connection error: {str(e)[:50]}", foreground="red")
def _toggle_organization(self):
"""Enable/disable organization controls."""
if self.vars['use_organization'].get():
self.org_combo.config(state="readonly")
if not self.org_combo['values']:
self._fetch_organizations()
else:
self.org_combo.config(state="disabled")
def _fetch_organizations(self):
"""Fetch organizations for the current API key."""
import requests
# Get the token
if self.vars['use_env_token'].get():
import os
from dotenv import load_dotenv
load_dotenv("HUGGINGFACE.env")
token = os.getenv("HF_API_KEY")
else:
token = self.vars['hf_token'].get()
if not token:
messagebox.showwarning("No Token", "Please configure an API token first")
return
try:
# Ensure token is properly stripped of whitespace and newlines
clean_token = token.strip().replace('\n', '').replace('\r', '')
headers = {"Authorization": f"Bearer {clean_token}"}
response = requests.get("https://huggingface.co/api/whoami", headers=headers)
if response.status_code == 200:
user_data = response.json()
orgs = user_data.get('orgs', [])
if orgs:
org_names = [org.get('name', '') for org in orgs]
self.org_listbox.delete(0, tk.END)
for org in org_names:
self.org_listbox.insert(tk.END, org)
self.org_combo['values'] = org_names
if org_names:
self.org_combo.set(org_names[0])
self.api_status_label.config(
text=f"Found {len(org_names)} organization(s)",
foreground="green"
)
else:
self.api_status_label.config(
text="No organizations found for this account",
foreground="blue"
)
else:
self.api_status_label.config(
text=f"Failed to fetch organizations: {response.status_code}",
foreground="red"
)
except Exception as e:
messagebox.showerror("Error", f"Failed to fetch organizations: {str(e)}")
def _on_org_select(self, event):
"""Handle organization selection from listbox."""
selection = self.org_listbox.curselection()
if selection:
org_name = self.org_listbox.get(selection[0])
self.vars['organization'].set(org_name)
def _browse_directory(self, var_name: str):
"""Browse for directory."""
directory = filedialog.askdirectory(
parent=self.dialog,
initialdir=self.vars[var_name].get() or "."
)
if directory:
self.vars[var_name].set(directory)
def _load_current_settings(self):
"""Load current settings into UI variables."""
self.vars['hf_token'].set(self.settings.get('api.huggingface_token', ''))
self.vars['use_env_token'].set(self.settings.get('api.use_env_token', True))
self.vars['use_organization'].set(self.settings.get('api.use_organization', False))
self.vars['organization'].set(self.settings.get('api.organization', ''))
self.vars['models_dir'].set(self.settings.get('paths.models_directory', './models'))
self.vars['downloads_dir'].set(self.settings.get('paths.downloads_directory', './downloads'))
self.vars['default_n_ctx'].set(self.settings.get('model_settings.default_n_ctx', 4096))
self.vars['default_n_gpu'].set(self.settings.get('model_settings.default_n_gpu_layers', 0))
self.vars['default_max_tokens'].set(self.settings.get('model_settings.default_max_tokens', 256))
self.vars['stream_default'].set(self.settings.get('model_settings.stream_by_default', True))
self.vars['temperature'].set(self.settings.get('model_settings.temperature', 0.7))
self.vars['top_p'].set(self.settings.get('model_settings.top_p', 0.9))
self.vars['repetition_penalty'].set(self.settings.get('model_settings.repetition_penalty', 1.1))
self.vars['no_repeat_ngram_size'].set(self.settings.get('model_settings.no_repeat_ngram_size', 0))
self.vars['min_p'].set(self.settings.get('model_settings.min_p', 0.0))
self.vars['typical_p'].set(self.settings.get('model_settings.typical_p', 1.0))
self.vars['search_type'].set(self.settings.get('search_preferences.default_search_type', 'Models'))
self.vars['default_sort'].set(self.settings.get('search_preferences.default_sort', 'downloads'))
self.vars['search_limit'].set(self.settings.get('search_preferences.search_limit', 50))
self.vars['auto_filter_gguf'].set(self.settings.get('search_preferences.auto_filter_gguf', True))
self.vars['show_tooltips'].set(self.settings.get('ui_preferences.show_tooltips', True))
self.vars['theme'].set(self.settings.get('ui_preferences.theme', 'default'))
# Library settings
self.vars['library_root'].set(self.settings.get('library.root_folder', ''))
self.vars['library_depth'].set(self.settings.get('library.max_depth', 3))
self.vars['auto_scan'].set(self.settings.get('library.auto_scan_on_startup', False))
self.vars['watch_changes'].set(self.settings.get('library.watch_for_changes', False))
# Download settings
self.vars['max_downloads'].set(self.settings.get('download_settings.max_concurrent_downloads', 3))
self.vars['max_speed'].set(self.settings.get('download_settings.max_download_speed', 0))
self.vars['min_speed'].set(self.settings.get('download_settings.min_download_speed', 0))
self.vars['retry_attempts'].set(self.settings.get('download_settings.retry_attempts', 3))
self.vars['timeout_seconds'].set(self.settings.get('download_settings.timeout_seconds', 30))
# Update token entry state
self._toggle_token_entry()
def _save_settings(self):
"""Save settings from UI to settings manager."""
# API settings (strip whitespace from strings)
self.settings.set('api.huggingface_token', self.vars['hf_token'].get().strip())
self.settings.set('api.use_env_token', self.vars['use_env_token'].get())
self.settings.set('api.use_organization', self.vars['use_organization'].get())
self.settings.set('api.organization', self.vars['organization'].get().strip())
# Path settings
models_dir = self.vars['models_dir'].get()
downloads_dir = self.vars['downloads_dir'].get()
# Create directories if requested
if self.create_dirs_var.get():
for directory in [models_dir, downloads_dir]:
if directory and not os.path.exists(directory):
try:
os.makedirs(directory, exist_ok=True)
except Exception as e:
messagebox.showerror("Error", f"Failed to create directory {directory}: {e}")
self.settings.set('paths.models_directory', models_dir)
self.settings.set('paths.downloads_directory', downloads_dir)
# Model settings
self.settings.set('model_settings.default_n_ctx', self.vars['default_n_ctx'].get())
self.settings.set('model_settings.default_n_gpu_layers', self.vars['default_n_gpu'].get())
self.settings.set('model_settings.default_max_tokens', self.vars['default_max_tokens'].get())
self.settings.set('model_settings.stream_by_default', self.vars['stream_default'].get())
self.settings.set('model_settings.temperature', self.vars['temperature'].get())
self.settings.set('model_settings.top_p', self.vars['top_p'].get())
self.settings.set('model_settings.repetition_penalty', self.vars['repetition_penalty'].get())
self.settings.set('model_settings.no_repeat_ngram_size', self.vars['no_repeat_ngram_size'].get())
self.settings.set('model_settings.min_p', self.vars['min_p'].get())
self.settings.set('model_settings.typical_p', self.vars['typical_p'].get())
# Search settings
self.settings.set('search_preferences.default_search_type', self.vars['search_type'].get())
self.settings.set('search_preferences.default_sort', self.vars['default_sort'].get())
self.settings.set('search_preferences.search_limit', self.vars['search_limit'].get())
self.settings.set('search_preferences.auto_filter_gguf', self.vars['auto_filter_gguf'].get())
# UI settings
self.settings.set('ui_preferences.show_tooltips', self.vars['show_tooltips'].get())
self.settings.set('ui_preferences.theme', self.vars['theme'].get())
# Library settings
self.settings.set('library.root_folder', self.vars['library_root'].get().strip())
self.settings.set('library.max_depth', self.vars['library_depth'].get())
self.settings.set('library.auto_scan_on_startup', self.vars['auto_scan'].get())
self.settings.set('library.watch_for_changes', self.vars['watch_changes'].get())
# Download settings
self.settings.set('download_settings.max_concurrent_downloads', self.vars['max_downloads'].get())
self.settings.set('download_settings.max_download_speed', self.vars['max_speed'].get())
self.settings.set('download_settings.min_download_speed', self.vars['min_speed'].get())
self.settings.set('download_settings.retry_attempts', self.vars['retry_attempts'].get())
self.settings.set('download_settings.timeout_seconds', self.vars['timeout_seconds'].get())
# Save to file
if self.settings.save_settings():
messagebox.showinfo("Settings", "Settings saved successfully!")
self.dialog.destroy()
else:
messagebox.showerror("Error", "Failed to save settings")
def _reset_defaults(self):
"""Reset settings to defaults."""
if messagebox.askyesno("Reset Settings", "Are you sure you want to reset all settings to defaults?"):
self.settings.reset_to_defaults()
self._load_current_settings()
messagebox.showinfo("Settings", "Settings reset to defaults")
def _center_window(self):
"""Center the dialog on the parent window."""
self.dialog.update_idletasks()
# Get parent position
parent_x = self.parent.winfo_x()
parent_y = self.parent.winfo_y()
parent_width = self.parent.winfo_width()
parent_height = self.parent.winfo_height()
# Get dialog size
dialog_width = self.dialog.winfo_width()
dialog_height = self.dialog.winfo_height()
# Calculate position
x = parent_x + (parent_width - dialog_width) // 2
y = parent_y + (parent_height - dialog_height) // 2
self.dialog.geometry(f"+{x}+{y}")
def open_settings_dialog(parent: tk.Tk, settings_manager: SettingsManager):
"""Convenience function to open the settings dialog."""
dialog = SettingsDialog(parent, settings_manager)
return dialog