text stringlengths 14 100k | source stringclasses 1
value | repo stringclasses 810
values | language stringclasses 13
values |
|---|---|---|---|
<|fim_prefix|>document.addEventListener('DOMContentLoaded', function() {
let currentMode = 'view'; // 'view', 'select', 'detail'
let selectedRows = new Set(); // Store indices of selected rows
const MAX_DISPLAY_COST_CAP = 200; // Define the constant here
const allMainRows = document.querySelectorAll('tr[id^="m... | fim | Aider-AI/aider | javascript |
<|fim_suffix|> }
}
});
}
}
// Initial chart render
updateChart('');
// Connect search input to chart filtering
document.getElementById('quantSearchInput').addEventListener('keyup', function() {
updateChart(this.value);
});
});
<|fim_prefix|>document.addEventListener('DOMContentLoaded... | fim | Aider-AI/aider | javascript |
document.addEventListener('DOMContentLoaded', function () {
var ctx = document.getElementById('qwqChart').getContext('2d');
var allData = [];
{% for row in site.data.qwq %}
allData.push({
model: '{{ row.model }}',
pass_rate_2: {{ row.pass_rate_2 }}
});
{% endfor %}
// Sort data by pass_ra... | fim | Aider-AI/aider | javascript |
<|fim_prefix|>document.addEventListener('DOMContentLoaded', function() {
let player; // Store player reference to make it accessible to click handlers
let globalAudio; // Global audio element to be reused
// Detect if device likely has no physical keyboard
function detectNoKeyboard() {
// Check if it's a... | fim | Aider-AI/aider | javascript |
#!/usr/bin/env python3
import datetime
import json
import os
import random
import re
import shutil
import subprocess
import sys
import time
import traceback
from collections import defaultdict
from json.decoder import JSONDecodeError
from pathlib import Path
from types import SimpleNamespace
from typing import List, Op... | fim | Aider-AI/aider | python |
from dataclasses import dataclass
from datetime import date
from typing import Dict, List, Tuple
import matplotlib.pyplot as plt
import yaml
from imgcat import imgcat
from matplotlib import rc
@dataclass
class ModelData:
name: str
release_date: date
pass_rate: float
@property
def color(self) -> ... | fim | Aider-AI/aider | python |
<|fim_suffix|>ies:
zorder += 1
print(df)
num_models, _ = df.shape
num_formats = 1
pos = np.array(range(num_models))
width = 0.6 / num_formats
if zorder > 1:
edge = dict(
edgecolor="#ffffff",
linewidth=1.5,
... | fim | Aider-AI/aider | python |
<|fim_prefix|>#!/usr/bin/env python
import argparse
import json
import shutil
from collections import defaultdict
from pathlib import Path
import yaml
from aider.dump import dump # noqa
HARD_SET_NUM = 3 # Number of models that defines the hard set threshold
def get_dirs_from_leaderboard():
# Load the leader... | fim | Aider-AI/aider | python |
<|fim_suffix|>e errors.
"""
<|fim_prefix|>instructions_addendum = """
####
Use the above instructions to modify the supplied files: {file_list}
Don't change the names of existing functions or classes, as they may be referenced from other code like unit tests, etc.
Only use standard libraries, don't suggest installing ... | fim | Aider-AI/aider | python |
<|fim_prefix|>#!/usr/bin/env python
import ast
import os
import shutil
import sys
from pathlib import Path
from aider.dump import dump # noqa: F401
class ParentNodeTransformer(ast.NodeTransformer):
"""
This transformer sets the 'parent' attribute on each node.
"""
def generic_visit(self, node):
... | fim | Aider-AI/aider | python |
<|fim_suffix|>"diff",
# "diff-func",
# "whole",
# "whole-func",
]
# for repeat in range(1, 2, 1):
for model in models:
for edit_format in edit_formats:
# dump(model, edit_format)
if "-func" in edit_format and "-03" in model:
continue
... | fim | Aider-AI/aider | python |
<|fim_suffix|>avefig(out_fname.with_suffix(".jpg").name)
plt.savefig(out_fname.with_suffix(".svg").name)
imgcat(fig)
ax.xaxis.label.set_color(font_color)
fname = sys.argv[1]
is_lite = "lite" in fname
plot_swe_bench(fname, is_lite)
<|fim_prefix|>import sys
from pathlib import Path
import matplotlib.pyplo... | fim | Aider-AI/aider | python |
<|fim_prefix|># flake8: noqa: E501
import unittest
from benchmark import cleanup_test_output
class TestCleanupTestOutput(unittest.TestCase):
def test_cleanup_test_output(self):
# Test case with timing info
output = "Ran 5 tests in 0.003s\nOK"
expected = "\nOK"
self.assertEqual(cl... | fim | Aider-AI/aider | python |
<|fim_prefix|>#!/usr/bin/env python
# flake8: noqa: E501
"""
Generate a celebratory SVG image for Aider reaching 30,000 GitHub stars.
This creates a shareable social media graphic with confetti animation.
"""
import argparse
import base64
import math
import random
from pathlib import Path
# Default colors for the cel... | fim | Aider-AI/aider | python |
<|fim_prefix|>#!/usr/bin/env python3
import argparse
import os
import subprocess
import sys
from collections import defaultdict
from datetime import datetime
from operator import itemgetter
import semver
import yaml
from tqdm import tqdm
website_files = [
"aider/website/index.html",
"aider/website/share/inde... | fim | Aider-AI/aider | python |
<|fim_prefix|>#!/usr/bin/env python
import difflib
import json
import re
from pathlib import Path
import json5
def find_block_lines(lines, key_to_remove):
"""Finds the start and end line indices for a top-level key's block."""
start_line_idx = -1
# Regex to find the line starting the key definition, all... | fim | Aider-AI/aider | python |
<|fim_suffix|>on_name}.svg to {output_path}")
return True
def main():
print(f"Downloading icons to {ICONS_DIR}")
success_count = 0
for icon in ICONS:
if download_icon(icon):
success_count += 1
print(f"Successfully downloaded {success_count}/{len(ICONS)} icons")
if __name__ ... | fim | Aider-AI/aider | python |
<|fim_prefix|>history_prompt = """
Update the history markdown doc with changes shown in the diffs.
Succinctly describe actual user-facing changes, not every single commit or detail that was made implementing them.
Only add new items not already listed in the history markdown.
Do NOT edit or update existing history en... | fim | Aider-AI/aider | python |
<|fim_prefix|>#!/usr/bin/env python3
import argparse
import json
import os
import sys
import time
from datetime import datetime
import requests
import yaml
from dotenv import load_dotenv
from google.cloud import bigquery
from google.oauth2 import service_account
TOKENS_PER_<|fim_suffix|>ef get_cache_path(package_nam... | fim | Aider-AI/aider | python |
<|fim_suffix|>{REPO_NAME}/issues/{issue['number']}/comments"
)
comment = CLOSE_FIXED_ENHANCEMENT_COMMENT if is_enhancement else CLOSE_FIXED_BUG_COMMENT
response = requests.post(comment_url, headers=headers, json={"body": comment})
response.raise_for_status()
... | fim | Aider-AI/aider | python |
<|fim_prefix|>#!/usr/bin/env python3
"""
Script to generate an SVG logo for Aider with embedded font.
Reads the Glass_TTY_VT220.ttf font, subsets it to only include the letters needed,
and creates an SVG with the word "aider" in terminal green (#14b014) on a transparent background.
"""
import argparse
import base64
im... | fim | Aider-AI/aider | python |
#!/usr/bin/env python3
import json
from collections import defaultdict, deque
from pathlib import Path
def collect_model_stats(n_lines=1000):
"""Collect model usage statistics from the analytics file."""
analytics_path = Path.home() / ".aider" / "analytics.jsonl"
model_stats = defaultdict(int)
with ... | fim | Aider-AI/aider | python |
<|fim_prefix|>#!/usr/bin/env python3
"""
Generate TTS audio files for recording commentary using OpenAI's API.
Usage: python scripts/recording_audio.py path/to/recording.md
"""
import argparse
import json
import os
import re
import subprocess
import tempfile
from pathlib import Path
import requests
from dotenv import... | fim | Aider-AI/aider | python |
<|fim_prefix|>#!/usr/bin/env python3
import json
import sys
import pyte
from tqdm import tqdm
from aider.dump import dump # noqa
def main():
if len(sys.argv) != 3:
print(f"Usage: {sys.argv[0]} input_cast_file output_cast_file")
sys.exit(1)
input_file = sys.argv[1]
output_file = sys.arg... | fim | Aider-AI/aider | python |
#!/usr/bin/env python3
import json
import os
import sys
import time
import requests
def get_default_branch(owner, repo):
"""Get the default branch of a GitHub repository using the API."""
api_url = f"https://api.github.com/repos/{owner}/{repo}"
try:
response = requests.get(api_url)
respo... | fim | Aider-AI/aider | python |
<|fim_prefix|>#!/usr/bin/env python3
import os
import re
import subprocess
import sys
import tempfile
from history_prompts import history_prompt
def get_latest_version_from_history():
with open("HISTORY.md", "r") as f:
history_content = f.read()
# Find most recent version header
match = re.sear... | fim | Aider-AI/aider | python |
<|fim_prefix|>#!/usr/bin/env python
import argparse
import datetime
import os
import re
import subprocess
import sys
from packaging import version
# Function to check if we are on the main branch
def check_branch():
branch = subprocess.run(
["git", "rev-parse", "--abbrev-ref", "HEAD"], capture_output=Tr... | fim | Aider-AI/aider | python |
import requests
from packaging import version
from packaging.specifiers import SpecifierSet
def get_versions_supporting_python38_or_lower(package_name):
url = f"https://pypi.org/pypi/{package_name}/json"
response = requests.get(url)
if response.status_code != 200:
print(f"Failed to fetch data for ... | fim | Aider-AI/aider | python |
<|fim_suffix|>est_analytics_event_logging(temp_analytics_file, temp_data_dir):
analytics = Analytics(logfile=temp_analytics_file)
analytics.asked_opt_in = True
analytics.enable()
test_event = "test_event"
test_properties = {"test_key": "test_value"}
# with patch.object(analytics.mp, "track") a... | fim | Aider-AI/aider | python |
<|fim_suffix|>m.validate_environment") as mock_validate:
# Mock the litellm validate_environment to return missing AWS keys
mock_validate.return_value = {
"missing_keys": ["AWS_ACCESS_KEY_ID", "AWS_SECRET_ACCESS_KEY"],
"keys_in_environment": False,... | fim | Aider-AI/aider | python |
<|fim_suffix|>lize_language(self):
coder = Coder.create(self.GPT35, None, io=InputOutput())
# Test None and empty
self.assertIsNone(coder.normalize_language(None))
self.assertIsNone(coder.normalize_language(""))
# Test "C" and "POSIX"
self.assertIsNone(coder.normalize_l... | fim | Aider-AI/aider | python |
<|fim_suffix|> self.assertEqual(len(coder.abs_read_only_fnames), 0)
# Test with vision model
vision_model = Model("gpt-4o")
vision_coder = Coder.create(vision_model, None, io)
vision_commands = Commands(io, vision_coder)
vision_commands.cmd_read_onl... | fim | Aider-AI/aider | python |
import os
from unittest import TestCase
from unittest.mock import MagicMock, patch
from prompt_toolkit.input import DummyInput
from prompt_toolkit.output import DummyOutput
from aider.deprecated import handle_deprecated_model_args
from aider.dump import dump # noqa
from aider.main import main
class TestDeprecated(... | fim | Aider-AI/aider | python |
<|fim_prefix|># flake8: noqa: E501
import tempfile
import unittest
from pathlib import Path
from unittest.mock import MagicMock, patch
from aider.coders import Coder
from aider.coders import editblock_coder as eb
from aider.dump import dump # noqa: F401
from aider.io import InputOutput
from aider.models import Model... | fim | Aider-AI/aider | python |
<|fim_suffix|> assert "Failed!" in captured.out
def test_discover_editor_override():
# Test editor override
assert discover_editor("code") == "code"
assert discover_editor('vim -c "set noswapfile"') == 'vim -c "set noswapfile"'
def test_pipe_editor_with_fake_editor():
# Create a temporary Python ... | fim | Aider-AI/aider | python |
<|fim_suffix|> message="Context length exceeded", model="gpt-4", llm_provider="openai"
)
ex_info = ex.get_ex_info(ctx_error)
assert ex_info.retry is False
def test_openrouter_error():
"""Test specific handling of OpenRouter API errors"""
ex = LiteLLMExceptions()
from litellm import APICon... | fim | Aider-AI/aider | python |
<|fim_suffix|> expected_output = f.read()
# Compare the actual and expected outputs
if actual_output != expected_output:
# If they're different, create a diff
diff = difflib.unified_diff(
expected_output.splitlines(keepends=True),
actual_outpu... | fim | Aider-AI/aider | python |
<|fim_prefix|>from unittest import TestCase, mock
from aider.history import ChatSummary
from aider.models import Model
def count(msg):
if isinstance(msg, list):
return sum(count(m) for m in msg)
return len(msg["content"].split())
class TestChatSummary(TestCase):
def setUp(self):
self.mo... | fim | Aider-AI/aider | python |
<|fim_suffix|> self.assertIsInstance(renderables[2], Text)
self.assertEqual(renderables[2].plain, "ro[markup].txt")
@patch("aider.io.Columns")
@patch("os.path.abspath")
@patch("os.path.join")
def test_format_files_for_input_pretty_true_mixed_files(
self, mock_join, mock_abspath, mock_c... | fim | Aider-AI/aider | python |
<|fim_prefix|>import os
import unittest
from unittest.mock import MagicMock, patch
from aider.dump import dump # noqa
from aider.linter import Linter
class TestLinter(unittest.TestCase):
def setUp(self):
self.linter = Linter(encoding="utf-8", root="/test/root")
def test_init(self):
self.ass... | fim | Aider-AI/aider | python |
<|fim_prefix|>import json
import os
import subprocess
import tempfile
from io import StringIO
from pathlib import Path
from unittest import TestCase
from unittest.mock import MagicMock, patch
import git
from prompt_toolkit.input import DummyInput
from prompt_toolkit.output import DummyOutput
from aider.coders import ... | fim | Aider-AI/aider | python |
<|fim_prefix|>import os
import tempfile
from pathlib import Path
from unittest import TestCase
from unittest.mock import MagicMock, patch
from aider.models import ModelInfoManager
class TestModelInfoManager(TestCase):
def setUp(self):
self.original_env = os.environ.copy()
self.manager = ModelInfo... | fim | Aider-AI/aider | python |
<|fim_suffix|>use_temperature)
# Test use_temperature as float value
model = Model("gpt-4")
model.use_temperature = 0.7
self.assertEqual(model.use_temperature, 0.7)
@patch("aider.models.litellm.completion")
def test_request_timeout_default(self, mock_completion):
# Test... | fim | Aider-AI/aider | python |
<|fim_suffix|>args, io_mock, analytics_mock)
self.assertEqual(selected_model, "specific-model")
mock_try_select.assert_not_called()
mock_offer_oauth.assert_not_called()
@patch("aider.onboarding.try_to_select_default_model", return_value="gpt-4o")
@patch("aider.onboarding.offer_openroute... | fim | Aider-AI/aider | python |
<|fim_prefix|>from pathlib import Path
from aider.models import ModelInfoManager
from aider.openrouter import OpenRouterModelManager
class DummyResponse:
"""Minimal stand-in for requests.Response used in tests."""
def __init__(self, json_data):
self.status_code = 200
self._json_data = json_d... | fim | Aider-AI/aider | python |
import unittest
from unittest.mock import MagicMock, patch
from aider.coders.base_coder import Coder
from aider.dump import dump # noqa
from aider.io import InputOutput
from aider.models import Model
from aider.reasoning_tags import (
REASONING_END,
REASONING_START,
remove_reasoning_content,
)
class Tes... | fim | Aider-AI/aider | python |
<|fim_prefix|>import os
import platform
import tempfile
import time
import unittest
from pathlib import Path
from unittest.mock import MagicMock, patch
import git
from aider.dump import dump # noqa: F401
from aider.io import InputOutput
from aider.models import Model
from aider.repo import GitRepo
from aider.utils i... | fim | Aider-AI/aider | python |
<|fim_suffix|> Path(__file__).parent.parent / "fixtures" / "sample-code-base-repo-map.txt"
)
# Ensure the paths exist
self.assertTrue(sample_code_base.exists(), "Sample code base directory not found")
self.assertTrue(expected_map_file.exists(), "Expected repo map file not found")
... | fim | Aider-AI/aider | python |
<|fim_prefix|>import pytest # noqa: F401
from aider.run_cmd import run_cmd
def test_run_cmd_echo(<|fim_suffix|>orld!"
<|fim_middle|>):
command = "echo Hello, World!"
exit_code, output = run_cmd(command)
assert exit_code == 0
assert output.strip() == "Hello, W<|endoftext|> | fim | Aider-AI/aider | python |
<|fim_prefix|>import os
import shutil
import struct
from unittest import mock
import pytest
from git import GitError, Repo
from aider import urls
from aider.main import sanity_check_repo
@pytest.fixture
def mock_io():
"""Fixture to create a mock io object."""
return mock.Mock()
@pytest.fixture
def create_... | fim | Aider-AI/aider | python |
import unittest
from pathlib import Path
from unittest.mock import patch
from aider.coders import Coder
from aider.models import Model
from aider.utils import GitTemporaryDirectory
class TestScriptingAPI(unittest.TestCase):
@patch("aider.coders.base_coder.Coder.send")
def test_basic_scripting(self, mock_send... | fim | Aider-AI/aider | python |
<|fim_prefix|>import unittest
from unittest.mock import MagicMock, patch
from aider.exceptions import LiteLLMExceptions
from aider.llm import litellm
from aider.models import Model
class PrintCalled(Exception):
pass
class TestSendChat(unittest.TestCase):
def setUp(self):
self.mock_messages = [{"rol... | fim | Aider-AI/aider | python |
<|fim_prefix|>import os
import pytest
from<|fim_suffix|>.md")
assert is_important(".gitignore")
assert not is_important(".GITIGNORE")
def test_is_important_with_paths():
# Test with different path formats
assert not is_important("project/README.md")
assert is_important("./README.md")
assert ... | fim | Aider-AI/aider | python |
<|fim_suffix|>rror
mock_model.return_value.info = {}
mock_model.return_value.validate_environment.return_value = {
"missing_keys": [],
"keys_in_environment": [],
}
with patch("aider.llm.litellm._lazy_module", mock_module):
... | fim | Aider-AI/aider | python |
<|fim_suffix|>"--check-update",
+ action="store_true",
+ help="Check for updates and return status in the exit code",
+ default=False,
+ )
other_group.add_argument(
"--apply",
metavar="FILE",
```
These changes will add the `--check-update` option to the command-line inter... | fim | Aider-AI/aider | python |
import requests
from aider import urls
def test_urls():
url_attributes = [
attr
for attr in dir(urls)
if not callable(getattr(urls, attr)) and not attr.startswith("__")
]
for attr in url_attributes:
url = getattr(urls, attr)
response = requests.get(url)
ass... | fim | Aider-AI/aider | python |
<|fim_suffix|>_a = tmp_path / "link_a"
link_b = tmp_path / "link_b"
link_a.symlink_to(link_b)
link_b.symlink_to(link_a)
# safe_abs_path must not raise, and must return an absolute path
result = safe_abs_path(str(link_a))
assert os.path.isabs(result)
<|fim_prefix|>import os
from aider.utils imp... | fim | Aider-AI/aider | python |
<|fim_prefix|>import os
import queue
from unittest.mock import MagicMock, patch
import numpy as np
import pytest
from aider.voice import SoundDeviceError, Voice
# Mock the entire sounddevice module
@pytest.fixture
def mock_sounddevice():
mock_sd = MagicMock()
mock_sd.query_devices.return_value = [
{... | fim | Aider-AI/aider | python |
<|fim_suffix|>le("src/main.py")
assert not spec.match_file("docs/index.html")
# Cleanup
tmp_gitignore.unlink()
def test_get_roots_to_watch(tmp_path):
# Create a test directory structure
(tmp_path / "included").mkdir()
(tmp_path / "excluded").mkdir()
io = InputOutput(pretty=False, fancy_i... | fim | Aider-AI/aider | python |
<|fim_suffix|>io, fnames=[sample_file])
# Set the partial response content with the updated content
# With path/to/ prepended onto the filename
coder.partial_response_content = f"path/to/{sample_file}\n```\nUpdated content\n```"
# Call update_files method
edited_files = coder.a... | fim | Aider-AI/aider | python |
<|fim_prefix|>import os
import unittest
from unittest.mock import patch
from aider.main import main
class TestBrowser(unittest.TestCase):
@patch("aider.main.launch_gui")
def test_browser_flag_imports_streamlit(self, mock_launch_gui):
os.environ["AIDER_ANALYTICS"] = "false"
# Run main with --... | fim | Aider-AI/aider | python |
<|fim_prefix|>#include <stdio.h>
int main() {
printf("Hello, World!\n");
return 0;
}
#include <stdio.h>
/**
* The main entry point of the program
* @return 0 on success
*/
int main(int argc, char **argv) {
printf("Hello, World<|fim_suffix|>e) {
printf("%s\n", message);
}
<|fim_middle|>!\n");
re... | fim | Aider-AI/aider | c |
<|fim_suffix|> std::endl;
return 0;
}
<|fim_prefix|>#include <iostream>
int main() {
std::cout << "Hello, World!" <<|fim_middle|><<|endoftext|> | fim | Aider-AI/aider | cpp |
<|fim_prefix|>using System;
using System.Collections.Generic;
namespace Greetings {
public interface IGreeter {
string Greet(string name);
}
public class Person {
public string Name { get; set; }
public int Age { get; set; }
public Person(string name, int age) {
... | fim | Aider-AI/aider | csharp |
<|fim_prefix|>package main
import (
<|fim_suffix|> FormalGreeter struct {
Prefix string
}
const (
DefaultName = "World"
MaxAge = 150
)
func (g FormalGreeter) Greet(p Person) string {
return fmt.Sprintf("%s, %s! You are %d years old.",
g.Prefix, p.Name, p.Age)
}
func NewFormalGreeter() *F... | fim | Aider-AI/aider | go |
public interface Greeting {
String greet(String name);
}
public class Test implements Greeting {
private String prefix = "Hello";
public String greet(String name) {
return prefix + ", " + name + "!";
}
public static void main(String[] args) {
Test greeter = new Test();
Sys... | fim | Aider-AI/aider | java |
<|fim_suffix|>);
// Export for use in other modules
module.exports = {
Person,
greet,
DEFAULT_NAME
};
<|fim_prefix|>// Class definition
class Person {
constructor(name) {
this.name = name;
}
sayHello() {
return `Hello, ${this.name}!`;
<|fim_middle|> }
}
// Function declarat... | fim | Aider-AI/aider | javascript |
<|fim_suffix|>o, $name!";
}
?>
<|fim_prefix|><?php
function greet($<|fim_middle|>name) {
echo "Hell<|endoftext|> | fim | Aider-AI/aider | php |
<|fim_suffix|> print(person.greet())
<|fim_prefix|>from typing import List, Optional
class Person:
"""A class representing a person."""
def __init__(self, name: str, age: Optional[int] = None):
self.name = name
self.age = age
def greet(self, formal: bool = False) -> str:
"""Ge... | fim | Aider-AI/aider | python |
<|fim_suffix|>{name}!"
end
<|fim_prefix|>de<|fim_middle|>f greet(name)
puts "Hello, #<|endoftext|> | fim | Aider-AI/aider | ruby |
<|fim_prefix|>// Define a trait
trait Greeting {
fn greet(&self) -> String;
}
// Define a struct
struct Person {
name: String,
age: u32,
}
// Implement the trait for Person
impl Greeting for Person<|fim_suffix|>greet(&self) -> String {
format!("Hello, {}! You are {} years old.", self.name, self.ag... | fim | Aider-AI/aider | rust |
<|fim_suffix|>r(age > 30)
greeter.greet(name) + s" I am $age years old."
}
}
class CasualGreeter extends Greeter {
override def greet(name: String): String = s"Hey, $name!"
}
<|fim_prefix|>package com.example.test
// A trait definition
trait Greeter {
def greet(name: String): Str<|fim_middle|>ing
}
// A cl... | fim | Aider-AI/aider | scala |
import React, { useState, useEffect } from 'react';
interface UserProps {
name: string;
age?: number;
}
// Component with props interface
const UserGreeting: React.FC<UserProps> = ({ name, age }) => {
const [greeting, setGreeting] = useState<string>('');
useEffect(() => {
setGreeting(`Hello, ... | fim | Aider-AI/aider | typescript |
<|fim_suffix|>void {
console.log(`Hello, ${name}!`);
}
<|fim_prefix|>func<|fim_middle|>tion greet(name: string): <|endoftext|> | fim | Aider-AI/aider | typescript |
// Sample JavaScript script with 7 functions
// 1. A simple greeting function
function greet(name) {
return `Hello, ${name}!`;
}
// 2. A function to calculate the area of a circle
function calculateCircleArea(radius) {
return Math.PI * radius * radius;
}
// 3. A function to check if a number is prime
functio... | fim | Aider-AI/aider | javascript |
<|fim_suffix|>garage.add_car(car2)
# List cars in the garage
my_garage.list_cars()
# Remove a car and list again
my_garage.remove_car(car1)
my_garage.list_cars()
if __name__ == "__main__":
main()
<|fim_prefix|>class Car:
def __init__(self, make, model, year):
self.make = make
... | fim | Aider-AI/aider | python |
<|fim_suffix|>return 1;
}
}
// trailing whitespace ai
// trailing whitespace ai!
// 15-16
<|fim_prefix|>// Regular AI comment
//ai do 1 something
//AI make 2 this better
//ai! urgent 3 change needed
//AI! another 4 urgent one
// ai with 5 space
// AI with 6 caps
// ai! with 7 bang
// this is not an ai comment
// ... | fim | Aider-AI/aider | javascript |
<|fim_suffix|> 6 ai!
# final 7 ai
# ai
#ai
# those are 8+9
pass # ai 10
<|fim_prefix|># fmt: off
<|fim_middle|># flake8: noqa
# Regular not AI comment
#ai 1 do something
# AI 2 make this better
# ai! 3 urgent change needed
#AI! 4 another urgent one
# this is not an ai comment
# aider is not an ai ... | fim | Aider-AI/aider | python |
<|fim_prefix|>// Regular AI comment
//ai do 1 something
//AI make 2 this be<|fim_suffix|>t
// aider is not an ai! comment
<|fim_middle|>tter
//ai! urgent 3 change needed
//AI! another 4 urgent one
// ai with 5 space
// with questions AI?
// this is not an ai commen<|endoftext|> | fim | Aider-AI/aider | javascript |
<|fim_prefix|>import time
import unittest
from unittest.mock import MagicMock
from requests.exceptions import ConnectionError, ReadTimeout
import aider
from aider.coders import Coder
from aider.commands import Commands
from aider.help import Help, fname_to_url
from aider.io import InputOutput
from aider.models import... | fim | Aider-AI/aider | python |
<|fim_prefix|>from aider.scrape import Scraper
class DummyIO:
def __init__(self):
self.outputs = []
self.confirmed = False
def tool_output(self, msg):
self.outputs.append(msg)
def confirm_ask(self, msg, default="y"):
self.outputs.append(f"confirm: {msg}")
return s... | fim | Aider-AI/aider | python |
import time
import unittest
from unittest.mock import MagicMock
from aider.commands import Commands
from aider.io import InputOutput
from aider.scrape import Scraper
class TestScrape(unittest.TestCase):
def test_scrape_self_signed_ssl(self):
def scrape_with_retries(scraper, url, max_retries=5, delay=0.5)... | fim | Aider-AI/aider | python |
<|fim_prefix|>#pragma once
#include <gtkmm/box.h>
#include <gtkmm/image.h>
#include "AIconLabel.hpp"
namespace waybar {
class AAppIconLabel : public AIconLabel {
public:
AAppIconLabel(const Json::Value& config, const std::string& name, <|fim_suffix|>int16_t interval = 0, bool ellipsize = false,
b... | fim | Alexays/Waybar | cpp |
<|fim_prefix|>#pragma once
#include <gtkmm/box.h>
#include <gtkmm/image.h>
#include "ALabel.hpp"
namespace wayba<|fim_suffix|>l {
public:
AIconLabel(const Json::Value& config, const std::string& name, const std::string& id,
const std::string& format, uint16_t interval = 0, bool ellipsize = false,
... | fim | Alexays/Waybar | cpp |
<|fim_prefix|>#pragma once
#include <glibmm/markup.h>
#include <gtkmm/label.h>
#include <|fim_suffix|>uint16_t max = 0);
virtual std::string getIcon(uint16_t, const std::vector<std::string>& alts, uint16_t max = 0);
protected:
Gtk::Label label_;
std::string format_;
const std::chrono::milliseconds interval_;... | fim | Alexays/Waybar | cpp |
<|fim_suffix|>DK_3BUTTON_PRESS), "on-triple-click-right"},
{std::make_pair(8, GdkEventType::GDK_BUTTON_PRESS), "on-click-backward"},
{std::make_pair(8, GdkEventType::GDK_BUTTON_RELEASE), "on-click-backward-release"},
{std::make_pair(8, GdkEventType::GDK_2BUTTON_PRESS), "on-double-click-backward"},
... | fim | Alexays/Waybar | cpp |
<|fim_prefix|>#pragma once
#include "AModule.hpp"
#include "gtkmm/scale.h"
namespace waybar {
class ASlider : public AModule {
public:
ASlider(const Json::Value& config, const std::string& name, const std::string& id);
vir<|fim_suffix|>
protected:
bool vertical_ = false;
int min_ = 0, max_ = 100, curr_ = 5... | fim | Alexays/Waybar | cpp |
#pragma once
#include <gtkmm/widget.h>
namespace waybar {
class IModule {
public:
virtual ~IModule() = default;
virtual auto update() -> void = 0;
virtual operator Gtk::Widget&() = 0;
virtual auto doAction(const std::string& name) -> void = 0;
};
} // namespace waybar
<|endoftext|> | fim | Alexays/Waybar | cpp |
<|fim_suffix|>or;
std::string name;
std::string identifier;
std::unique_ptr<struct zxdg_output_v1, decltype(&zxdg_output_v1_destroy)> xdg_output = {
nullptr, &zxdg_output_v1_destroy};
};
enum class bar_layer : uint8_t {
BOTTOM,
TOP,
OVERLAY,
};
struct bar_margins {
int top = 0;
int right = 0;
... | fim | Alexays/Waybar | cpp |
<|fim_prefix|>#pragma once
#include <fmt/format.h>
#include <gdk/gdk.h>
#include <gdk/gdkwayland.h>
#include <wayland-client.h>
#include "bar.hpp"
#include "config.hpp"
#include "util/css_reload_helper.hpp"
#include "util/portal.hpp"
struct zwp_idle_inhibitor_v1;
struct zwp_idle_inhibit_manager_v1;
namespace waybar... | fim | Alexays/Waybar | cpp |
#pragma once
#include <json/json.h>
#include <optional>
#include <string>
#ifndef SYSCONFDIR
#define SYSCONFDIR "/etc"
#endif
namespace waybar {
class Config {
public:
static const std::vector<std::string> CONFIG_DIRS;
static const char* CONFIG_PATH_ENV;
/* Try to find any of provided names in the supporte... | fim | Alexays/Waybar | cpp |
#pragma once
#include <json/json.h>
#include <AModule.hpp>
namespace waybar {
class Bar;
class Factory {
public:
Factory(const Bar& bar, const Json::Value& config);
AModule* makeModule(const std::string& name, const std::string& pos) const;
private:
const Bar& bar_;
const Json::Value& config_;
};
} //... | fim | Alexays/Waybar | cpp |
<|fim_prefix|>#pragma once
#include <gtkmm/box.h>
#include <gtkmm/widget.h>
#include <json/json.h>
#include "AModule.hpp"
#include "gtkmm/revealer.h"
namespace waybar {
class Group : public AModule {
public:
Group(const std::string&, const std::string&, const Json::Value&, bool);
~Group() override = default;
... | fim | Alexays/Waybar | cpp |
<|fim_prefix|>#pragma once
#include <memory>
#include <optional>
#include <string>
#incl<|fim_suffix|>e() -> void override;
bool handleScroll(GdkEventScroll* e) override;
const std::string preferred_device_;
std::string previous_format_;
util::BacklightBackend backend;
};
} // namespace waybar::modules
<|... | fim | Alexays/Waybar | cpp |
<|fim_suffix|>rval_;
std::string preferred_device_;
util::BacklightBackend backend;
};
} // namespace waybar::modules<|fim_prefix|>#pragma once
#include <chrono>
#include "ASlider.hpp"
#include "util/backlight_ba<|fim_middle|>ckend.hpp"
namespace waybar::modules {
class BacklightSlider : public ASlider {
pub... | fim | Alexays/Waybar | cpp |
<|fim_prefix|>#pragma once
#include <fmt/format.h>
#include <filesystem>
#if defined(__linux__)
#include <sys/inotify.h>
#endif
#include <poll.h>
#include <algorithm>
#include <fstream>
#include <string>
#inclu<|fim_suffix|>& bar_;
util::SleeperThread thread_;
util::SleeperThread thread_battery_update_;
util:... | fim | Alexays/Waybar | cpp |
<|fim_prefix|>#pragma once
#include "ALabel.hpp"
#ifdef WANT_RFKILL
#include "util/rfkill.hpp"
#endif
#include <gio/gio.h>
#include <optional>
#include <string>
#include <vector>
namespace waybar::modules {
class Bluetooth : public ALabel {
struct ControllerInfo {
std::string path;
std::string address;
... | fim | Alexays/Waybar | cpp |
<|fim_prefix|>#pragma once
#include <epoxy/gl.h>
#include "AModule.hpp"
#include "cava_backend.hpp"
namespace waybar::modules::cava {
class CavaGLSL final : public AModule, public Gtk::GLArea {
public:
CavaGLSL(const std::string&, const Json::Value&);
~CavaGLSL() = default;
private:
std::shared_ptr<Cav<|fi... | fim | Alexays/Waybar | cpp |
<|fim_suffix|>cava::Cava::pause_resume}};
};
} // namespace waybar::modules::cava
<|fim_prefix|>#pragma once
#include "ALabel.hpp"
#include "cava_backend.hpp"
namespace waybar::modules::cava {
class Cava final : public ALabel, public sigc::trackable {
public:
Cava(const<|fim_middle|> std::string&, const Json::Va... | fim | Alexays/Waybar | cpp |
<|fim_suffix|>onds fetch_input_delay_{4};
// Delay to handle audio source
std::chrono::milliseconds frame_time_milsec_{1s};
const Json::Value& config_;
int re_paint_{0};
bool silence_{false};
bool silence_prev_{false};
std::chrono::seconds suspend_silence_delay_{0};
int sleep_counter_{0};
std::string... | fim | Alexays/Waybar | cpp |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.