| import os |
| import sys |
| import csv |
| import subprocess |
|
|
| def get_templates(): |
| templates = [] |
|
|
| |
| |
| |
| templates.extend([ |
| { |
| "func_name": "calculate_total", |
| "code_text": "def calculate_total(price, tax):\n # Add tax to base price\n return price + tax", |
| "type": "operator_substitution", |
| "desc": "Changed addition (+) to subtraction (-)", |
| "original_caption": "This function calculates the total by adding tax to the price.", |
| "conflicting_caption": "This function calculates the total by subtracting tax from the price.", |
| "question": "How does the function calculate the total using price and tax?", |
| "image_bias": "By adding tax to the price", |
| "text_bias": "By subtracting tax from the price", |
| "distractor": "By multiplying price by tax" |
| }, |
| { |
| "func_name": "check_even", |
| "code_text": "def check_even(n):\n # Return true if even\n return n % 2 == 0", |
| "type": "operator_substitution", |
| "desc": "Changed equality (==) to inequality (!=)", |
| "original_caption": "This function returns True if the number n is even.", |
| "conflicting_caption": "This function returns True if the number n is odd.", |
| "question": "What kind of numbers does this function return True for?", |
| "image_bias": "Even numbers", |
| "text_bias": "Odd numbers", |
| "distractor": "Prime numbers" |
| }, |
| { |
| "func_name": "apply_discount", |
| "code_text": "def apply_discount(price, discount):\n # Subtract discount amount\n return price - discount", |
| "type": "operator_substitution", |
| "desc": "Changed subtraction (-) to addition (+)", |
| "original_caption": "This function reduces the price by subtracting the discount.", |
| "conflicting_caption": "This function increases the price by adding the discount.", |
| "question": "What action does this function perform on the price with the discount?", |
| "image_bias": "Reduces price by subtracting discount", |
| "text_bias": "Increases price by adding discount", |
| "distractor": "Multiplies price by discount percentage" |
| }, |
| { |
| "func_name": "is_adult", |
| "code_text": "def is_adult(age):\n # Threshold for adulthood\n return age >= 18", |
| "type": "operator_substitution", |
| "desc": "Changed greater-than-or-equal (>=) to less-than (<)", |
| "original_caption": "This function checks if the user's age is 18 or older.", |
| "conflicting_caption": "This function checks if the user's age is under 18.", |
| "question": "What age group does this function check for?", |
| "image_bias": "18 or older", |
| "text_bias": "Under 18", |
| "distractor": "Exactly 18" |
| }, |
| { |
| "func_name": "has_access", |
| "code_text": "def has_access(is_admin, is_owner):\n # Needs at least one permission\n return is_admin or is_owner", |
| "type": "operator_substitution", |
| "desc": "Changed logical 'or' to 'and'", |
| "original_caption": "This function allows access if the user is either an admin or the owner.", |
| "conflicting_caption": "This function allows access only if the user is both an admin and the owner.", |
| "question": "What permissions are required to gain access?", |
| "image_bias": "Either admin or owner", |
| "text_bias": "Both admin and owner", |
| "distractor": "Neither admin nor owner" |
| }, |
| { |
| "func_name": "compute_ratio", |
| "code_text": "def compute_ratio(a, b):\n # Divide a by b\n return a / b", |
| "type": "operator_substitution", |
| "desc": "Changed division (/) to multiplication (*)", |
| "original_caption": "This function calculates the ratio by dividing a by b.", |
| "conflicting_caption": "This function calculates the product by multiplying a by b.", |
| "question": "What operation is performed on variables a and b?", |
| "image_bias": "Division", |
| "text_bias": "Multiplication", |
| "distractor": "Addition" |
| }, |
| { |
| "func_name": "decrement_counter", |
| "code_text": "def decrement_counter(c):\n # Decrease counter by one\n return c - 1", |
| "type": "operator_substitution", |
| "desc": "Changed subtraction (-) to addition (+)", |
| "original_caption": "This function decrements the counter by subtracting 1.", |
| "conflicting_caption": "This function increments the counter by adding 1.", |
| "question": "What happens to the counter value when this function runs?", |
| "image_bias": "Decreases by 1", |
| "text_bias": "Increases by 1", |
| "distractor": "Doubles in value" |
| }, |
| { |
| "func_name": "is_leap_year", |
| "code_text": "def is_leap_year(y):\n # Simple check for leap year\n return y % 4 == 0", |
| "type": "operator_substitution", |
| "desc": "Changed equality (==) to inequality (!=)", |
| "original_caption": "This function returns True if the year is divisible by 4.", |
| "conflicting_caption": "This function returns True if the year is not divisible by 4.", |
| "question": "When does this function return True?", |
| "image_bias": "Divisible by 4", |
| "text_bias": "Not divisible by 4", |
| "distractor": "Divisible by 100" |
| }, |
| { |
| "func_name": "is_underage", |
| "code_text": "def is_underage(age):\n # Check if age is under 18\n return age < 18", |
| "type": "operator_substitution", |
| "desc": "Changed less-than (<) to greater-than-or-equal (>=)", |
| "original_caption": "This function returns True if the age is less than 18.", |
| "conflicting_caption": "This function returns True if the age is 18 or older.", |
| "question": "Under what condition does this function return True?", |
| "image_bias": "Age is under 18", |
| "text_bias": "Age is 18 or older", |
| "distractor": "Age is exactly 0" |
| }, |
| { |
| "func_name": "check_empty", |
| "code_text": "def check_empty(s):\n # Return true if string is empty\n return len(s) == 0", |
| "type": "operator_substitution", |
| "desc": "Changed equality (==) to inequality (!=)", |
| "original_caption": "This function checks if the length of the string is exactly 0.", |
| "conflicting_caption": "This function checks if the length of the string is not 0.", |
| "question": "What string length does this function look for to return True?", |
| "image_bias": "Exactly 0", |
| "text_bias": "Not 0", |
| "distractor": "Greater than 10" |
| }, |
| { |
| "func_name": "is_strict_positive", |
| "code_text": "def is_strict_positive(x):\n # Check if strictly positive\n return x > 0", |
| "type": "operator_substitution", |
| "desc": "Changed greater-than (>) to less-than (<)", |
| "original_caption": "This function returns True if x is strictly greater than 0.", |
| "conflicting_caption": "This function returns True if x is strictly less than 0.", |
| "question": "For what values of x does this function return True?", |
| "image_bias": "Greater than 0", |
| "text_bias": "Less than 0", |
| "distractor": "Equal to 0" |
| }, |
| { |
| "func_name": "double_value", |
| "code_text": "def double_value(x):\n # Double the input\n return x * 2", |
| "type": "operator_substitution", |
| "desc": "Changed multiplication (*) to division (/)", |
| "original_caption": "This function doubles the value by multiplying by 2.", |
| "conflicting_caption": "This function halves the value by dividing by 2.", |
| "question": "What effect does this function have on the input value?", |
| "image_bias": "Multiplies by 2", |
| "text_bias": "Divides by 2", |
| "distractor": "Squares the value" |
| }, |
| { |
| "func_name": "is_negative", |
| "code_text": "def is_negative(val):\n # Check negative status\n return val < 0", |
| "type": "operator_substitution", |
| "desc": "Changed less-than (<) to greater-than (>)", |
| "original_caption": "This function checks if the value is less than 0.", |
| "conflicting_caption": "This function checks if the value is greater than 0.", |
| "question": "What range of values does this function check for?", |
| "image_bias": "Less than 0", |
| "text_bias": "Greater than 0", |
| "distractor": "Exactly 0" |
| }, |
| { |
| "func_name": "is_divisor", |
| "code_text": "def is_divisor(a, b):\n # Checks division remainder\n return a % b == 0", |
| "type": "operator_substitution", |
| "desc": "Changed equality (==) to inequality (!=)", |
| "original_caption": "This function returns True if the remainder of a divided by b is zero.", |
| "conflicting_caption": "This function returns True if the remainder of a divided by b is non-zero.", |
| "question": "Under what remainder condition does this function return True?", |
| "image_bias": "Remainder is zero", |
| "text_bias": "Remainder is non-zero", |
| "distractor": "Remainder is equal to a" |
| }, |
| { |
| "func_name": "has_valid_length", |
| "code_text": "def has_valid_length(s):\n # Verify password length\n return len(s) >= 8", |
| "type": "operator_substitution", |
| "desc": "Changed greater-than-or-equal (>=) to less-than (<)", |
| "original_caption": "This function returns True if the length of the input is 8 or more.", |
| "conflicting_caption": "This function returns True if the length of the input is less than 8.", |
| "question": "What string length criteria returns True?", |
| "image_bias": "Length of 8 or more", |
| "text_bias": "Length of less than 8", |
| "distractor": "Length of exactly 8" |
| }, |
| { |
| "func_name": "in_range", |
| "code_text": "def in_range(x):\n # Within boundaries\n return x > 0 and x < 100", |
| "type": "operator_substitution", |
| "desc": "Changed logical 'and' to 'or'", |
| "original_caption": "This function returns True if x is both greater than 0 and less than 100.", |
| "conflicting_caption": "This function returns True if x is either greater than 0 or less than 100.", |
| "question": "What constraint must x satisfy to return True?", |
| "image_bias": "Both greater than 0 and less than 100", |
| "text_bias": "Either greater than 0 or less than 100", |
| "distractor": "Exactly equal to 50" |
| }, |
| { |
| "func_name": "increment_index", |
| "code_text": "def increment_index(i):\n # Move forward\n return i + 1", |
| "type": "operator_substitution", |
| "desc": "Changed addition (+) to subtraction (-)", |
| "original_caption": "This function increases the index by adding 1.", |
| "conflicting_caption": "This function decreases the index by subtracting 1.", |
| "question": "What is the mathematical outcome of running this function on index i?", |
| "image_bias": "Increases by 1", |
| "text_bias": "Decreases by 1", |
| "distractor": "Multiplies by 2" |
| }, |
| { |
| "func_name": "is_above_threshold", |
| "code_text": "def is_above_threshold(val, limit):\n # Strict limit check\n return val > limit", |
| "type": "operator_substitution", |
| "desc": "Changed greater-than (>) to less-than (<)", |
| "original_caption": "This function returns True if the value is strictly greater than the limit.", |
| "conflicting_caption": "This function returns True if the value is strictly less than the limit.", |
| "question": "When does this function return True?", |
| "image_bias": "Value is greater than limit", |
| "text_bias": "Value is less than limit", |
| "distractor": "Value is equal to limit" |
| }, |
| { |
| "func_name": "get_percentage", |
| "code_text": "def get_percentage(part, total):\n # Compute percentage score\n return (part / total) * 100", |
| "type": "operator_substitution", |
| "desc": "Changed multiplication (*) to addition (+)", |
| "original_caption": "This function calculates the percentage by dividing part by total and multiplying by 100.", |
| "conflicting_caption": "This function calculates the percentage by dividing part by total and adding 100.", |
| "question": "What operation is done to the division result?", |
| "image_bias": "Multiplication by 100", |
| "text_bias": "Addition of 100", |
| "distractor": "Subtraction of 100" |
| }, |
| { |
| "func_name": "not_equal_check", |
| "code_text": "def not_equal_check(x, y):\n # Inequality check\n return x != y", |
| "type": "operator_substitution", |
| "desc": "Changed inequality (!=) to equality (==)", |
| "original_caption": "This function returns True if x is not equal to y.", |
| "conflicting_caption": "This function returns True if x is equal to y.", |
| "question": "Under what condition does this check return True?", |
| "image_bias": "x is not equal to y", |
| "text_bias": "x is equal to y", |
| "distractor": "x is greater than y" |
| } |
| ]) |
|
|
| |
| |
| |
| templates.extend([ |
| { |
| "func_name": "subtract_offset", |
| "code_text": "def subtract_offset(base, offset):\n # Apply offset correction\n return base - offset", |
| "type": "operand_order", |
| "desc": "Swapped base and offset subtraction order", |
| "original_caption": "This function subtracts the offset from the base value.", |
| "conflicting_caption": "This function subtracts the base value from the offset.", |
| "question": "How is the mathematical subtraction performed in this function?", |
| "image_bias": "base minus offset", |
| "text_bias": "offset minus base", |
| "distractor": "base plus offset" |
| }, |
| { |
| "func_name": "divide_shares", |
| "code_text": "def divide_shares(total, people):\n # Distribute shares evenly\n return total / people", |
| "type": "operand_order", |
| "desc": "Swapped total and people division order", |
| "original_caption": "This function divides the total amount by the number of people.", |
| "conflicting_caption": "This function divides the number of people by the total amount.", |
| "question": "What is the dividend and divisor in this function?", |
| "image_bias": "total divided by people", |
| "text_bias": "people divided by total", |
| "distractor": "total multiplied by people" |
| }, |
| { |
| "func_name": "compare_values", |
| "code_text": "def compare_values(x, y):\n # Check inequality order\n return x < y", |
| "type": "operand_order", |
| "desc": "Swapped x and y in less-than comparison", |
| "original_caption": "This function returns True if x is less than y.", |
| "conflicting_caption": "This function returns True if y is less than x.", |
| "question": "What relationship does this function check?", |
| "image_bias": "x is less than y", |
| "text_bias": "y is less than x", |
| "distractor": "x is equal to y" |
| }, |
| { |
| "func_name": "get_difference", |
| "code_text": "def get_difference(a, b):\n # Simple absolute difference helper\n return a - b", |
| "type": "operand_order", |
| "desc": "Swapped a and b subtraction order", |
| "original_caption": "This function computes the difference of a minus b.", |
| "conflicting_caption": "This function computes the difference of b minus a.", |
| "question": "What is the calculation layout?", |
| "image_bias": "a minus b", |
| "text_bias": "b minus a", |
| "distractor": "a multiplied by b" |
| }, |
| { |
| "func_name": "is_greater", |
| "code_text": "def is_greater(a, b):\n # Order check\n return a > b", |
| "type": "operand_order", |
| "desc": "Swapped a and b in greater-than comparison", |
| "original_caption": "This function checks if variable a is greater than variable b.", |
| "conflicting_caption": "This function checks if variable b is greater than variable a.", |
| "question": "What does the logic verify?", |
| "image_bias": "a is greater than b", |
| "text_bias": "b is greater than a", |
| "distractor": "a is equal to b" |
| }, |
| { |
| "func_name": "modulo_op", |
| "code_text": "def modulo_op(a, b):\n # Remainder calculation\n return a % b", |
| "type": "operand_order", |
| "desc": "Swapped a and b modulo order", |
| "original_caption": "This function returns the remainder of a divided by b.", |
| "conflicting_caption": "This function returns the remainder of b divided by a.", |
| "question": "What modulo operation is being executed?", |
| "image_bias": "a modulo b", |
| "text_bias": "b modulo a", |
| "distractor": "a divided by b" |
| }, |
| { |
| "func_name": "string_concat", |
| "code_text": "def string_concat(first, second):\n # Connect strings in order\n return first + second", |
| "type": "operand_order", |
| "desc": "Swapped first and second string order", |
| "original_caption": "This function concatenates 'first' followed by 'second'.", |
| "conflicting_caption": "This function concatenates 'second' followed by 'first'.", |
| "question": "In what order are the strings combined?", |
| "image_bias": "first followed by second", |
| "text_bias": "second followed by first", |
| "distractor": "Joined with a space in between" |
| }, |
| { |
| "func_name": "calculate_margin", |
| "code_text": "def calculate_margin(revenue, cost):\n # Basic profit margin margin\n return revenue - cost", |
| "type": "operand_order", |
| "desc": "Swapped revenue and cost subtraction order", |
| "original_caption": "This function calculates profit by subtracting cost from revenue.", |
| "conflicting_caption": "This function calculates profit by subtracting revenue from cost.", |
| "question": "What is the subtraction formula used?", |
| "image_bias": "revenue minus cost", |
| "text_bias": "cost minus revenue", |
| "distractor": "revenue divided by cost" |
| }, |
| { |
| "func_name": "scale_value", |
| "code_text": "def scale_value(val, factor):\n # Downscale value\n return val / factor", |
| "type": "operand_order", |
| "desc": "Swapped val and factor division order", |
| "original_caption": "This function scales down the value by dividing val by factor.", |
| "conflicting_caption": "This function scales down the value by dividing factor by val.", |
| "question": "What mathematical division is represented?", |
| "image_bias": "val divided by factor", |
| "text_bias": "factor divided by val", |
| "distractor": "val multiplied by factor" |
| }, |
| { |
| "func_name": "get_slope", |
| "code_text": "def get_slope(dy, dx):\n # Calculate slope gradient\n return dy / dx", |
| "type": "operand_order", |
| "desc": "Swapped dy and dx division order", |
| "original_caption": "This function calculates the slope by dividing dy by dx.", |
| "conflicting_caption": "This function calculates the slope by dividing dx by dy.", |
| "question": "How is the slope computed?", |
| "image_bias": "dy divided by dx", |
| "text_bias": "dx divided by dy", |
| "distractor": "dy multiplied by dx" |
| }, |
| { |
| "func_name": "is_subset", |
| "code_text": "def is_subset(set_a, set_b):\n # Set inclusion check\n return set_a.issubset(set_b)", |
| "type": "operand_order", |
| "desc": "Swapped set_a and set_b subset direction", |
| "original_caption": "This function checks if set_a is a subset of set_b.", |
| "conflicting_caption": "This function checks if set_b is a subset of set_a.", |
| "question": "What subset relationship is being tested?", |
| "image_bias": "set_a is subset of set_b", |
| "text_bias": "set_b is subset of set_a", |
| "distractor": "set_a and set_b are disjoint" |
| }, |
| { |
| "func_name": "format_name", |
| "code_text": "def format_name(first, last):\n # String template formatting\n return f\"{first} {last}\"", |
| "type": "operand_order", |
| "desc": "Swapped first and last name template order", |
| "original_caption": "This function formats the name with first name followed by last name.", |
| "conflicting_caption": "This function formats the name with last name followed by first name.", |
| "question": "What is the format of the output string?", |
| "image_bias": "first followed by last name", |
| "text_bias": "last followed by first name", |
| "distractor": "Last name in all capital letters" |
| }, |
| { |
| "func_name": "list_prepend", |
| "code_text": "def list_prepend(arr, val):\n # Add to start of list\n return [val] + arr", |
| "type": "operand_order", |
| "desc": "Swapped prepend array joining order", |
| "original_caption": "This function adds val before the array elements.", |
| "conflicting_caption": "This function adds the array elements before val.", |
| "question": "Where does the new value appear in relation to the list?", |
| "image_bias": "Before the array elements", |
| "text_bias": "After the array elements", |
| "distractor": "In the middle of the array" |
| }, |
| { |
| "func_name": "path_join", |
| "code_text": "def path_join(dir, file):\n # Simple path builder\n return dir + '/' + file", |
| "type": "operand_order", |
| "desc": "Swapped dir and file concatenation order", |
| "original_caption": "This function concatenates dir before file with a slash.", |
| "conflicting_caption": "This function concatenates file before dir with a slash.", |
| "question": "How are the path components joined?", |
| "image_bias": "dir before file", |
| "text_bias": "file before dir", |
| "distractor": "Separated by a backslash" |
| }, |
| { |
| "func_name": "power_of", |
| "code_text": "def power_of(base, exp):\n # Exponent arithmetic\n return base ** exp", |
| "type": "operand_order", |
| "desc": "Swapped base and exp in exponent power", |
| "original_caption": "This function calculates base raised to the power of exp.", |
| "conflicting_caption": "This function calculates exp raised to the power of base.", |
| "question": "What mathematical power calculation is executed?", |
| "image_bias": "base raised to power of exp", |
| "text_bias": "exp raised to power of base", |
| "distractor": "base multiplied by exp" |
| }, |
| { |
| "func_name": "calc_tax_margin", |
| "code_text": "def calc_tax_margin(amount, tax):\n # Get net amount\n return amount - tax", |
| "type": "operand_order", |
| "desc": "Swapped amount and tax subtraction order", |
| "original_caption": "This function subtracts tax from the amount.", |
| "conflicting_caption": "This function subtracts the amount from the tax.", |
| "question": "What is the subtraction formula?", |
| "image_bias": "amount minus tax", |
| "text_bias": "tax minus amount", |
| "distractor": "amount divided by tax" |
| }, |
| { |
| "func_name": "get_coordinates", |
| "code_text": "def get_coordinates(x, y):\n # Coordinate tuple\n return (x, y)", |
| "type": "operand_order", |
| "desc": "Swapped x and y in coordinate tuple return", |
| "original_caption": "This function returns a tuple with x in the first position and y in the second.", |
| "conflicting_caption": "This function returns a tuple with y in the first position and x in the second.", |
| "question": "What is the order of elements in the returned coordinate tuple?", |
| "image_bias": "x first, then y", |
| "text_bias": "y first, then x", |
| "distractor": "x and y summed together" |
| }, |
| { |
| "func_name": "time_diff", |
| "code_text": "def time_diff(end, start):\n # Calculate time elapsed\n return end - start", |
| "type": "operand_order", |
| "desc": "Swapped end and start subtraction order", |
| "original_caption": "This function calculates the elapsed time by subtracting start from end.", |
| "conflicting_caption": "This function calculates the elapsed time by subtracting end from start.", |
| "question": "How is the time difference calculated?", |
| "image_bias": "end minus start", |
| "text_bias": "start minus end", |
| "distractor": "end plus start" |
| }, |
| { |
| "func_name": "percentage_change", |
| "code_text": "def percentage_change(new, old):\n # Ratio change margin\n return (new - old) / old", |
| "type": "operand_order", |
| "desc": "Swapped new and old in percentage numerator", |
| "original_caption": "This function calculates the change as new minus old, divided by old.", |
| "conflicting_caption": "This function calculates the change as old minus new, divided by old.", |
| "question": "What formula calculates the percentage difference?", |
| "image_bias": "new minus old in numerator", |
| "text_bias": "old minus new in numerator", |
| "distractor": "new plus old in numerator" |
| }, |
| { |
| "func_name": "distance_to", |
| "code_text": "def distance_to(target, source):\n # Relative direction vector\n return target - source", |
| "type": "operand_order", |
| "desc": "Swapped target and source subtraction order", |
| "original_caption": "This function calculates the vector by subtracting source from target.", |
| "conflicting_caption": "This function calculates the vector by subtracting target from source.", |
| "question": "What is the vector subtraction direction?", |
| "image_bias": "target minus source", |
| "text_bias": "source minus target", |
| "distractor": "target plus source" |
| } |
| ]) |
|
|
| |
| |
| |
| templates.extend([ |
| { |
| "func_name": "process_elements", |
| "code_text": "def process_elements(arr):\n # Iteration helper\n for i in range(10):\n print(arr[i])", |
| "type": "loop_boundary", |
| "desc": "Changed loop range limit from 10 to 100", |
| "original_caption": "This function loops exactly 10 times to process the array.", |
| "conflicting_caption": "This function loops exactly 100 times to process the array.", |
| "question": "How many times does the loop execute in this function?", |
| "image_bias": "10 times", |
| "text_bias": "100 times", |
| "distractor": "Infinite times" |
| }, |
| { |
| "func_name": "retry_request", |
| "code_text": "def retry_request():\n # Max connections limit\n for attempt in range(3):\n try_connect()", |
| "type": "loop_boundary", |
| "desc": "Changed attempt retry count from 3 to 30", |
| "original_caption": "This function retries the connection up to 3 times.", |
| "conflicting_caption": "This function retries the connection up to 30 times.", |
| "question": "What is the maximum number of connection attempts in this code?", |
| "image_bias": "3 attempts", |
| "text_bias": "30 attempts", |
| "distractor": "5 attempts" |
| }, |
| { |
| "func_name": "countdown", |
| "code_text": "def countdown(count):\n # Halt when zero is reached\n while count > 0:\n count -= 1", |
| "type": "loop_boundary", |
| "desc": "Changed while condition from strictly-greater (>) to greater-than-or-equal (>=)", |
| "original_caption": "The while loop runs as long as count is strictly greater than 0.", |
| "conflicting_caption": "The while loop runs as long as count is greater than or equal to 0.", |
| "question": "What is the condition for the countdown while loop to continue?", |
| "image_bias": "count is strictly greater than 0", |
| "text_bias": "count is greater than or equal to 0", |
| "distractor": "count is equal to 0" |
| }, |
| { |
| "func_name": "paginate_results", |
| "code_text": "def paginate_results():\n # Database page cap\n limit = 20\n return fetch_data(limit)", |
| "type": "loop_boundary", |
| "desc": "Changed pagination limit variable from 20 to 200", |
| "original_caption": "This function sets the fetch data limit to 20.", |
| "conflicting_caption": "This function sets the fetch data limit to 200.", |
| "question": "What is the numerical limit set in this function?", |
| "image_bias": "20", |
| "text_bias": "200", |
| "distractor": "10" |
| }, |
| { |
| "func_name": "fill_buffer", |
| "code_text": "def fill_buffer():\n # Buffer block index fill\n for i in range(5):\n write_data(i)", |
| "type": "loop_boundary", |
| "desc": "Changed loop buffer range from 5 to 50", |
| "original_caption": "The function writes data inside a loop that runs 5 times.", |
| "conflicting_caption": "The function writes data inside a loop that runs 50 times.", |
| "question": "What is the size limit of the buffer write loop?", |
| "image_bias": "5", |
| "text_bias": "50", |
| "distractor": "10" |
| }, |
| { |
| "func_name": "read_lines", |
| "code_text": "def read_lines():\n # Max line reader safety\n max_lines = 50\n return read_file(max_lines)", |
| "type": "loop_boundary", |
| "desc": "Changed max_lines limit variable from 50 to 500", |
| "original_caption": "This function sets the maximum lines to read to 50.", |
| "conflicting_caption": "This function sets the maximum lines to read to 500.", |
| "question": "How many maximum lines will this code attempt to read?", |
| "image_bias": "50 lines", |
| "text_bias": "500 lines", |
| "distractor": "5 lines" |
| }, |
| { |
| "func_name": "is_valid_grade", |
| "code_text": "def is_valid_grade(g):\n # Score limit validation\n return 0 <= g <= 100", |
| "type": "loop_boundary", |
| "desc": "Changed grade range check ceiling from 100 to 10", |
| "original_caption": "This function validates that the grade is between 0 and 100.", |
| "conflicting_caption": "This function validates that the grade is between 0 and 10.", |
| "question": "What is the maximum valid score this function accepts?", |
| "image_bias": "100", |
| "text_bias": "10", |
| "distractor": "50" |
| }, |
| { |
| "func_name": "clamp_value", |
| "code_text": "def clamp_value(val):\n # Cap input range\n return min(max(val, 0), 10)", |
| "type": "loop_boundary", |
| "desc": "Changed clamp ceiling limit from 10 to 100", |
| "original_caption": "This function clamps the value to a maximum threshold of 10.", |
| "conflicting_caption": "This function clamps the value to a maximum threshold of 100.", |
| "question": "What is the upper bound value used to clamp the output?", |
| "image_bias": "10", |
| "text_bias": "100", |
| "distractor": "0" |
| }, |
| { |
| "func_name": "is_in_limit", |
| "code_text": "def is_in_limit(x):\n # Range checker\n return x < 50", |
| "type": "loop_boundary", |
| "desc": "Changed threshold ceiling from 50 to 5", |
| "original_caption": "This function checks if the value of x is less than 50.", |
| "conflicting_caption": "This function checks if the value of x is less than 5.", |
| "question": "What is the value boundary for the check?", |
| "image_bias": "50", |
| "text_bias": "5", |
| "distractor": "100" |
| }, |
| { |
| "func_name": "get_iterations", |
| "code_text": "def get_iterations():\n # Iteration counter\n for i in range(100):\n compute(i)", |
| "type": "loop_boundary", |
| "desc": "Changed range boundary from 100 to 1000", |
| "original_caption": "The range function inside the loop goes up to 100 iterations.", |
| "conflicting_caption": "The range function inside the loop goes up to 1000 iterations.", |
| "question": "How many iterations are configured in the range function?", |
| "image_bias": "100", |
| "text_bias": "1000", |
| "distractor": "10" |
| }, |
| { |
| "func_name": "scan_ports", |
| "code_text": "def scan_ports():\n # Firewall port scan range\n for port in range(1024):\n test(port)", |
| "type": "loop_boundary", |
| "desc": "Changed scanned ports ceiling from 1024 to 10240", |
| "original_caption": "This function loops through and tests ports up to index 1024.", |
| "conflicting_caption": "This function loops through and tests ports up to index 10240.", |
| "question": "What is the upper limit of ports tested in the loop?", |
| "image_bias": "1024", |
| "text_bias": "10240", |
| "distractor": "80" |
| }, |
| { |
| "func_name": "generate_ids", |
| "code_text": "def generate_ids():\n # Id sequence limit\n count = 10\n return make_seq(count)", |
| "type": "loop_boundary", |
| "desc": "Changed count variable from 10 to 100", |
| "original_caption": "This function sets the generation count variable to 10.", |
| "conflicting_caption": "This function sets the generation count variable to 100.", |
| "question": "What sequence length does the count variable specify?", |
| "image_bias": "10", |
| "text_bias": "100", |
| "distractor": "1000" |
| }, |
| { |
| "func_name": "has_max_retries", |
| "code_text": "def has_max_retries(r):\n # Check retry cutoff limit\n return r >= 5", |
| "type": "loop_boundary", |
| "desc": "Changed retry limit ceiling from 5 to 50", |
| "original_caption": "This function returns True if retries are 5 or more.", |
| "conflicting_caption": "This function returns True if retries are 50 or more.", |
| "question": "What is the threshold for checking maximum retries?", |
| "image_bias": "5 or more", |
| "text_bias": "50 or more", |
| "distractor": "exactly 5" |
| }, |
| { |
| "func_name": "run_batch", |
| "code_text": "def run_batch():\n # Thread batch size definition\n batch_size = 32\n return process(batch_size)", |
| "type": "loop_boundary", |
| "desc": "Changed batch_size constant from 32 to 320", |
| "original_caption": "The batch size configured in this function is 32.", |
| "conflicting_caption": "The batch size configured in this function is 320.", |
| "question": "What batch size value is passed to the process function?", |
| "image_bias": "32", |
| "text_bias": "320", |
| "distractor": "64" |
| }, |
| { |
| "func_name": "check_timeout", |
| "code_text": "def check_timeout(t):\n # Wait limit check\n return t < 30", |
| "type": "loop_boundary", |
| "desc": "Changed timeout limit threshold from 30 to 300", |
| "original_caption": "This function returns True if time t is less than 30.", |
| "conflicting_caption": "This function returns True if time t is less than 300.", |
| "question": "What is the threshold value used to check the timeout?", |
| "image_bias": "30", |
| "text_bias": "300", |
| "distractor": "60" |
| }, |
| { |
| "func_name": "truncate_text", |
| "code_text": "def truncate_text(s):\n # Character limit truncation\n max_len = 80\n return s[:max_len]", |
| "type": "loop_boundary", |
| "desc": "Changed max_len constant from 80 to 800", |
| "original_caption": "This function sets the maximum character length to 80.", |
| "conflicting_caption": "This function sets the maximum character length to 800.", |
| "question": "What is the character length cutoff used for truncation?", |
| "image_bias": "80", |
| "text_bias": "800", |
| "distractor": "100" |
| }, |
| { |
| "func_name": "validate_ip_octet", |
| "code_text": "def validate_ip_octet(p):\n # Address validation range\n return 0 <= p <= 255", |
| "type": "loop_boundary", |
| "desc": "Changed maximum value range from 255 to 2550", |
| "original_caption": "This function checks if the octet value is at most 255.", |
| "conflicting_caption": "This function checks if the octet value is at most 2550.", |
| "question": "What is the upper limit value allowed for the ip octet?", |
| "image_bias": "255", |
| "text_bias": "2550", |
| "distractor": "256" |
| }, |
| { |
| "func_name": "sleep_delay", |
| "code_text": "def sleep_delay():\n # Thread sleep delay\n delay = 5\n time.sleep(delay)", |
| "type": "loop_boundary", |
| "desc": "Changed delay timer variable from 5 to 50", |
| "original_caption": "This function triggers a sleep command for 5 seconds.", |
| "conflicting_caption": "This function triggers a sleep command for 50 seconds.", |
| "question": "How many seconds does this function delay execution?", |
| "image_bias": "5 seconds", |
| "text_bias": "50 seconds", |
| "distractor": "1 second" |
| }, |
| { |
| "func_name": "is_valid_percent", |
| "code_text": "def is_valid_percent(p):\n # Ratio threshold\n return p <= 100", |
| "type": "loop_boundary", |
| "desc": "Changed percentage threshold limit from 100 to 1000", |
| "original_caption": "This function checks if value p is less than or equal to 100.", |
| "conflicting_caption": "This function checks if value p is less than or equal to 1000.", |
| "question": "What is the upper boundary check for the percent validation?", |
| "image_bias": "100", |
| "text_bias": "1000", |
| "distractor": "1" |
| }, |
| { |
| "func_name": "max_capacity", |
| "code_text": "def max_capacity():\n # Capacity limit constants\n capacity = 500\n return capacity", |
| "type": "loop_boundary", |
| "desc": "Changed capacity variable value from 500 to 50", |
| "original_caption": "This function defines a capacity variable holding 500.", |
| "conflicting_caption": "This function defines a capacity variable holding 50.", |
| "question": "What value is assigned to the capacity variable?", |
| "image_bias": "500", |
| "text_bias": "50", |
| "distractor": "1000" |
| } |
| ]) |
|
|
| |
| |
| |
| templates.extend([ |
| { |
| "func_name": "get_first", |
| "code_text": "def get_first(arr):\n # Array indexing access\n return arr[0]", |
| "type": "array_indexing", |
| "desc": "Changed target offset index from 0 (first) to -1 (last)", |
| "original_caption": "This function retrieves the first element at index 0 of the array.", |
| "conflicting_caption": "This function retrieves the last element at index -1 of the array.", |
| "question": "Which array element does the index position target?", |
| "image_bias": "First element (index 0)", |
| "text_bias": "Last element (index -1)", |
| "distractor": "Second element (index 1)" |
| }, |
| { |
| "func_name": "get_last", |
| "code_text": "def get_last(arr):\n # Array indexing access\n return arr[-1]", |
| "type": "array_indexing", |
| "desc": "Changed target offset index from -1 (last) to 0 (first)", |
| "original_caption": "This function retrieves the last element at index -1 of the array.", |
| "conflicting_caption": "This function retrieves the first element at index 0 of the array.", |
| "question": "Which position in the list is returned by the indexing code?", |
| "image_bias": "Last element (index -1)", |
| "text_bias": "First element (index 0)", |
| "distractor": "Middle element" |
| }, |
| { |
| "func_name": "get_second", |
| "code_text": "def get_second(arr):\n # Get secondary item\n return arr[1]", |
| "type": "array_indexing", |
| "desc": "Changed target index from 1 (second) to 0 (first)", |
| "original_caption": "This function retrieves the element at index 1 of the list.", |
| "conflicting_caption": "This function retrieves the element at index 0 of the list.", |
| "question": "What element index is being accessed?", |
| "image_bias": "Index 1", |
| "text_bias": "Index 0", |
| "distractor": "Index -1" |
| }, |
| { |
| "func_name": "get_penultimate", |
| "code_text": "def get_penultimate(arr):\n # Index offset access\n return arr[-2]", |
| "type": "array_indexing", |
| "desc": "Changed target index from -2 (second-to-last) to 0 (first)", |
| "original_caption": "This function retrieves the second-to-last element at index -2.", |
| "conflicting_caption": "This function retrieves the first element at index 0.", |
| "question": "Which element does index position -2 retrieve?", |
| "image_bias": "Second-to-last element", |
| "text_bias": "First element", |
| "distractor": "Last element" |
| }, |
| { |
| "func_name": "get_third", |
| "code_text": "def get_third(arr):\n # Index helper\n return arr[2]", |
| "type": "array_indexing", |
| "desc": "Changed target index from 2 (third) to -1 (last)", |
| "original_caption": "This function retrieves the element at index 2 of the list.", |
| "conflicting_caption": "This function retrieves the element at index -1 of the list.", |
| "question": "Which position in the list is accessed?", |
| "image_bias": "Index 2", |
| "text_bias": "Index -1", |
| "distractor": "Index 0" |
| }, |
| { |
| "func_name": "slice_start", |
| "code_text": "def slice_start(arr):\n # Subset slicing helper\n return arr[:3]", |
| "type": "array_indexing", |
| "desc": "Changed slicing range from start-up-to-3 (:3) to starting-from-3 (3:)", |
| "original_caption": "This function slices the array returning elements up to index 3.", |
| "conflicting_caption": "This function slices the array returning elements starting from index 3.", |
| "question": "What sub-array range does the slicing code return?", |
| "image_bias": "Elements up to index 3", |
| "text_bias": "Elements starting from index 3", |
| "distractor": "Only the element at index 3" |
| }, |
| { |
| "func_name": "slice_end", |
| "code_text": "def slice_end(arr):\n # Slice tail elements\n return arr[-3:]", |
| "type": "array_indexing", |
| "desc": "Changed slicing range from last-3 (-3:) to up-to-last-3 (:-3)", |
| "original_caption": "This function slices the list returning the last 3 elements.", |
| "conflicting_caption": "This function slices the list returning all elements except the last 3.", |
| "question": "Which elements are returned by the slice operation?", |
| "image_bias": "The last 3 elements", |
| "text_bias": "All elements except the last 3", |
| "distractor": "Only the first 3 elements" |
| }, |
| { |
| "func_name": "get_nested", |
| "code_text": "def get_nested(matrix):\n # Access 2D grid matrix\n return matrix[0][0]", |
| "type": "array_indexing", |
| "desc": "Changed inner list column index from 0 (first) to -1 (last)", |
| "original_caption": "This function retrieves the first column value of the first row at matrix[0][0].", |
| "conflicting_caption": "This function retrieves the last column value of the first row at matrix[0][-1].", |
| "question": "Which cell in the matrix does the index code target?", |
| "image_bias": "Row 0, Column 0", |
| "text_bias": "Row 0, Column -1", |
| "distractor": "Row -1, Column 0" |
| }, |
| { |
| "func_name": "get_header", |
| "code_text": "def get_header(rows):\n # Document header row\n return rows[0]", |
| "type": "array_indexing", |
| "desc": "Changed index from 0 (first) to -1 (last)", |
| "original_caption": "This function extracts the header at index 0 of the rows list.", |
| "conflicting_caption": "This function extracts the footer at index -1 of the rows list.", |
| "question": "Based on the index expression used on the rows list, which document row position is returned by this function?", |
| "image_bias": "Header (index 0)", |
| "text_bias": "Footer (index -1)", |
| "distractor": "Middle row" |
| }, |
| { |
| "func_name": "get_footer", |
| "code_text": "def get_footer(rows):\n # Document footer row\n return rows[-1]", |
| "type": "array_indexing", |
| "desc": "Changed index from -1 (last) to 0 (first)", |
| "original_caption": "This function extracts the footer at index -1 of the rows list.", |
| "conflicting_caption": "This function extracts the header at index 0 of the rows list.", |
| "question": "Based on the index expression used on the rows list, which document row position is returned by this function?", |
| "image_bias": "Footer (index -1)", |
| "text_bias": "Header (index 0)", |
| "distractor": "None of the rows" |
| }, |
| { |
| "func_name": "get_newest", |
| "code_text": "def get_newest(items):\n # Sorted items access\n return items[-1]", |
| "type": "array_indexing", |
| "desc": "Changed index from -1 (last) to 0 (first)", |
| "original_caption": "This function gets the last item at index -1 representing the newest item.", |
| "conflicting_caption": "This function gets the first item at index 0 representing the oldest item.", |
| "question": "Which item (newest or oldest) is retrieved from the list by this function?", |
| "image_bias": "Last item (index -1)", |
| "text_bias": "First item (index 0)", |
| "distractor": "A random item" |
| }, |
| { |
| "func_name": "get_oldest", |
| "code_text": "def get_oldest(items):\n # Sorted items access\n return items[0]", |
| "type": "array_indexing", |
| "desc": "Changed index from 0 (first) to -1 (last)", |
| "original_caption": "This function gets the first item at index 0 representing the oldest item.", |
| "conflicting_caption": "This function gets the last item at index -1 representing the newest item.", |
| "question": "Which item (oldest or newest) is retrieved from the list by this function?", |
| "image_bias": "First item (index 0)", |
| "text_bias": "Last item (index -1)", |
| "distractor": "Second item" |
| }, |
| { |
| "func_name": "get_runner_up", |
| "code_text": "def get_runner_up(scores):\n # Standing index access\n return scores[1]", |
| "type": "array_indexing", |
| "desc": "Changed index from 1 (runner up) to 0 (winner)", |
| "original_caption": "This function accesses index 1 to retrieve the runner-up score.", |
| "conflicting_caption": "This function accesses index 0 to retrieve the winner's score.", |
| "question": "Which standing score position (winner or runner-up) is retrieved by this function?", |
| "image_bias": "Runner-up (index 1)", |
| "text_bias": "Winner (index 0)", |
| "distractor": "Third place" |
| }, |
| { |
| "func_name": "get_winner", |
| "code_text": "def get_winner(scores):\n # Standing index access\n return scores[0]", |
| "type": "array_indexing", |
| "desc": "Changed index from 0 (winner) to -1 (last place)", |
| "original_caption": "This function accesses index 0 to retrieve the winning score.", |
| "conflicting_caption": "This function accesses index -1 to retrieve the last place score.", |
| "question": "Which standing score position (winner or last place) is retrieved by this function?", |
| "image_bias": "Winner (index 0)", |
| "text_bias": "Last place (index -1)", |
| "distractor": "Runner-up" |
| }, |
| { |
| "func_name": "get_first_two", |
| "code_text": "def get_first_two(arr):\n # Subarray slices\n return arr[:2]", |
| "type": "array_indexing", |
| "desc": "Changed slice range from first-two (:2) to everything-after-two (2:)", |
| "original_caption": "This function slices the array returning the first 2 elements.", |
| "conflicting_caption": "This function slices the array returning all elements except the first 2.", |
| "question": "Which subset of elements is returned from the array by this function?", |
| "image_bias": "First 2 elements", |
| "text_bias": "All elements except the first 2", |
| "distractor": "Only index 2" |
| }, |
| { |
| "func_name": "get_last_two", |
| "code_text": "def get_last_two(arr):\n # Subarray slices\n return arr[-2:]", |
| "type": "array_indexing", |
| "desc": "Changed slice range from last-two (-2:) to everything-before-last-two (:-2)", |
| "original_caption": "This function slices the list returning the last 2 elements.", |
| "conflicting_caption": "This function slices the list returning all elements except the last 2.", |
| "question": "Which sub-list items does the slice output?", |
| "image_bias": "The last 2 elements", |
| "text_bias": "All elements except the last 2", |
| "distractor": "The first 2 elements" |
| }, |
| { |
| "func_name": "get_top_left", |
| "code_text": "def get_top_left(grid):\n # 2D Grid positioning\n return grid[0][0]", |
| "type": "array_indexing", |
| "desc": "Changed index from [0][0] to [-1][-1] (bottom right)", |
| "original_caption": "This function retrieves the top-left cell at grid[0][0].", |
| "conflicting_caption": "This function retrieves the bottom-right cell at grid[-1][-1].", |
| "question": "Which grid cell coordinate is retrieved?", |
| "image_bias": "Top-left cell", |
| "text_bias": "Bottom-right cell", |
| "distractor": "Middle cell" |
| }, |
| { |
| "func_name": "get_bottom_right", |
| "code_text": "def get_bottom_right(grid):\n # 2D Grid positioning\n return grid[-1][-1]", |
| "type": "array_indexing", |
| "desc": "Changed index from [-1][-1] to [0][0] (top left)", |
| "original_caption": "This function retrieves the bottom-right cell at grid[-1][-1].", |
| "conflicting_caption": "This function retrieves the top-left cell at grid[0][0].", |
| "question": "What position in the 2D grid is accessed?", |
| "image_bias": "Bottom-right cell", |
| "text_bias": "Top-left cell", |
| "distractor": "Bottom-left cell" |
| }, |
| { |
| "func_name": "get_second_last", |
| "code_text": "def get_second_last(arr):\n # List indexing helper\n return arr[-2]", |
| "type": "array_indexing", |
| "desc": "Changed index from -2 (second-last) to -1 (last)", |
| "original_caption": "This function accesses index -2 to return the second-to-last item.", |
| "conflicting_caption": "This function accesses index -1 to return the last item.", |
| "question": "Which item (second-to-last or last) is retrieved from the list by this function?", |
| "image_bias": "Second-to-last item", |
| "text_bias": "Last item", |
| "distractor": "First item" |
| }, |
| { |
| "func_name": "get_middle_element", |
| "code_text": "def get_middle_element(arr):\n # Midpoint index access\n mid = len(arr) // 2\n return arr[mid]", |
| "type": "array_indexing", |
| "desc": "Changed index variable from mid to 0 (first element)", |
| "original_caption": "This function retrieves the middle element of the array using index mid.", |
| "conflicting_caption": "This function retrieves the first element of the array using index 0.", |
| "question": "Which position in the array is returned by the function?", |
| "image_bias": "Middle element", |
| "text_bias": "First element", |
| "distractor": "Last element" |
| } |
| ]) |
|
|
| |
| |
| |
| templates.extend([ |
| { |
| "func_name": "is_admin", |
| "code_text": "def is_admin(user):\n # Check admin privileges\n if user.role == 'admin':\n return True\n return False", |
| "type": "boolean_inversion", |
| "desc": "Inverted the return values inside the condition branches", |
| "original_caption": "This function returns True if the user role is admin, otherwise False.", |
| "conflicting_caption": "This function returns False if the user role is admin, otherwise True.", |
| "question": "What does this function return for a user whose role is 'admin'?", |
| "image_bias": "True", |
| "text_bias": "False", |
| "distractor": "None" |
| }, |
| { |
| "func_name": "has_permission", |
| "code_text": "def has_permission(user):\n # Check account active status\n if user.is_active:\n return True\n return False", |
| "type": "boolean_inversion", |
| "desc": "Inverted active permission check return values", |
| "original_caption": "The function returns True if the user is active, and False otherwise.", |
| "conflicting_caption": "The function returns False if the user is active, and True otherwise.", |
| "question": "What is the return value when user.is_active is True?", |
| "image_bias": "True", |
| "text_bias": "False", |
| "distractor": "None" |
| }, |
| { |
| "func_name": "is_valid_email", |
| "code_text": "def is_valid_email(email):\n # Basic syntax presence check\n if '@' in email:\n return True\n return False", |
| "type": "boolean_inversion", |
| "desc": "Inverted email symbol validation check", |
| "original_caption": "This function returns True if the character '@' exists in the email, otherwise False.", |
| "conflicting_caption": "This function returns False if the character '@' exists in the email, otherwise True.", |
| "question": "What does the function return if the email contains '@'?", |
| "image_bias": "True", |
| "text_bias": "False", |
| "distractor": "None" |
| }, |
| { |
| "func_name": "is_prime", |
| "code_text": "def is_prime(n):\n # Small prime trigger check\n if n < 2:\n return False\n return True", |
| "type": "boolean_inversion", |
| "desc": "Inverted n < 2 prime return outcome", |
| "original_caption": "This function returns False if n is less than 2.", |
| "conflicting_caption": "This function returns True if n is less than 2.", |
| "question": "What does this function return if the input n is 1?", |
| "image_bias": "False", |
| "text_bias": "True", |
| "distractor": "None" |
| }, |
| { |
| "func_name": "is_empty_list", |
| "code_text": "def is_empty_list(arr):\n # Array footprint check\n if len(arr) == 0:\n return True\n return False", |
| "type": "boolean_inversion", |
| "desc": "Inverted empty array check output values", |
| "original_caption": "This function returns True if the array has a length of 0.", |
| "conflicting_caption": "This function returns False if the array has a length of 0.", |
| "question": "What does this code output for an empty list input?", |
| "image_bias": "True", |
| "text_bias": "False", |
| "distractor": "None" |
| }, |
| { |
| "func_name": "is_weekend", |
| "code_text": "def is_weekend(day):\n # Weekend calendar check\n if day in ['Saturday', 'Sunday']:\n return True\n return False", |
| "type": "boolean_inversion", |
| "desc": "Inverted weekend day check outputs", |
| "original_caption": "This function returns True if the input day is Saturday or Sunday.", |
| "conflicting_caption": "This function returns False if the input day is Saturday or Sunday.", |
| "question": "What does this code return for the input day 'Saturday'?", |
| "image_bias": "True", |
| "text_bias": "False", |
| "distractor": "None" |
| }, |
| { |
| "func_name": "is_expired", |
| "code_text": "def is_expired(token):\n # Auth lifespan check\n if token.age > 3600:\n return True\n return False", |
| "type": "boolean_inversion", |
| "desc": "Inverted age expiration check outputs", |
| "original_caption": "This function returns True if token age exceeds 3600.", |
| "conflicting_caption": "This function returns False if token age exceeds 3600.", |
| "question": "What is the return value if the token's age is 4000?", |
| "image_bias": "True", |
| "text_bias": "False", |
| "distractor": "None" |
| }, |
| { |
| "func_name": "has_error", |
| "code_text": "def has_error(status):\n # Http code status check\n if status >= 400:\n return True\n return False", |
| "type": "boolean_inversion", |
| "desc": "Inverted error status threshold check output", |
| "original_caption": "This function returns True if the status code is 400 or higher.", |
| "conflicting_caption": "This function returns False if the status code is 400 or higher.", |
| "question": "What does the code return for a status code of 404?", |
| "image_bias": "True", |
| "text_bias": "False", |
| "distractor": "None" |
| }, |
| { |
| "func_name": "is_authenticated", |
| "code_text": "def is_authenticated(session):\n # Active session check\n if session.is_valid:\n return True\n return False", |
| "type": "boolean_inversion", |
| "desc": "Inverted session validity return values", |
| "original_caption": "This function returns True if the session is valid, otherwise False.", |
| "conflicting_caption": "This function returns False if the session is valid, otherwise True.", |
| "question": "What does the function output for a valid session?", |
| "image_bias": "True", |
| "text_bias": "False", |
| "distractor": "None" |
| }, |
| { |
| "func_name": "is_success", |
| "code_text": "def is_success(code):\n # Http ok success check\n if code == 200:\n return True\n return False", |
| "type": "boolean_inversion", |
| "desc": "Inverted code 200 ok check output values", |
| "original_caption": "This function returns True if the response code is exactly 200.", |
| "conflicting_caption": "This function returns False if the response code is exactly 200.", |
| "question": "What is the return value of this function when code is 200?", |
| "image_bias": "True", |
| "text_bias": "False", |
| "distractor": "None" |
| }, |
| { |
| "func_name": "is_digit", |
| "code_text": "def is_digit(char):\n # Numeric digit character check\n if char.isdigit():\n return True\n return False", |
| "type": "boolean_inversion", |
| "desc": "Inverted isdigit character helper check output", |
| "original_caption": "This function returns True if the input character is a digit.", |
| "conflicting_caption": "This function returns False if the input character is a digit.", |
| "question": "What does this code return for the character '5'?", |
| "image_bias": "True", |
| "text_bias": "False", |
| "distractor": "None" |
| }, |
| { |
| "func_name": "is_lowercase", |
| "code_text": "def is_lowercase(s):\n # Lowercase string casing check\n if s.islower():\n return True\n return False", |
| "type": "boolean_inversion", |
| "desc": "Inverted lowercase casing string check output", |
| "original_caption": "This function returns True if the string is all lowercase.", |
| "conflicting_caption": "This function returns False if the string is all lowercase.", |
| "question": "What does this function return for a lowercase string 'abc'?", |
| "image_bias": "True", |
| "text_bias": "False", |
| "distractor": "None" |
| }, |
| { |
| "func_name": "is_file", |
| "code_text": "def is_file(path):\n # File type verification\n if os.path.isfile(path):\n return True\n return False", |
| "type": "boolean_inversion", |
| "desc": "Inverted path file check output values", |
| "original_caption": "This function returns True if the path points to a file.", |
| "conflicting_caption": "This function returns False if the path points to a file.", |
| "question": "What does this function return if the path is indeed a valid file?", |
| "image_bias": "True", |
| "text_bias": "False", |
| "distractor": "None" |
| }, |
| { |
| "func_name": "is_directory", |
| "code_text": "def is_directory(path):\n # Folder check verification\n if os.path.isdir(path):\n return True\n return False", |
| "type": "boolean_inversion", |
| "desc": "Inverted path directory folders checks", |
| "original_caption": "This function returns True if the path points to a directory.", |
| "conflicting_caption": "This function returns False if the path points to a directory.", |
| "question": "What does this function return if the path is a folder?", |
| "image_bias": "True", |
| "text_bias": "False", |
| "distractor": "None" |
| }, |
| { |
| "func_name": "is_leap", |
| "code_text": "def is_leap(year):\n # Leap validation flag\n if year % 4 == 0:\n return True\n return False", |
| "type": "boolean_inversion", |
| "desc": "Inverted leap validation outputs", |
| "original_caption": "This function returns True if the input year is divisible by 4.", |
| "conflicting_caption": "This function returns False if the input year is divisible by 4.", |
| "question": "What is the output for a year that is divisible by 4?", |
| "image_bias": "True", |
| "text_bias": "False", |
| "distractor": "None" |
| }, |
| { |
| "func_name": "is_even_check", |
| "code_text": "def is_even_check(x):\n # Parity check flag\n if x % 2 == 0:\n return True\n return False", |
| "type": "boolean_inversion", |
| "desc": "Inverted even parity check outputs", |
| "original_caption": "This function returns True if the number x is even.", |
| "conflicting_caption": "This function returns False if the number x is even.", |
| "question": "What does the code return if x is 4?", |
| "image_bias": "True", |
| "text_bias": "False", |
| "distractor": "None" |
| }, |
| { |
| "func_name": "is_odd_check", |
| "code_text": "def is_odd_check(x):\n # Odd check flag\n if x % 2 != 0:\n return True\n return False", |
| "type": "boolean_inversion", |
| "desc": "Inverted odd parity check outputs", |
| "original_caption": "This function returns True if the number x is odd.", |
| "conflicting_caption": "This function returns False if the number x is odd.", |
| "question": "What does the code return if x is 5?", |
| "image_bias": "True", |
| "text_bias": "False", |
| "distractor": "None" |
| }, |
| { |
| "func_name": "is_uppercase", |
| "code_text": "def is_uppercase(s):\n # Uppercase string validation\n if s.isupper():\n return True\n return False", |
| "type": "boolean_inversion", |
| "desc": "Inverted uppercase string checks", |
| "original_caption": "This function returns True if the string is all uppercase.", |
| "conflicting_caption": "This function returns False if the string is all uppercase.", |
| "question": "What does this function return for the uppercase string 'XYZ'?", |
| "image_bias": "True", |
| "text_bias": "False", |
| "distractor": "None" |
| }, |
| { |
| "func_name": "is_verified", |
| "code_text": "def is_verified(user):\n # User validation tag checks\n if user.verified:\n return True\n return False", |
| "type": "boolean_inversion", |
| "desc": "Inverted user verification return values", |
| "original_caption": "This function returns True if the user is verified, otherwise False.", |
| "conflicting_caption": "This function returns False if the user is verified, otherwise True.", |
| "question": "What does the code return if user.verified is True?", |
| "image_bias": "True", |
| "text_bias": "False", |
| "distractor": "None" |
| }, |
| { |
| "func_name": "is_complete", |
| "code_text": "def is_complete(task):\n # Task completion checklist\n if task.done:\n return True\n return False", |
| "type": "boolean_inversion", |
| "desc": "Inverted task completion outputs", |
| "original_caption": "This function returns True if the task.done flag is True.", |
| "conflicting_caption": "This function returns False if the task.done flag is True.", |
| "question": "What is the return value of this function when task.done is True?", |
| "image_bias": "True", |
| "text_bias": "False", |
| "distractor": "None" |
| } |
| ]) |
|
|
| return templates |
|
|
| def run_generation(batch_num): |
| dataset_dir = "/Users/akanshjain/.gemini/antigravity/scratch/code_conflict_dataset" |
| images_dir = os.path.join(dataset_dir, "train") |
| os.makedirs(images_dir, exist_ok=True) |
| |
| templates = get_templates() |
| |
| |
| start_idx = (batch_num - 1) * 5 |
| end_idx = batch_num * 5 |
| |
| batch_templates = templates[start_idx:end_idx] |
| |
| |
| csv_path = os.path.join(images_dir, "metadata.csv") |
| existing_rows = [] |
| if os.path.exists(csv_path) and batch_num > 1: |
| with open(csv_path, mode="r") as f: |
| reader = csv.DictReader(f) |
| for r in reader: |
| existing_rows.append(r) |
| |
| |
| new_rows = [] |
| pygmentize_path = "/opt/miniconda3/bin/pygmentize" |
| |
| for i, t in enumerate(batch_templates): |
| serial_no = start_idx + i + 1 |
| img_filename = f"code_{serial_no}.png" |
| img_path = os.path.join(images_dir, img_filename) |
| |
| |
| temp_file = os.path.join(dataset_dir, "temp_code.py") |
| with open(temp_file, "w") as f: |
| f.write(t["code_text"]) |
| |
| |
| try: |
| subprocess.run([ |
| pygmentize_path, |
| "-f", "png", |
| "-O", "style=monokai,font_name=Courier New,font_size=20,line_numbers=True", |
| "-o", img_path, |
| temp_file |
| ], check=True) |
| except Exception as e: |
| print(f"Error running pygmentize: {e}") |
| |
| |
| if os.path.exists(temp_file): |
| os.remove(temp_file) |
| |
| new_rows.append({ |
| "file_name": img_filename, |
| "original_caption": t["original_caption"], |
| "conflicting_caption": t["conflicting_caption"], |
| "question": t["question"], |
| "image_bias": t["image_bias"], |
| "text_bias": t["text_bias"], |
| "distractor": t["distractor"], |
| "serial_no": serial_no, |
| "conflict type": t["type"], |
| "language": "english" |
| }) |
| |
| |
| rows_dict = {int(r["serial_no"]): r for r in existing_rows} |
| for r in new_rows: |
| rows_dict[int(r["serial_no"])] = r |
| all_rows = list(rows_dict.values()) |
| all_rows = sorted(all_rows, key=lambda x: int(x["serial_no"])) |
| |
| with open(csv_path, mode="w", newline="") as f: |
| writer = csv.DictWriter(f, fieldnames=[ |
| "file_name", "original_caption", "conflicting_caption", "question", |
| "image_bias", "text_bias", "distractor", "serial_no", "conflict type", "language" |
| ]) |
| writer.writeheader() |
| writer.writerows(all_rows) |
| |
| print(f"Successfully generated batch {batch_num} (serial_no {start_idx+1} to {end_idx})") |
|
|
| if __name__ == "__main__": |
| if len(sys.argv) < 2: |
| print("Usage: python3 generate_batch.py <batch_number>") |
| sys.exit(1) |
| |
| batch_num = int(sys.argv[1]) |
| run_generation(batch_num) |
|
|
