Function bodies 141 total

run function · rust · L28-L58 (31 LOC)

src/main.rs

async fn run(mut terminal: DefaultTerminal, args: &Args) -> color_eyre::Result<()> {
    let mut app = App::new(args);
    let mut events = EventHandler::new(Duration::from_millis(250));
    let client = OllamaClient::new(args.base_url())?;
    let cancel = CancellationToken::new();

    spawn_poller(
        client.clone(),
        events.sender(),
        Duration::from_secs(args.refresh),
        cancel.clone(),
    );

    while app.running {
        terminal.draw(|frame| ui::render(&mut app, frame))?;

        let event = events.next().await?;
        match app.handle_event(event) {
            Action::ForceRefresh => {
                let state = client.poll_all().await;
                app.ollama_state = state;
                app.clamp_selections();
            }
            Action::None => {}
        }
    }

    cancel.cancel();
    Ok(())
}

default function · rust · L105-L113 (9 LOC)

src/ollama.rs

    fn default() -> Self {
        Self {
            connection: ConnectionStatus::Connecting,
            version: None,
            running: Vec::new(),
            local: Vec::new(),
            last_updated: None,
        }
    }

new function · rust · L125-L131 (7 LOC)

src/ollama.rs

    pub fn new(base_url: String) -> Result<Self> {
        let client = reqwest::Client::builder()
            .timeout(Duration::from_secs(5))
            .build()
            .wrap_err("failed to build HTTP client")?;
        Ok(Self { client, base_url })
    }

health function · rust · L132-L141 (10 LOC)

src/ollama.rs

    pub async fn health(&self) -> Result<bool> {
        let resp = self
            .client
            .get(format!("{}/", self.base_url))
            .send()
            .await
            .wrap_err("health check request failed")?;
        Ok(resp.status().is_success())
    }

version function · rust · L142-L154 (13 LOC)

src/ollama.rs

    pub async fn version(&self) -> Result<String> {
        let resp: VersionResponse = self
            .client
            .get(format!("{}/api/version", self.base_url))
            .send()
            .await
            .wrap_err("version request failed")?
            .json()
            .await
            .wrap_err("failed to parse version response")?;
        Ok(resp.version)
    }

running_models function · rust · L155-L167 (13 LOC)

src/ollama.rs

    pub async fn running_models(&self) -> Result<Vec<RunningModel>> {
        let resp: PsResponse = self
            .client
            .get(format!("{}/api/ps", self.base_url))
            .send()
            .await
            .wrap_err("ps request failed")?
            .json()
            .await
            .wrap_err("failed to parse ps response")?;
        Ok(resp.models)
    }

local_models function · rust · L168-L180 (13 LOC)

src/ollama.rs

    pub async fn local_models(&self) -> Result<Vec<LocalModel>> {
        let resp: TagsResponse = self
            .client
            .get(format!("{}/api/tags", self.base_url))
            .send()
            .await
            .wrap_err("tags request failed")?
            .json()
            .await
            .wrap_err("failed to parse tags response")?;
        Ok(resp.models)
    }

Source: Repobility analyzer · https://repobility.com

poll_all function · rust · L181-L203 (23 LOC)

src/ollama.rs

    pub async fn poll_all(&self) -> OllamaState {
        // Health check first as a fast connectivity test
        if let Err(e) = self.health().await {
            return OllamaState {
                connection: ConnectionStatus::Disconnected(e.to_string()),
                ..Default::default()
            };
        }

        let version = self.version().await.ok();

        let running = self.running_models().await.unwrap_or_default();
        let local = self.local_models().await.unwrap_or_default();

        OllamaState {
            connection: ConnectionStatus::Connected,
            version,
            running,
            local,
            last_updated: Some(chrono::Local::now()),
        }
    }

test_deserialize_ps_response function · rust · L211-L244 (34 LOC)

src/ollama.rs

    fn test_deserialize_ps_response() {
        let json = r#"{
            "models": [{
                "name": "mistral:latest",
                "model": "mistral:latest",
                "size": 5137025024,
                "digest": "2ae6f6dd7a3d",
                "details": {
                    "parent_model": "",
                    "format": "gguf",
                    "family": "llama",
                    "families": ["llama"],
                    "parameter_size": "7.2B",
                    "quantization_level": "Q4_0"
                },
                "expires_at": "2024-06-04T14:38:31.83753-07:00",
                "size_vram": 5137025024,
                "context_length": 4096
            }]
        }"#;

        let resp: PsResponse = serde_json::from_str(json).unwrap();
        assert_eq!(resp.models.len(), 1);

        let m = &resp.models[0];
        assert_eq!(m.name, "mistral:latest");
        assert_eq!(m.size, 5137025024);
        assert_eq!(m.size_vram, 513702502

test_deserialize_ps_empty function · rust · L247-L251 (5 LOC)

src/ollama.rs

    fn test_deserialize_ps_empty() {
        let json = r#"{"models": []}"#;
        let resp: PsResponse = serde_json::from_str(json).unwrap();
        assert!(resp.models.is_empty());
    }

test_deserialize_ps_multiple_models function · rust · L254-L299 (46 LOC)

src/ollama.rs

    fn test_deserialize_ps_multiple_models() {
        let json = r#"{
            "models": [
                {
                    "name": "llama3:8b",
                    "model": "llama3:8b",
                    "size": 4900000000,
                    "digest": "abc123",
                    "details": {
                        "parent_model": "",
                        "format": "gguf",
                        "family": "llama",
                        "families": ["llama"],
                        "parameter_size": "8.0B",
                        "quantization_level": "Q4_K_M"
                    },
                    "expires_at": "2024-06-04T14:38:31Z",
                    "size_vram": 4900000000,
                    "context_length": 4096
                },
                {
                    "name": "mistral:7b",
                    "model": "mistral:7b",
                    "size": 4100000000,
                    "digest": "def456",
                    "details": {

test_deserialize_tags_response function · rust · L302-L329 (28 LOC)

src/ollama.rs

    fn test_deserialize_tags_response() {
        let json = r#"{
            "models": [{
                "name": "deepseek-r1:latest",
                "model": "deepseek-r1:latest",
                "modified_at": "2025-05-10T08:06:48.639712648-07:00",
                "size": 4683075271,
                "digest": "0a8c26691023",
                "details": {
                    "parent_model": "",
                    "format": "gguf",
                    "family": "qwen2",
                    "families": ["qwen2"],
                    "parameter_size": "7.6B",
                    "quantization_level": "Q4_K_M"
                }
            }]
        }"#;

        let resp: TagsResponse = serde_json::from_str(json).unwrap();
        assert_eq!(resp.models.len(), 1);

        let m = &resp.models[0];
        assert_eq!(m.name, "deepseek-r1:latest");
        assert_eq!(m.size, 4683075271);
        assert_eq!(m.details.family, "qwen2");
        assert_eq!(m.details.quantization_level, "Q4

test_deserialize_tags_empty function · rust · L332-L336 (5 LOC)

src/ollama.rs

    fn test_deserialize_tags_empty() {
        let json = r#"{"models": []}"#;
        let resp: TagsResponse = serde_json::from_str(json).unwrap();
        assert!(resp.models.is_empty());
    }

test_deserialize_version_response function · rust · L339-L343 (5 LOC)

src/ollama.rs

    fn test_deserialize_version_response() {
        let json = r#"{"version": "0.5.1"}"#;
        let resp: VersionResponse = serde_json::from_str(json).unwrap();
        assert_eq!(resp.version, "0.5.1");
    }

test_deserialize_missing_optional_fields function · rust · L346-L364 (19 LOC)

src/ollama.rs

    fn test_deserialize_missing_optional_fields() {
        let json = r#"{
            "models": [{
                "name": "minimal-model",
                "size": 1000
            }]
        }"#;

        let resp: PsResponse = serde_json::from_str(json).unwrap();
        let m = &resp.models[0];
        assert_eq!(m.name, "minimal-model");
        assert_eq!(m.size, 1000);
        assert_eq!(m.context_length, None);
        assert_eq!(m.size_vram, 0);
        assert_eq!(m.model, "");
        assert_eq!(m.digest, "");
        assert_eq!(m.details.family, "");
        assert_eq!(m.details.families, None);
    }

About: code-quality intelligence by Repobility · https://repobility.com

test_deserialize_model_details_defaults function · rust · L367-L376 (10 LOC)

src/ollama.rs

    fn test_deserialize_model_details_defaults() {
        let json = r#"{}"#;
        let details: ModelDetails = serde_json::from_str(json).unwrap();
        assert_eq!(details.parent_model, "");
        assert_eq!(details.format, "");
        assert_eq!(details.family, "");
        assert_eq!(details.families, None);
        assert_eq!(details.parameter_size, "");
        assert_eq!(details.quantization_level, "");
    }

test_ollama_state_default function · rust · L379-L386 (8 LOC)

src/ollama.rs

    fn test_ollama_state_default() {
        let state = OllamaState::default();
        assert!(matches!(state.connection, ConnectionStatus::Connecting));
        assert!(state.version.is_none());
        assert!(state.running.is_empty());
        assert!(state.local.is_empty());
        assert!(state.last_updated.is_none());
    }

test_ollama_client_new function · rust · L389-L392 (4 LOC)

src/ollama.rs

    fn test_ollama_client_new() {
        let client = OllamaClient::new("http://localhost:11434".to_string()).unwrap();
        assert_eq!(client.base_url, "http://localhost:11434");
    }

test_deserialize_tags_multiple_models function · rust · L395-L434 (40 LOC)

src/ollama.rs

    fn test_deserialize_tags_multiple_models() {
        let json = r#"{
            "models": [
                {
                    "name": "llama3:8b",
                    "model": "llama3:8b",
                    "modified_at": "2025-01-01T00:00:00Z",
                    "size": 4900000000,
                    "digest": "abc",
                    "details": {
                        "parent_model": "",
                        "format": "gguf",
                        "family": "llama",
                        "parameter_size": "8.0B",
                        "quantization_level": "Q4_K_M"
                    }
                },
                {
                    "name": "gemma3:4b",
                    "model": "gemma3:4b",
                    "modified_at": "2025-02-01T00:00:00Z",
                    "size": 2800000000,
                    "digest": "def",
                    "details": {
                        "parent_model": "",
                        "format": "gguf",

test_deserialize_local_model_minimal function · rust · L437-L449 (13 LOC)

src/ollama.rs

    fn test_deserialize_local_model_minimal() {
        let json = r#"{
            "models": [{
                "name": "test-model"
            }]
        }"#;
        let resp: TagsResponse = serde_json::from_str(json).unwrap();
        let m = &resp.models[0];
        assert_eq!(m.name, "test-model");
        assert_eq!(m.size, 0);
        assert_eq!(m.model, "");
        assert_eq!(m.modified_at, "");
    }

test_poll_all_disconnected function · rust · L452-L467 (16 LOC)

src/ollama.rs

    async fn test_poll_all_disconnected() {
        // Use an unreachable address to test disconnection handling
        let client = OllamaClient::new("http://127.0.0.1:1".to_string()).unwrap();
        let state = client.poll_all().await;
        assert!(matches!(state.connection, ConnectionStatus::Disconnected(_)));
        assert!(state.version.is_none());
        assert!(state.running.is_empty());
        assert!(state.local.is_empty());
    }

    #[tokio::test]
    async fn test_health_unreachable() {
        let client = OllamaClient::new("http://127.0.0.1:1".to_string()).unwrap();
        let result = client.health().await;
        assert!(result.is_err());
    }

test_health_unreachable function · rust · L463-L474 (12 LOC)

src/ollama.rs

    async fn test_health_unreachable() {
        let client = OllamaClient::new("http://127.0.0.1:1".to_string()).unwrap();
        let result = client.health().await;
        assert!(result.is_err());
    }

    #[tokio::test]
    async fn test_version_unreachable() {
        let client = OllamaClient::new("http://127.0.0.1:1".to_string()).unwrap();
        let result = client.version().await;
        assert!(result.is_err());
    }

test_version_unreachable function · rust · L470-L481 (12 LOC)

src/ollama.rs

    async fn test_version_unreachable() {
        let client = OllamaClient::new("http://127.0.0.1:1".to_string()).unwrap();
        let result = client.version().await;
        assert!(result.is_err());
    }

    #[tokio::test]
    async fn test_running_models_unreachable() {
        let client = OllamaClient::new("http://127.0.0.1:1".to_string()).unwrap();
        let result = client.running_models().await;
        assert!(result.is_err());
    }

Repobility · code-quality intelligence platform · https://repobility.com

test_running_models_unreachable function · rust · L477-L488 (12 LOC)

src/ollama.rs

    async fn test_running_models_unreachable() {
        let client = OllamaClient::new("http://127.0.0.1:1".to_string()).unwrap();
        let result = client.running_models().await;
        assert!(result.is_err());
    }

    #[tokio::test]
    async fn test_local_models_unreachable() {
        let client = OllamaClient::new("http://127.0.0.1:1".to_string()).unwrap();
        let result = client.local_models().await;
        assert!(result.is_err());
    }

render function · rust · L12-L30 (19 LOC)

src/ui.rs

pub fn render(app: &mut App, frame: &mut Frame) {
    let chunks = Layout::vertical([
        Constraint::Length(1),
        Constraint::Min(5),
        Constraint::Min(5),
        Constraint::Length(1),
    ])
    .split(frame.area());

    render_status_bar(app, frame, chunks[0]);
    render_running_models(app, frame, chunks[1]);
    render_available_models(app, frame, chunks[2]);
    render_footer(frame, chunks[3]);

    if app.show_help {
        render_help_overlay(frame, frame.area());
    }
}

render_status_bar function · rust · L31-L73 (43 LOC)

src/ui.rs

fn render_status_bar(app: &App, frame: &mut Frame, area: Rect) {
    let (indicator, status_text, color) = match &app.ollama_state.connection {
        ConnectionStatus::Connected => ("\u{25cf}", "Connected".to_string(), Color::Green),
        ConnectionStatus::Connecting => ("\u{25cc}", "Connecting...".to_string(), Color::Yellow),
        ConnectionStatus::Disconnected(msg) => {
            ("\u{25cf}", format!("Disconnected: {msg}"), Color::Red)
        }
    };

    let mut spans = vec![
        Span::styled(
            "ollama-tui",
            Style::default().add_modifier(Modifier::BOLD),
        ),
        Span::raw("  "),
        Span::styled(
            format!("{indicator} {status_text}"),
            Style::default().fg(color),
        ),
    ];

    if let Some(ref version) = app.ollama_state.version {
        spans.push(Span::raw("  "));
        spans.push(Span::raw(format!("v{version}")));
    }

    spans.push(Span::raw("  "));
    spans.push(Span::styled(
        for

render_running_models function · rust · L74-L153 (80 LOC)

src/ui.rs

fn render_running_models(app: &mut App, frame: &mut Frame, area: Rect) {
    let is_focused = app.focused_panel == Panel::Running;
    let title = format!(" Running Models ({}) ", app.ollama_state.running.len());
    let border_color = if is_focused {
        Color::Cyan
    } else {
        Color::DarkGray
    };
    let block = Block::default()
        .title(title)
        .borders(Borders::ALL)
        .border_style(Style::default().fg(border_color));

    if app.ollama_state.running.is_empty() {
        let inner = Paragraph::new("No models currently loaded")
            .style(Style::default().fg(Color::DarkGray))
            .block(block);
        frame.render_widget(inner, area);
        return;
    }

    let header = Row::new(vec![
        Cell::from("Name"),
        Cell::from("Size"),
        Cell::from("VRAM"),
        Cell::from("Quant"),
        Cell::from("Ctx"),
        Cell::from("Expires"),
    ])
    .style(
        Style::default()
            .add_modifier(Modifi

render_available_models function · rust · L154-L228 (75 LOC)

src/ui.rs

fn render_available_models(app: &mut App, frame: &mut Frame, area: Rect) {
    let is_focused = app.focused_panel == Panel::Available;
    let title = format!(" Available Models ({}) ", app.ollama_state.local.len());
    let border_color = if is_focused {
        Color::Cyan
    } else {
        Color::DarkGray
    };
    let block = Block::default()
        .title(title)
        .borders(Borders::ALL)
        .border_style(Style::default().fg(border_color));

    if app.ollama_state.local.is_empty() {
        let inner = Paragraph::new("No models found")
            .style(Style::default().fg(Color::DarkGray))
            .block(block);
        frame.render_widget(inner, area);
        return;
    }

    let header = Row::new(vec![
        Cell::from("Name"),
        Cell::from("Size"),
        Cell::from("Family"),
        Cell::from("Params"),
        Cell::from("Quant"),
        Cell::from("Modified"),
    ])
    .style(
        Style::default()
            .add_modifier(Modifier:

render_footer function · rust · L229-L236 (8 LOC)

src/ui.rs

fn render_footer(frame: &mut Frame, area: Rect) {
    let footer = Paragraph::new(Line::from(vec![Span::styled(
        "q: Quit  r: Refresh  \u{2191}\u{2193}/jk: Scroll  Tab: Switch panel  ?: Help",
        Style::default().fg(Color::DarkGray),
    )]));
    frame.render_widget(footer, area);
}

render_help_overlay function · rust · L237-L297 (61 LOC)

src/ui.rs

fn render_help_overlay(frame: &mut Frame, area: Rect) {
    let popup_area = centered_rect(50, 60, area);

    frame.render_widget(Clear, popup_area);

    let block = Block::default()
        .title(" Keybindings ")
        .borders(Borders::ALL)
        .border_style(Style::default().fg(Color::Cyan));

    let help_text = vec![
        Line::from(""),
        Line::from(vec![
            Span::styled("  q / Ctrl+C", Style::default().add_modifier(Modifier::BOLD)),
            Span::raw("    Quit"),
        ]),
        Line::from(vec![
            Span::styled("  r", Style::default().add_modifier(Modifier::BOLD)),
            Span::raw("             Refresh now"),
        ]),
        Line::from(vec![
            Span::styled("  Tab", Style::default().add_modifier(Modifier::BOLD)),
            Span::raw("           Next panel"),
        ]),
        Line::from(vec![
            Span::styled("  Shift+Tab", Style::default().add_modifier(Modifier::BOLD)),
            Span::raw("     Previo

centered_rect function · rust · L298-L306 (9 LOC)

src/ui.rs

fn centered_rect(percent_x: u16, percent_y: u16, area: Rect) -> Rect {
    let vertical = Layout::vertical([Constraint::Percentage(percent_y)])
        .flex(Flex::Center)
        .split(area);
    Layout::horizontal([Constraint::Percentage(percent_x)])
        .flex(Flex::Center)
        .split(vertical[0])[0]
}

Want this analysis on your repo? https://repobility.com/scan/

vram_color function · rust · L307-L320 (14 LOC)

src/ui.rs

fn vram_color(size_vram: i64, total_size: i64) -> Color {
    if total_size <= 0 || size_vram < 0 {
        return Color::DarkGray;
    }
    let ratio = size_vram as f64 / total_size as f64;
    if ratio >= 0.99 {
        Color::Green
    } else if ratio > 0.0 {
        Color::Yellow
    } else {
        Color::Red
    }
}

test_vram_color_full_gpu function · rust · L327-L329 (3 LOC)

src/ui.rs

    fn test_vram_color_full_gpu() {
        assert_eq!(vram_color(5000, 5000), Color::Green);
    }

test_vram_color_partial function · rust · L332-L334 (3 LOC)

src/ui.rs

    fn test_vram_color_partial() {
        assert_eq!(vram_color(2500, 5000), Color::Yellow);
    }

test_vram_color_cpu_only function · rust · L337-L339 (3 LOC)

src/ui.rs

    fn test_vram_color_cpu_only() {
        assert_eq!(vram_color(0, 5000), Color::Red);
    }

test_vram_color_zero_total function · rust · L342-L344 (3 LOC)

src/ui.rs

    fn test_vram_color_zero_total() {
        assert_eq!(vram_color(0, 0), Color::DarkGray);
    }

test_vram_color_nearly_full function · rust · L347-L349 (3 LOC)

src/ui.rs

    fn test_vram_color_nearly_full() {
        assert_eq!(vram_color(4990, 5000), Color::Green);
    }

test_vram_color_just_below_full function · rust · L352-L354 (3 LOC)

src/ui.rs

    fn test_vram_color_just_below_full() {
        assert_eq!(vram_color(4949, 5000), Color::Yellow);
    }

test_vram_color_negative_vram function · rust · L357-L359 (3 LOC)

src/ui.rs

    fn test_vram_color_negative_vram() {
        assert_eq!(vram_color(-1, 5000), Color::DarkGray);
    }

Source: Repobility analyzer · https://repobility.com

test_vram_color_negative_total function · rust · L362-L364 (3 LOC)

src/ui.rs

    fn test_vram_color_negative_total() {
        assert_eq!(vram_color(0, -1), Color::DarkGray);
    }

test_centered_rect function · rust · L367-L375 (9 LOC)

src/ui.rs

    fn test_centered_rect() {
        let area = Rect::new(0, 0, 100, 50);
        let popup = centered_rect(50, 60, area);
        // Should be centered and smaller than the full area
        assert!(popup.width <= 50);
        assert!(popup.height <= 30);
        assert!(popup.x > 0);
        assert!(popup.y > 0);
    }

‹ prevpage 3 / 3