text stringlengths 14 100k | source stringclasses 1
value | repo stringclasses 810
values | language stringclasses 13
values |
|---|---|---|---|
<|fim_suffix|> nullptr) return;
auto* pNodeInfo = (PrivacyNodeInfo*)pw_proxy_get_user_data(proxy);
new (pNodeInfo) PrivacyNodeInfo{};
pNodeInfo->id = id;
pNodeInfo->data = this;
pNodeInfo->type = mediaType;
pNodeInfo->media_class = mediaClass;
pw_proxy_add_listener(proxy, &pNodeInfo->proxy_listener, &PR... | fim | Alexays/Waybar | cpp |
<|fim_prefix|>#include "util/pipewire/privacy_node_info.hpp"
namespace waybar::util::PipewireBackend {
std::string PrivacyNodeInfo::getName() {
const std::vector<std::string*> names{&application_name, &node_name};
std::string name = "Unknown Application";
for (const auto& item : names) {
if (item != nullptr... | fim | Alexays/Waybar | cpp |
<|fim_prefix|>#include "util/portal.hpp"
#include <giomm/dbusproxy.h>
#include <glibmm/variant.h>
#include <spdlog/spdlog.h>
#include <iostream>
#include <string>
#include "fmt/format.h"
namespace waybar {
static constexpr const char* PORTAL_BUS_NAME = "org.freedesktop.portal.Desktop";
static constexpr const char* ... | fim | Alexays/Waybar | cpp |
<|fim_suffix|>ariant_get(parameters, "(b)", &sleeping);
auto* self = static_cast<PrepareForSleep*>(user_data);
self->signal.emit(sleeping);
}
}
public:
static PrepareForSleep& GetInstance() {
static PrepareForSleep instance;
return instance;
}
waybar::SafeSignal<bool> signal;
privat... | fim | Alexays/Waybar | cpp |
<|fim_prefix|>#include "util/regex_collection.hpp"
#include <json/value.h>
#include <spdlog/spdlog.h>
#include <algorithm>
#include <utility>
namespace waybar::util {
int default_priority_function(std::string& key) { return 0; }
RegexCollection::RegexCollection(const Json::Value& map, std::string default_repr,
... | fim | Alexays/Waybar | cpp |
<|fim_suffix|>h (const std::regex_error& e) {
spdlog::error("Invalid rule {}: {}", it.key().asString(), e.what());
}
}
}
return res;
}
} // namespace waybar::util
<|fim_prefix|>#include "util/rewrite_string.hpp"
#include <spdlog/spdlog.h>
#include <regex>
namespace waybar::util {
std::string ... | fim | Alexays/Waybar | cpp |
<|fim_suffix|>RFKILL control device");
return false;
}
bool waybar::util::Rfkill::getState() const { return state_; }
<|fim_prefix|>/* https://git.kernel.org/pub/scm/linux/kernel/git/jberg/rfkill.git/
*
* Copyright 2009 Johannes Berg <johannes@sipsolutions.net>
* Copyright 2009 Marcel Holtmann <marcel@holtmann.or... | fim | Alexays/Waybar | cpp |
<|fim_prefix|>#inc<|fim_suffix|>t auto& pair : replacement_table) {
startpoint = 0;
while ((startpoint = str.find(pair.first, startpoint)) != std::string::npos) {
str.replace(startpoint, 1, pair.second);
startpoint += pair.second.length();
}
}
return str;
}
} // namespace waybar::util
<|fi... | fim | Alexays/Waybar | cpp |
<|fim_prefix|>#include <filesystem>
#include <fstream>
#include <iomanip>
#include <regex>
#include <sstream>
namespace fs = std::filesystem;
struct TransformResult {
std::string css;
bool was_transform<|fim_suffix|>e = fs::file_size(file_path);
std::string result(size, '\0');
if (!f.is_open() || !f.good()) {
... | fim | Alexays/Waybar | cpp |
#include "util/ustring_clen.hpp"
int ustring_clen(const Glib::ustring& str) {
int total = 0;
for (unsigned int i : str) {
total += g_unichar_iswide(i) + 1;
}
return total;
}
<|endoftext|> | fim | Alexays/Waybar | cpp |
<|fim_prefix|>#include "config.hpp"
#if __has_include(<catch2/catch_test_macros.hpp>)
#include <catch2/catch_test_macros.hpp>
#else
#include <catch2/catch.hpp>
#endif
TEST_CASE("Load simple config", "[config]") {
waybar::Config conf;
conf.load("test/config/simple.json");
SECTION("validate the config data") {
... | fim | Alexays/Waybar | cpp |
<|fim_suffix|>ldLuaDispatch("unknown_dispatcher", "some_arg");
REQUIRE(result ==
"/dispatch hl.dsp.unknown_dispatcher(\"some_arg\")");
}
TEST_CASE("dispatch throws when Hyprland is not running", "[dispatch]") {
unsetenv("HYPRLAND_INSTANCE_SIGNATURE");
IPCTestHelper::resetSocketFolder();
IPCTestHelper... | fim | Alexays/Waybar | cpp |
<|fim_suffix|>pact") {
logger->sinks().clear();
} else {
logger->sinks().assign({std::make_shared<spdlog::sinks::stderr_sink_st>()});
}
}
return session.run();
}
<|fim_prefix|>#define CATCH_CONFIG_RUNNER
#include <glibmm.h>
#include <spdlog/sinks/stdout_sinks.h>
#include <spdlog/spdlog.h>
#if ... | fim | Alexays/Waybar | cpp |
<|fim_suffix|>n with emoji", "[json]") {
SECTION("Parse json with emoji") {
std::string stringToTest = R"({"test": "😊"})";
waybar::util::JsonParser parser;
Json::Value jsonValue = parser.parse(stringToTest);
REQUIRE(jsonValue["test"].asString() == "😊");
}
}
TEST_CASE("Json with chinese characters... | fim | Alexays/Waybar | cpp |
<|fim_suffix|>SafeSignal<int> test_signal;
test_signal.set_max_queued_events(MAX_QUEUED_EVENTS);
setTimeout(500);
test_signal.connect([&](auto value) { received.push_back(value); });
run([&]() {
std::thread producer([&]() {
for (int i = 1; i <= NUM_EVENTS; ++i) {
test_signal.emit(i);
... | fim | Alexays/Waybar | cpp |
<|fim_prefix|>#if __has_include(<catch2/catch_test_macros.hpp>)
#include <catch2/catch_test_macros.hpp>
#else
#include <catch2/catch.hpp>
#endif
#include <sys/wait.h>
#include <unistd.h>
#include <cerrno>
#include <list>
#include <mutex>
std::mutex reap_mtx;
std::list<pid_t> reap;
extern "C" int waybar_test_execl(c... | fim | Alexays/Waybar | cpp |
<|fim_prefix|>#include "util/css_reload_helper.hpp"
#include <map>
#if __has_include(<catch2/catch_test_macros.hpp>)
#include <catch2/catch_test_macros.hpp>
#else
#include <catch2/catch.hpp>
#endif
class CssReloadHelperTest : public waybar::CssReloadHelper {
public:
CssReloadHelperTest() : CssReloadHelper("/tmp/w... | fim | Alexays/Waybar | cpp |
<|fim_suffix|>");
}
}
SECTION("GB locale") {
try {
const auto loc = std::locale("en_GB.UTF-8");
#if not HAVE_CHRONO_TIMEZONES
CHECK(fmt_lib::format(loc, "{}", tm).empty()); // no format specified
CHECK_THAT(fmt_lib::format(loc, "{:%c}", tm), // HowardHinnant/date#704
C... | fim | Alexays/Waybar | cpp |
<|fim_prefix|>#pragma once
#include <glibmm/main.h>
/**
* Minimal Glib application to be used for tests that require Glib main loop
*/
class GlibTestsFixture : public sigc::trackable {
public:
GlibTestsFixture() : main_loop_{Glib::MainLoop::create()} {}
void setTimeout(int timeout) {
Glib::signal_timeout().... | fim | Alexays/Waybar | cpp |
<|fim_prefix|><|fim_suffix|>reassignment_regression() {
waybar::util::SleeperThread thread;
thread = [] { std::this_thread::sleep_for(std::chrono::milliseconds(10)); };
thread = [] { std::this_thread::sleep_for(std::chrono::milliseconds(1)); };
return 0;
}
int run_control_flag_stress() {
for (int i = 0; i < ... | fim | Alexays/Waybar | cpp |
<|fim_suffix|> **unsorted** so the caller can apply its own sort criteria.
pub fn build_model_fits(
db: &ModelDatabase,
specs: &SystemSpecs,
installed: &InstalledIndex,
context_limit: Option<u32>,
forced_runtime: Option<InferenceRuntime>,
) -> Vec<ModelFit> {
use crate::fit::backend_compatible;
... | fim | AlexsJones/llmfit | rust |
<|fim_suffix|>
}
}
Ok(tags.models[0].name.clone())
}
// ── Display helpers ────────────────────────────────────────────────
impl BenchResult {
pub fn display(&self) {
println!();
println!(" === Benchmark Results ===");
println!(" Model: {}", self.model);
print... | fim | AlexsJones/llmfit | rust |
//! Client for the localmaxxing.com benchmark API.
//!
//! Fetches real-world benchmark results (tok/s, TTFT, VRAM usage) for
//! hardware configurations that match the user's detected system specs.
//! Includes an embedded cache as fallback when the API is unreachable.
use crate::hardware::{GpuBackend, SystemSpecs};
... | fim | AlexsJones/llmfit | rust |
<|fim_prefix|>pub mod analysis;
pub mod bench;
pub mod benchmarks;
pub mod fit;
pub mod hardware;
pub mod models;
pub mod plan;
pub <|fim_suffix|> UpgradeDelta, estimate_model_plan, normalize_quant, resolve_model_selector,
};
pub use providers::{
LlamaCppProvider, LmStudioProvider, MlxProvider, ModelProvider, Ollam... | fim | AlexsJones/llmfit | rust |
<|fim_prefix|>use crate::fit::{FitLevel, RunMode};
use crate::hardware::{GpuBackend, SystemSpecs};
use crate::models::{KvQuant, LlmModel, quant_speed_multiplier};
const SUPPORTED_QUANTS: &[&str] = &[
"F32",
"F16",
"BF16",
"Q8_0",
"Q6_K",
"Q5_K_M",
"Q4_K_M",
"Q4_0",
"Q3_K_M",
"Q2... | fim | AlexsJones/llmfit | rust |
<|fim_suffix|>.len() >= 2 {
let (ref _best_model, best_q, best_s, best_c) = scores[0];
let (ref ru_model, ru_q, ru_s, ru_c) = scores[1];
let note = if ru_s > best_s * 1.5 {
"consider for speed".to_string()
} else if (ru_q - best_q).abs() < 1.0 {
... | fim | AlexsJones/llmfit | rust |
<|fim_suffix|>applied in ModelDatabase::new().
let embedded_names: HashSet<String> = ModelDatabase::embedded()
.get_all_models()
.iter()
.map(|m| crate::models::canonical_slug(&m.name))
.collect();
// Load the existing cache so we can append to it.
let mut cached = load_cach... | fim | AlexsJones/llmfit | rust |
fn main() {
tauri_build::build()
}
<|endoftext|> | fim | AlexsJones/llmfit | rust |
<|fim_suffix|>et specs = SystemSpecs::detect();
let gpus = specs
.gpus
.iter()
.map(|g| GpuInfoJs {
name: g.name.clone(),
vram_gb: g.vram_gb,
backend: format!("{:?}", g.backend),
count: g.count,
unified_memory: g.unified_memory,
... | fim | AlexsJones/llmfit | rust |
<|fim_suffix|>tered = filtered.filter(f => f.name.toLowerCase().includes(search));
}
if (fitFilter !== 'all') {
filtered = filtered.filter(f => f.fit_level === fitFilter);
}
renderModels(filtered);
}
async function loadModels() {
try {
allFits = await invoke('get_model_fits') || [];
applyFilters(... | fim | AlexsJones/llmfit | javascript |
<|fim_prefix|>(function initI18n(global) {
const LOCALE_KEY = 'llmfit.locale';
const FALLBACK_LOCALE = 'en';
const MESSAGES = {
en: {
language: {
label: 'Language',
english: 'English',
chinese: '中文'
},
system: {
title: 'System',
cpu: 'CPU',
to... | fim | AlexsJones/llmfit | javascript |
<|fim_suffix|> f"Binary not found at {bin_path}. The binary selection logic selected a file that does not exist.",
)
# If possible, check the self-reported version of the binary.
# If the binary was built for a different platform then it's not possible.
if py_target == runn... | fim | AlexsJones/llmfit | python |
<|fim_prefix|>from __future__ import annotations
import sys
import sysconfig
from importlib.metadata import PackageNotFoundError, version
from pathlib import Path
try:
__version__ = version("llmfit")
except PackageNotFoundError:
__version__ = "unknown"
class LlmfitError(Exception):
"""Base class for llm... | fim | AlexsJones/llmfit | python |
<|fim_suffix|>n(args, check=False)
except KeyboardInterrupt:
sys.exit(2)
sys.exit(completed_process.returncode)
else:
os.execv(bin_path, args) # noqa: S606 # arguments are sufficiently validated
if __name__ == "__main__":
main()
<|fim_prefix|>from __future__ import annotat... | fim | AlexsJones/llmfit | python |
<|fim_suffix|>it.__version__) is not None
<|fim_prefix|>"""Tests for the llmfit Python module (llmfit-python/src/llmfit/)."""
from __future__ import annotations
import re
import subprocess
from pathlib import Path
import pytest
import llmfit
from llmfit import find_llmfit_bin
def test_find_llmfit_bin_raises_when_... | fim | AlexsJones/llmfit | python |
<|fim_suffix|>edAsset] = &[\n");
output.push_str(" EmbeddedAsset { path: \"/index.html\", content_type: \"text/html; charset=utf-8\", bytes: FALLBACK_INDEX_HTML },\n");
output.push_str(" EmbeddedAsset { path: \"/assets/fallback.js\", content_type: \"text/javascript; charset=utf-8\", bytes: FALLBACK_JS },\... | fim | AlexsJones/llmfit | rust |
<|fim_suffix|>puOnly => Some("-ngl 0"),
RunMode::CpuOffload => Some(if supports_fit_arg {
"-ngl auto --fit on"
} else {
"-ngl auto"
}),
// llmfit's MoE estimate is not an exact llama.cpp layer/MoE split, so
// prefer llama.cpp's fit-aware auto offload rath... | fim | AlexsJones/llmfit | rust |
<|fim_suffix|> pub fn remove(&mut self, index: usize) {
if index < self.records.len() {
self.records.remove(index);
self.save();
}
}
pub fn epoch_now() -> u64 {
SystemTime::now()
.duration_since(UNIX_EPOCH)
.map(|d| d.as_secs())
... | fim | AlexsJones/llmfit | rust |
<|fim_prefix|>use llmfit_core::hardware::SystemSpecs;
use serde::Serialize;
use std::sync::Arc;
use crate::serve_shared;
pub struct EventPublisher {
client: async_nats::Client,
hostname: String,
}
#[derive(Serialize)]
struct EventEnvelope<'a, T: Serialize> {
timestamp: String,
hostname: &'a str,
... | fim | AlexsJones/llmfit | rust |
<|fim_suffix|>s not present
/// in the saved map keep their current (default) value.
pub fn apply_map(names: &[String], selected: &mut [bool], saved: &HashMap<String, bool>) {
for (i, name) in names.iter().enumerate() {
if let Some(&val) = saved.get(name) {
selected[i] = val;... | fim | AlexsJones/llmfit | rust |
mod display;
mod download_history;
#[cfg(feature = "nats")]
mod events;
mod filter_config;
mod mcp_server;
mod serve_api;
mod serve_shared;
mod theme;
mod tui_app;
mod tui_events;
mod tui_ui;
use clap::{Parser, Subcommand};
use std::net::{TcpStream, ToSocketAddrs};
use std::process::Stdio;
use std::thread;
use std::ti... | fim | AlexsJones/llmfit | rust |
<|fim_suffix|>ovider, or use case"
)]
async fn search_models(&self, params: Parameters<SearchModelsParams>) -> String {
let params = params.0;
let limit = params.limit.unwrap_or(10);
let search_lower = params.query.to_lowercase();
let mut fits = self.analyze_all();
fits.... | fim | AlexsJones/llmfit | rust |
<|fim_prefix|>use std::collections::HashMap;
use std::net::{IpAddr, SocketAddr};
use std::sync::{Arc, LazyLock};
use axum::extract::{ConnectInfo, Path, Query, State};
use axum::http::header::{CACHE_CONTROL, CONTENT_TYPE};
use axum::http::{HeaderValue, StatusCode};
use axum::response::{IntoResponse, Response};
use axum... | fim | AlexsJones/llmfit | rust |
<|fim_prefix|>use llmfit_core::fit::{FitLevel, InferenceRuntime, ModelFit, RunMode};
use llmfit_core::hardware::SystemSpecs;
pub fn system_json(specs: &SystemSpecs) -> serde_json::Value {
let gpus_json: Vec<serde_json::Value> = specs
.gpus
.iter()
.map(|g| {
serde_json::json!({
... | fim | AlexsJones/llmfit | rust |
<|fim_suffix|>re_low: Color::Rgb(237, 135, 150),
fit_perfect: Color::Rgb(166, 218, 149),
fit_good: Color::Rgb(238, 212, 159),
fit_marginal: Color::Rgb(198, 160, 246), // Mauve
fit_tight: Color::Rgb(237, 135, 150),
mode_gpu: Color::Rgb(166, 218, 149),
mode_moe: Color::Rg... | fim | AlexsJones/llmfit | rust |
<|fim_prefix|>use crossterm::event::{self, Event, KeyCode, KeyEvent, KeyEventKind, KeyModifiers};
use std::time::Duration;
use crate::tui_app::{App, InputMode};
/// Poll for and handle events. Returns true if an event was processed.
pub fn handle_events(app: &mut App) -> std::io::Result<bool> {
// Always tick the... | fim | AlexsJones/llmfit | rust |
<|fim_suffix|>t models = json
.get("models")
.and_then(Value::as_array)
.expect("fit --json output missing models array");
assert!(models.len() <= 3, "fit output exceeded requested limit");
if let Some(first) = models.first() {
let first = first
.as_object()
... | fim | AlexsJones/llmfit | rust |
<|fim_suffix|>
{t('models.compareAction', { count: compareCount })}
</button>
)}
<span className="chip">
{t('models.summary', { returned, total })}
</span>
</div>
</div>
<FilterBar />
{showCompare && compareCount >= 2 ? (
... | fim | AlexsJones/llmfit | javascript |
<|fim_prefix|>import { fireEvent, render, screen, waitFor } from '@testing-library/react';
import App from './App';
function jsonResponse(payload, { ok = true, status = 200 } = {}) {
return {
ok,
status,
json: async () => payload
};
}
const systemPayload = {
node: { name: 'local-node', os: 'darwin' ... | fim | AlexsJones/llmfit | javascript |
<|fim_suffix|> params.set('sort', filters.sort);
}
// New server-side filter params
const license = trimOrEmpty(filters.license);
if (license) {
params.set('license', license);
}
const maxContext = trimOrEmpty(String(filters.maxContext || ''));
if (maxContext) {
const parsed = Number.parseInt(... | fim | AlexsJones/llmfit | javascript |
<|fim_prefix|>import { appendSimulationParams, buildModelsQuery } from './api';
describe('buildModelsQuery', () => {
it('maps filter state to API query parameters', () => {
const query = buildModelsQuery({
search: 'qwen',
minFit: 'good',
runtime: 'llamacpp',
useCase: 'coding',
provi... | fim | AlexsJones/llmfit | javascript |
<|fim_prefix|>import { useMemo } from 'react';
import { useI18n } from '../contexts/I18nContext';
import { useModelContext } from '../contexts/ModelContext';
import { round, translateFitLevel, translateRunMode } from '../utils';
function buildCompareFields(t) {
return [
{ key: 'fit_level', label: t('compare.fiel... | fim | AlexsJones/llmfit | javascript |
<|fim_prefix|>import { useEffect, useMemo, useState } from 'react';
import { fetchPlanEstimate } from '../api';
import { useI18n } from '../contexts/I18nContext';
import { useModelContext } from '../contexts/ModelContext';
import { round, fitClass, translateFitLevel, translateRunMode } from '../utils';
function Metric... | fim | AlexsJones/llmfit | javascript |
import { useMemo, useRef, useState, useEffect } from 'react';
import { useFilters, useFilterDispatch } from '../contexts/FilterContext';
import { useI18n } from '../contexts/I18nContext';
import { useModelContext } from '../contexts/ModelContext';
import { collectUniqueValues } from '../utils';
function MultiSelectDro... | fim | AlexsJones/llmfit | javascript |
<|fim_prefix|>import { useState, useEffect } from 'react';
import { useFilterDispatch } from '../contexts/FilterContext';
import { useI18n } from '../contexts/I18nContext';
import { useModelContext } from '../contexts/ModelContext';
const THEME_KEY = 'llmfit-theme';
const THEMES = [
{ value: 'default', labelKey: 't... | fim | AlexsJones/llmfit | javascript |
<|fim_suffix|>odelName(model.name)}
>
<td
className="col-compare"
onClick={(e) => e.stopPropagation()}
>
<input
type="checkbox"
className="compare-c... | fim | AlexsJones/llmfit | javascript |
<|fim_suffix|> <span>{t('simulation.fields.vram')}</span>
<input
type="number"
min="0"
step="0.1"
value={simulationDraft.vramGb}
onChange={(event) => updateSimulationDraft('vramGb', event.target.value)}
placeholder={... | fim | AlexsJones/llmfit | javascript |
<|fim_suffix|>'all',
provider: '',
sort: 'score',
limit: '50',
// Advanced filters
license: '',
maxContext: '',
capability: [],
quant: [],
runMode: [],
paramsBucket: 'all',
tp: 'all',
showAdvanced: false
};
function filterReducer(state, action) {
switch (action.type) {
case 'SET_FILTER':
... | fim | AlexsJones/llmfit | javascript |
<|fim_prefix|>import { createContext, useContext, useEffect, useMemo, useState } from 'react';
import en from '../i18n/locales/en';
import zhCN from '../i18n/locales/zh-CN';
export const LOCALE_STORAGE_KEY = 'llmfit.locale';
const FALLBACK_LOCALE = 'en';
const SUPPORTED_LOCALES = {
en,
'zh-CN': zhCN
};
const I18n... | fim | AlexsJones/llmfit | javascript |
<|fim_suffix|>e([]);
const [refreshTick, setRefreshTick] = useState(0);
const [simulationDraft, setSimulationDraft] = useState(EMPTY_SIMULATION);
const [appliedSimulation, setAppliedSimulation] = useState(EMPTY_SIMULATION);
const triggerRefresh = useCallback(() => {
setRefreshTick((t) => t + 1);
}, []);
... | fim | AlexsJones/llmfit | javascript |
<|fim_suffix|>otal(0);
setReturned(0);
setLoading(false);
setError(
error instanceof Error ? error.message : 'Unable to load model fits.'
);
setSelectedModelName(null);
}
}
loadModels();
return () => controller.abort();
}, [
filters,
applied... | fim | AlexsJones/llmfit | javascript |
<|fim_suffix|> setSystemError(
error instanceof Error
? error.message
: 'Unable to load system details.'
);
setSystemInfo(null);
}
}
loadSystem();
return () => controller.abort();
}, [
refreshTick,
appliedSimulation,
setSystemInfo... | fim | AlexsJones/llmfit | javascript |
<|fim_prefix|>const en = {
language: {
label: 'Language',
english: 'English',
chinese: '中文'
},
header: {
eyebrow: 'Local LLM Planning',
title: 'llmfit Dashboard',
copy: 'Hundreds of models & providers. One command to find what runs on your hardware.',
resetFilters: 'Reset filters',
... | fim | AlexsJones/llmfit | javascript |
<|fim_suffix|>context: '例如 8192',
quant: '例如 Q4_K_M',
kvQuant: 'fp16、fp8、q8_0、q4_0、tq',
targetTps: '可选'
},
actions: {
estimate: '生成规划',
loading: '估算中…'
},
sections: {
paths: '运行路径',
upgrades: '升级建议',
kvAlternatives: 'KV Cache 备选方案'
},
summary: {
... | fim | AlexsJones/llmfit | javascript |
<|fim_suffix|>eLocale('zh')).toBe('zh-CN');
expect(normalizeLocale('zh-TW')).toBe('zh-CN');
});
it('falls back to English when a key is missing in the active locale', () => {
expect(resolveMessage('zh-CN', 'test.fallbackOnly')).toBe('Fallback only');
});
});
<|fim_prefix|>import { n<|fim_middle|>ormalize... | fim | AlexsJones/llmfit | javascript |
<|fim_prefix|>import React from 'react';
im<|fim_suffix|> from 'react-dom/client';
import App from './App';
import './styles.css';
import './themes.css';
ReactDOM.createRoot(document.getElementById('root')).render(
<React.StrictMode>
<App />
</React.StrictMode>
);
<|fim_middle|>port ReactDOM<|endoftext|> | fim | AlexsJones/llmfit | javascript |
<|fim_prefix|>import '@test<|fim_suffix|>-library/jest-dom/vitest';
<|fim_middle|>ing<|endoftext|> | fim | AlexsJones/llmfit | javascript |
<|fim_suffix|>ls) ? models : [];
if (minFit === 'all') {
return list;
}
if (minFit === 'too_tight') {
return list.filter((model) => model.fit_level === 'too_tight');
}
const threshold = fitRank(minFit);
return list.filter((model) => {
const rank = fitRank(model.fit_level);
return rank >= th... | fim | AlexsJones/llmfit | javascript |
<|fim_suffix|>87',
'/health': 'http://127.0.0.1:8787'
}
},
test: {
environment: 'jsdom',
setupFiles: './src/test-setup.js',
globals: true,
css: true
}
});
<|fim_prefix|>import { defineConfig } from 'vite';
import react from '@vitejs/plugin-react';
export default defineConfig({
plugins... | fim | AlexsJones/llmfit | javascript |
#!/usr/bin/env python3
"""
Scraper for localmaxxing.com benchmark data.
Fetches leaderboard results for all hardware presets and caches them locally
so the TUI has a fallback when the API is unreachable.
Usage:
python3 scrape_benchmarks.py # Scrape all presets, 100 results each
python3 scrape_be... | fim | AlexsJones/llmfit | python |
<|fim_prefix|>#!/usr/bin/env python3
"""
Scraper for Docker Model Runner available models.
Queries the Docker Hub API for models in the 'ai/' namespace,
cross-references against llmfit's HF model database and Ollama mapping table,
and outputs a JSON mapping of HF model names to Docker Model Runner tags.
Usage:
pyth... | fim | AlexsJones/llmfit | python |
<|fim_prefix|>#!/usr/bin/env python3
"""
Local API validation tests for llmfit serve.
Usage:
# Test an already-running server
python3 scripts/test_api.py --base-url http://127.0.0.1:8787
# Spawn server automatically (from repo root)
python3 scripts/test_api.py --spawn
"""
from __future__ import annotations
... | fim | AlexsJones/llmfit | python |
<|fim_prefix|>#!/usr/bin/env python3
"""
Validate generation-aware quality scoring on the scraped model database.
Loads hf_models.json and applies the same generation parsing logic as the Rust
code to demonstrate that newer model generations are scored appropriately.
"""
import json
import re
import sys
from collecti... | fim | AlexsJones/llmfit | python |
<|fim_prefix|>#!/usr/bin/env python3
"""Verify that all models in hf_models.json exist on HuggingFace and all
Ollama mappings in src/providers.rs point to valid Ollama registry entries.
Usage:
python3 scripts/verify_models.py # check both
python3 scripts/verify_models.py --hf # HuggingFace onl... | fim | AlexsJones/llmfit | python |
<|fim_prefix|><?php
declare(strict_types=1);
// Global co<|fim_suffix|>onst VERSION_CODENAME = 'The Restoration';
<|fim_middle|>nstants
const BASE_PATH = __DIR__ . '/..';
const VERSION = '25.1.0';
c<|endoftext|> | fim | Anankke/SSPanel-UIM | php |
<|fim_suffix|>:class . ':addTraffic');
$group->post('/users/aliveip', App\Controllers\WebAPI\UserController::class . ':addAliveIp');
$group->post('/users/detectlog', App\Controllers\WebAPI\UserController::class . ':addDetectLog');
// 审计 & 杂七杂八的功能
$group->get('/func/detect_rules', App\Con... | fim | Anankke/SSPanel-UIM | php |
<|fim_prefix|><?php
//基本设置---------------------------------------------------------------------------------------------------------------
$_ENV['key'] = 'ChangeMe'; // Cookie加密密钥，请务必修改此key为随机字符串
$_ENV['pwdMethod'] = 'bcrypt'; // 密码加密 可选 bcrypt, argon2i, argon2id
$_ENV['salt'] = ''; // bcrypt/argon2i/arg... | fim | Anankke/SSPanel-UIM | php |
<|fim_suffix|>ck',
'DOMAIN-SUFFIX,stonecalcom.com,🛑 Block',
'DOMAIN-SUFFIX,str1kee.com,🛑 Block',
'DOMAIN-SUFFIX,sunnimiq.cf,🛑 Block',
'DOMAIN-SUFFIX,sunnimiq5.cf,🛑 Block',
'DOMAIN-SUFFIX,sunnimiq6.cf,🛑 Block',
'DOMAIN-SUFFIX,swiftmining.win,🛑 Block',
'DOMAIN... | fim | Anankke/SSPanel-UIM | php |
<|fim_prefix|><?php
declare(strict_types=1);
use App\Interfaces\MigrationInterface;
use App\Services\DB;
return new class() implements MigrationInterface {
public function up(): int
{
DB::getPdo()->exec(
"CREATE TABLE `announcement` (
`id` bigint(20) unsigned NOT NULL AUTO... | fim | Anankke/SSPanel-UIM | php |
<|fim_suffix|> `create_time` bigint(20) unsigned DEFAULT NULL,
`expire_time` bigint(20) DEFAULT NULL,
PRIMARY KEY (`id`),
KEY `user_id` (`user_id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;'
);
return 2023020100;
... | fim | Anankke/SSPanel-UIM | php |
<|fim_suffix|>TS `invoice_id`;');
return 2023021600;
}
};
<|fim_prefix|><?php
declare(strict_types=1);
use App\Interfaces\MigrationInterface;
use App\Services\DB;
return new class() implements MigrationInterface {
public function up(): int
{
DB::getPdo()->exec('ALTER TABLE paylist ADD CO... | fim | Anankke/SSPanel-UIM | php |
<|fim_suffix|>log`;');
return 2023030500;
}
};
<|fim_prefix|><?php
declare(strict_types=1);
use App\Interfaces\MigrationInterface;
use App\Services\DB;
return new class() implements MigrationInterface {
public function up(): int
{
DB::getPdo()->exec("CREATE TABLE IF NOT EXISTS `user_mone... | fim | Anankke/SSPanel-UIM | php |
<|fim_suffix|>teway`;');
return 2023031700;
}
};
<|fim_prefix|><?php
declare(strict_types=1);
use App\Interfaces\MigrationInterface;
use App\Services\DB;
return new class() implements MigrationInterface {
public function up(): int
{
DB::getPdo()->exec("ALTER<|fim_middle|> TABLE paylist A... | fim | Anankke/SSPanel-UIM | php |
<?php
declare(strict_types=1);
use App\Interfaces\MigrationInterface;
use App\Services\DB;
return new class() implements MigrationInterface {
public function up(): int
{
$pdo = DB::getPdo();
$pdo->exec('
CREATE TABLE IF NOT EXISTS online_log (
id INT UNSIGNED NOT N... | fim | Anankke/SSPanel-UIM | php |
<|fim_suffix|>已使用的流量';");
DB::getPdo()->exec('ALTER TABLE user DROP COLUMN IF EXISTS `transfer_today`;');
return 2023032600;
}
};
<|fim_prefix|><?php
declare(strict_types=1);
use App\Interfaces\MigrationInterface;
use App\Services\DB;
return new<|fim_middle|> class() implements MigrationInterfac... | fim | Anankke/SSPanel-UIM | php |
<|fim_suffix|>(11) NOT NULL DEFAULT 0 COMMENT '累计使用数';");
return 2023053000;
}
public function down(): int
{
DB::getPdo()->exec('ALTER TABLE user_coupon DROP COLUMN IF EXISTS `use_count`;');
return 2023050800;
}
};
<|fim_prefix|><?php
declare(strict_types=1);
use App\Interfa... | fim | Anankke/SSPanel-UIM | php |
<|fim_prefix|><?php
declare(strict_types=1);
use App\Interfaces\MigrationInterface;
use App\Services\DB;
return new class() implements MigrationInterface {
public function up(): int
{
DB::getPdo()->exec("
ALTER TABLE user ADD COLUMN IF NOT EXISTS `locale` varchar(16) NOT NULL DEFAULT 'zh-TW' ... | fim | Anankke/SSPanel-UIM | php |
<|fim_prefix|><?php
declare(strict_types=1);
use App\Interfaces\MigrationInterface;
use App\Services\DB;
return new class() implements MigrationInterface {
public function up(): int
{
DB::<|fim_suffix|>'' COMMENT '订单优惠码';
ALTER TABLE `order` MODIFY COLUMN `price` double unsigned NOT NULL DEFA... | fim | Anankke/SSPanel-UIM | php |
<|fim_prefix|><?php
declare(strict_types=1)<|fim_suffix|> user DROP COLUMN IF EXISTS `t`;
ALTER TABLE user ADD COLUMN IF NOT EXISTS `is_inactive` tinyint(1) NOT NULL DEFAULT 0 COMMENT '是否处于闲置状态';
ALTER TABLE user ADD COLUMN IF NOT EXISTS `last_use_time` int(11) unsigned NOT NULL DEFAULT 0 COMME... | fim | Anankke/SSPanel-UIM | php |
<|fim_prefix|><?php
declare(strict_types=1);
use App\Interfaces\MigrationInterface;
use App\Services\DB;
return new class() implements MigrationInterface {
public function up(): int
{
DB::getPdo()->exec('
DROP TABLE IF EXISTS `email_verify`;
DROP TABLE IF EXISTS `user_password... | fim | Anankke/SSPanel-UIM | php |
<|fim_suffix|>ult` text NOT NULL DEFAULT '' COMMENT '检测结果',
`created_at` int(11) unsigned NOT NULL DEFAULT 0 COMMENT '创建时间',
PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;"
);
return 2023071000;
}
};
<|fim_prefix|><... | fim | Anankke/SSPanel-UIM | php |
<|fim_suffix|>("
ALTER TABLE user ADD COLUMN IF NOT EXISTS `is_shadow_banned` tinyint(1) unsigned NOT NULL DEFAULT 0 COMMENT '是否处于账户异常状态';
ALTER TABLE user MODIFY COLUMN `is_dark_mode` tinyint(1) unsigned NOT NULL DEFAULT 0 COMMENT '是否启用暗黑模式';
ALTER TABLE user MODIFY COLUMN `is_inact... | fim | Anankke/SSPanel-UIM | php |
<|fim_suffix|>5) NOT NULL DEFAULT '' COMMENT '获取的订阅类型',
`request_ip` varchar(255) NOT NULL DEFAULT '' COMMENT '请求IP',
`request_user_agent` varchar(255) NOT NULL DEFAULT '' COMMENT '请求UA信息',
`request_time` int(11) unsigned NOT NULL DEFAULT 0 COMMENT '请求时间',
... | fim | Anankke/SSPanel-UIM | php |
<|fim_suffix|>023080900;
}
public function down(): int
{
DB::getPdo()->exec("
ALTER TABLE user MODIFY COLUMN `im_type` smallint(6) unsigned NOT NULL DEFAULT 1 COMMENT '联系方式类型';
");
return 2023072000;
}
};
<|fim_prefix|><?php
declare(strict_types=1);
use App\Interf... | fim | Anankke/SSPanel-UIM | php |
<|fim_suffix|>
ALTER TABLE user DROP COLUMN IF EXISTS `contact_method`;
');
return 2023080900;
}
};
<|fim_prefix|><?php
declare(strict_types=1);
use App\Interfaces\MigrationInterface;
use App\Services\DB;
return new class() implements <|fim_middle|>MigrationInterface {
public fun... | fim | Anankke/SSPanel-UIM | php |
<|fim_prefix|><?php
declare(strict_types=1);
use App\Interfaces\MigrationInterface;
use App\Services\DB;
return new class() implements MigrationInterface {
public function up(): int
{
DB::getPdo()->exec('
ALTER TABLE user DROP COLUMN IF EXISTS `expire_in`;
');
return 2023... | fim | Anankke/SSPanel-UIM | php |
<|fim_suffix|>B::getPdo()->exec('
ALTER TABLE node DROP COLUMN IF EXISTS `is_dynamic_rate`;
ALTER TABLE node DROP COLUMN IF EXISTS `dynamic_rate_config`;
');
return 2023082000;
}
};
<|fim_prefix|><?php
declare(strict_types=1);
use App\Interfaces\MigrationInterface;
use App... | fim | Anankke/SSPanel-UIM | php |
<|fim_prefix|><?php
declare(strict_types=1);
use App\Interfaces\MigrationInterface;
use App\Services\DB;
return new class() implements MigrationInterface {
public function up(): int
{
DB::getPdo()->exec('
ALTER TABLE node DROP COLUMN IF EXISTS `info`;
ALTER TABLE node DROP COL... | fim | Anankke/SSPanel-UIM | php |
<|fim_suffix|>` timestamp NOT NULL DEFAULT current_timestamp() ON UPDATE current_timestamp() COMMENT '创建时间';
ALTER TABLE user_invite_code ADD COLUMN IF NOT EXISTS `updated_at` timestamp NOT NULL DEFAULT '1989-06-04 00:05:00' COMMENT '更新时间';
");
return 2023111700;
}
};
<|fim_prefix|><?ph... | fim | Anankke/SSPanel-UIM | php |
<|fim_prefix|><?php
declare(strict_types=1);
use App\Interfaces\MigrationInterface;
use App\Services\DB;
return new class() implements MigrationInterface {
public function up(): int
{
DB::getPdo()->exec('
<|fim_suffix|>ER TABLE detect_ban_log DROP COLUMN IF EXISTS `email`;
');
re... | fim | Anankke/SSPanel-UIM | php |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.