Update app.py

app.py

@@ -13,337 +13,305 @@ app.logger = logging.getLogger("CodeSearchAPI")
 
 # 预定义代码片段
 CODE_SNIPPETS = [
-    "print('Hello, World!')",
-"def add(a, b): return a + b",
-"import random; def generate_random(): return random.randint(1, 100)",
-"def is_even(n): return n % 2 == 0",
-"def string_length(s): return len(s)",
-"from datetime import date; def get_current_date(): return date.today()",
-"import os; def file_exists(path): return os.path.exists(path)",
-"def read_file(path): return open(path, 'r').read()",
-"def write_file(path, content): open(path, 'w').write(content)",
-"from datetime import datetime; def get_current_time(): return datetime.now()",
-"def to_upper(s): return s.upper()",
-"def to_lower(s): return s.lower()",
-"def reverse_string(s): return s[::-1]",
-"def list_length(lst): return len(lst)",
-"def list_max(lst): return max(lst)",
-"def list_min(lst): return min(lst)",
-"def sort_list(lst): return sorted(lst)",
-"def merge_lists(lst1, lst2): return lst1 + lst2",
-"def remove_element(lst, element): lst.remove(element)",
-"def is_list_empty(lst): return len(lst) == 0",
-"def count_char(s, char): return s.count(char)",
-"def contains_substring(s, sub): return sub in s",
-"def int_to_str(n): return str(n)",
-"def str_to_int(s): return int(s)",
-"def is_numeric(s): return s.isdigit()",
-"def get_index(lst, element): return lst.index(element)",
-"def clear_list(lst): lst.clear()",
-"def reverse_list(lst): lst.reverse()",
-"def remove_duplicates(lst): return list(set(lst))",
-"def is_in_list(lst, value): return value in lst",
-"def create_dict(): return {}",
-"def add_to_dict(d, key, value): d[key] = value",
-"def delete_key(d, key): del d[key]",
-"def get_keys(d): return list(d.keys())",
-"def get_values(d): return list(d.values())",
-"def merge_dicts(d1, d2): return {**d1, **d2}",
-"def is_dict_empty(d): return len(d) == 0",
-"def get_value(d, key): return d[key]",
-"def key_exists(d, key): return key in d",
-"def clear_dict(d): d.clear()",
-"def count_lines(path): return len(open(path).readlines())",
-"def write_list_to_file(path, lst): open(path, 'w').write('\\n'.join(map(str, lst)))",
-"def read_list_from_file(path): return open(path, 'r').read().splitlines()",
-"def count_words(path): return len(open(path, 'r').read().split())",
-"def is_leap_year(year): return year % 4 == 0 and (year % 100 != 0 or year % 400 == 0)",
-"from datetime import datetime; def format_time(dt): return dt.strftime('%Y-%m-%d %H:%M:%S')",
-"from datetime import date; def days_between(d1, d2): return (d2 - d1).days",
-"import os; def get_current_dir(): return os.getcwd()",
-"import os; def list_files(path): return os.listdir(path)",
-"import os; def create_dir(path): os.mkdir(path)"
-"import os; def remove_dir(path): os.rmdir(path)",
-"import os; def is_file(path): return os.path.isfile(path)",
-"import os; def is_dir(path): return os.path.isdir(path)",
-"import os; def get_file_size(path): return os.path.getsize(path)",
-"import os; def rename_file(src, dst): os.rename(src, dst)",
-"import shutil; def copy_file(src, dst): shutil.copy(src, dst)",
-"import shutil; def move_file(src, dst): shutil.move(src, dst)",
-"import os; def delete_file(path): os.remove(path)",
-"import os; def get_env_var(key): return os.getenv(key)",
-"import os; def set_env_var(key, value): os.environ[key] = value",
-"import webbrowser; def open_url(url): webbrowser.open(url)",
-"import requests; def send_get_request(url): return requests.get(url).text",
-"import json; def parse_json(data): return json.loads(data)",
-"import json; def write_json(data, path): open(path, 'w').write(json.dumps(data))",
-"import json; def read_json(path): return json.loads(open(path, 'r').read())",
-"def list_to_string(lst): return ''.join(lst)",
-"def string_to_list(s): return list(s)",
-"def join_with_comma(lst): return ','.join(lst)",
-"def join_with_newline(lst): return '\\n'.join(lst)",
-"def split_by_space(s): return s.split()",
-"def split_by_char(s, char): return s.split(char)",
-"def split_to_chars(s): return list(s)",
-"def replace_string(s, old, new): return s.replace(old, new)",
-"def remove_spaces(s): return s.replace(' ', '')",
-"import string; def remove_punctuation(s): return s.translate(str.maketrans('', '', string.punctuation))",
-"def is_string_empty(s): return len(s) == 0",
-"def is_palindrome(s): return s == s[::-1]",
-"import csv; def write_csv(data, path): open(path, 'w', newline='').write('\\n'.join([','.join(map(str, row)) for row in data]))",
-"import csv; def read_csv(path): return [row for row in csv.reader(open(path, 'r'))]",
-"def count_csv_lines(path): return len(open(path).readlines())",
-"import random; def shuffle_list(lst): random.shuffle(lst)",
-"import random; def random_choice(lst): return random.choice(lst)",
-"import random; def random_sample(lst, k): return random.sample(lst, k)",
-"import random; def roll_dice(): return random.randint(1, 6)",
-"import random; def flip_coin(): return random.choice(['Heads', 'Tails'])",
-"import random; import string; def generate_password(length=8): return ''.join(random.choices(string.ascii_letters + string.digits, k=length))",
-"import random; def generate_color(): return '#%06x' % random.randint(0, 0xFFFFFF)",
-"import uuid; def generate_uuid(): return str(uuid.uuid4())",
-"class MyClass: pass",
-"def create_instance(): return MyClass()",
-"class MyClass: def my_method(self): pass",
-"class MyClass: def __init__(self): self.my_attr = None",
-"class ChildClass(MyClass): pass",
-"class ChildClass(MyClass): def my_method(self): pass",
-"class MyClass: @classmethod def my_class_method(cls): pass",
-"class MyClass: @staticmethod def my_static_method(): pass",
-"def check_type(obj): return type(obj)",
-"def get_attr(obj, attr): return getattr(obj, attr)",
-"def set_attr(obj, attr, value): setattr(obj, attr, value)",
-"def del_attr(obj, attr): delattr(obj, attr)",
-"""try:
-    x = 1 / 0
-except ZeroDivisionError:
-    pass""",
-"""class CustomError(Exception): pass
-def raise_custom_error(): raise CustomError('Error occurred')""",
-"""try:
-    x = 1 / 0
-except Exception as e: return str(e)""",
-"""import logging; logging.basicConfig(filename='error.log', level=logging.ERROR); logging.error('Error occurred')""",
-"""import time; def timer(): start = time.time(); return lambda: time.time() - start""",
-"""import time; def run_time(): start = time.time(); return lambda: time.time() - start""",
-"""import sys; def print_progress(progress): sys.stdout.write(f'\\rProgress: {progress}%'); sys.stdout.flush()""",
-"""import time; def delay(seconds): time.sleep(seconds)""",
-"lambda x: x * 2",
-"map(lambda x: x * 2, [1, 2, 3])",
-"filter(lambda x: x > 2, [1, 2, 3])",
-"from functools import reduce; reduce(lambda x, y: x + y, [1, 2, 3])",
-"[x * 2 for x in [1, 2, 3]]",
-"{x: x * 2 for x in [1, 2, 3]}",
-"{x for x in [1, 2, 3]}",
-"set1 & set2",
-"set1 | set2",
-"set1 - set2",
-"[x for x in lst if x is not None]",
-"""try:
-    with open('file.txt', 'r') as f: pass
-except IOError: pass""",
-"type(var)",
-"bool(s)",
-"if condition: pass",
-"while condition: pass",
-"for item in lst: pass",
-"for key, value in d.items(): pass",
-"for char in s: pass",
-"for item in lst: if condition: break",
-"for item in lst: if condition: continue",
-"def my_func(): pass",
-"def my_func(param=1): pass",
-"def my_func(): return 1, 2",
-"def my_func(*args): pass",
-"def my_func(**kwargs): pass",
-"""import time; def timer(func):
-    def wrapper(*args, **kwargs):
-        start = time.time()
-        result = func(*args, **kwargs)
-        print(f'Time: {time.time() - start}'); return result
-    return wrapper""",
-"""def decorator(func):
-    def wrapper(*args, **kwargs): return func(*args, **kwargs)
-    return wrapper""",
-"""from functools import lru_cache; @lru_cache(maxsize=None)
-def my_func(): pass""",
-"def my_generator(): yield 1",
-"gen = my_generator(); next(gen)",
-"class MyIterator: def __iter__(self): return self; def __next__(self): pass",
-"it = iter([1, 2, 3]); next(it)",
-"for i, val in enumerate(lst): pass",
-"list(zip(lst1, lst2))",
-"dict(zip(keys, values))",
-"lst1 == lst2",
-"dict1 == dict2",
-"set1 == set2",
-"set(lst)",
-"set.clear()",
-"len(set) == 0",
-"set.add(item)",
-"set.remove(item)",
-"item in set",
-"len(set)",
-"set1 & set2",
-"set(lst1).issubset(lst2)",
-"sub in s",
-"s[0]",
-"s[-1]",
-"import mimetypes; mimetypes.guess_type(path)[0] == 'text/plain'",
-"import mimetypes; mimetypes.guess_type(path)[0].startswith('image/')",
-"round(num)",
-"import math; math.ceil(num)",
-"import math; math.floor(num)",
-"f'{num:.2f}'",
-"import random; import string; ''.join(random.choices(string.ascii_letters + string.digits, k=8))",
-"import os; os.path.exists(path)",
-"import os; for root, dirs, files in os.walk(path): pass",
-"import os; os.path.splitext(path)[1]",
-"import os; os.path.basename(path)",
-"import os; os.path.abspath(path)",
-"import platform; platform.python_version()",
-"import platform; platform.system()",
-"import multiprocessing; multiprocessing.cpu_count()",
-"import psutil; psutil.virtual_memory().total",
-"import psutil; psutil.disk_usage('/')",
-"import socket; socket.gethostbyname(socket.gethostname())",
-"import requests; try: requests.get('http://www.google.com'); return True; except: return False",
-"import requests; def download_file(url, path): with open(path, 'wb') as f: f.write(requests.get(url).content)",
-"def upload_file(path): with open(path, 'rb') as f: requests.post('http://example.com/upload', files={'file': f})",
-"import requests; requests.post(url, data={'key': 'value'})",
-"import requests; requests.get(url, params={'key': 'value'})",
-"import requests; requests.get(url, headers={'key': 'value'})",
-"from bs4 import BeautifulSoup; BeautifulSoup(html, 'html.parser')",
-"from bs4 import BeautifulSoup; soup.title.text",
-"from bs4 import BeautifulSoup; [a['href'] for a in soup.find_all('a')]",
-"from bs4 import BeautifulSoup; import requests; for img in soup.find_all('img'): requests.get(img['src']).content",
-"from collections import Counter; Counter(text.split())",
-"import requests; session = requests.Session(); session.post(login_url, data={'username': 'user', 'password': 'pass'})",
-"from bs4 import BeautifulSoup; soup.get_text()",
-"import re; re.findall(r'[\\w.-]+@[\\w.-]+', text)",
-"import re; re.findall(r'\\+?\\d[\\d -]{8,12}\\d', text)",
-"import re; re.findall(r'\\d+', text)",
-"import re; re.sub(pattern, repl, text)",
-"import re; re.match(pattern, text)",
-"from bs4 import BeautifulSoup; soup.get_text()",
-"import html; html.escape(text)",
-"import html; html.unescape(text)",
-"import tkinter as tk; root = tk.Tk(); root.mainloop()",
-"import tkinter as tk; def add_button(window, text): return tk.Button(window, text=text)",
-"""def bind_click(button, func): button.config(command=func)""",
-"""import tkinter.messagebox; def show_alert(message): tkinter.messagebox.showinfo('Info', message)""",
-"""def get_entry_text(entry): return entry.get()""",
-"def set_title(window, title): window.title(title)",
-"def set_size(window, width, height): window.geometry(f'{width}x{height}')",
-"""def center_window(window):
-    window.update_idletasks()
-    width = window.winfo_width()
-    height = window.winfo_height()
-    x = (window.winfo_screenwidth() // 2) - (width // 2)
-    y = (window.winfo_screenheight() // 2) - (height // 2)
-    window.geometry(f'{width}x{height}+{x}+{y}')""",
-"""def create_menu(window): return tk.Menu(window)""",
-"def create_combobox(window): return ttk.Combobox(window)",
-"def create_radiobutton(window, text): return tk.Radiobutton(window, text=text)",
-"def create_checkbutton(window, text): return tk.Checkbutton(window, text=text)",
-"""from PIL import ImageTk, Image; def show_image(window, path):
-    img = Image.open(path)
-    photo = ImageTk.PhotoImage(img)
-    label = tk.Label(window, image=photo)
-    label.image = photo
-    return label""",
-"import pygame; def play_audio(path): pygame.mixer.init(); pygame.mixer.music.load(path); pygame.mixer.music.play()",
-"import cv2; def play_video(path): cap = cv2.VideoCapture(path); while cap.isOpened(): ret, frame = cap.read()",
-"def get_playback_time(): return pygame.mixer.music.get_pos()",
-"import pyautogui; def screenshot(): return pyautogui.screenshot()",
-"import pyautogui; import time; def record_screen(duration): return [pyautogui.screenshot() for _ in range(duration)]",
-"def get_mouse_pos(): return pyautogui.position()",
-"import pyautogui; def type_text(text): pyautogui.write(text)",
-"import pyautogui; def click_mouse(x, y): pyautogui.click(x, y)",
-"import time; def get_timestamp(): return int(time.time())",
-"import datetime; def timestamp_to_date(ts): return datetime.datetime.fromtimestamp(ts)",
-"import time; def date_to_timestamp(dt): return int(time.mktime(dt.timetuple()))",
-"def get_weekday(): return datetime.datetime.now().strftime('%A')",
-"import calendar; def get_month_days(): return calendar.monthrange(datetime.datetime.now().year, datetime.datetime.now().month)[1]",
-"def first_day_of_year(): return datetime.date(datetime.datetime.now().year, 1, 1)",
-"def last_day_of_year(): return datetime.date(datetime.datetime.now().year, 12, 31)",
-"def first_day_of_month(month): return datetime.date(datetime.datetime.now().year, month, 1)",
-"import calendar; def last_day_of_month(month): return datetime.date(datetime.datetime.now().year, month, calendar.monthrange(datetime.datetime.now().year, month)[1])",
-"def is_weekday(): return datetime.datetime.now().weekday() < 5",
-"def is_weekend(): return datetime.datetime.now().weekday() >= 5",
-"def current_hour(): return datetime.datetime.now().hour",
-"def current_minute(): return datetime.datetime.now().minute",
-"def current_second(): return datetime.datetime.now().second",
-"import time; def delay_1s(): time.sleep(1)",
-"import time; def millis_timestamp(): return int(time.time() * 1000)",
-"def format_time(dt, fmt='%Y-%m-%d %H:%M:%S'): return dt.strftime(fmt)",
-"from dateutil.parser import parse; def parse_time(s): return parse(s)",
-"import threading; def create_thread(target): return threading.Thread(target=target)",
-"import time; def thread_pause(seconds): time.sleep(seconds)",
-"def run_threads(*threads): [t.start() for t in threads]",
-"import threading; def current_thread_name(): return threading.current_thread().name",
-"def set_daemon(thread): thread.daemon = True",
-"import threading; lock = threading.Lock()",
-"import multiprocessing; def create_process(target): return multiprocessing.Process(target=target)",
-"import os; def get_pid(): return os.getpid()",
-"import psutil; def is_process_alive(pid): return psutil.pid_exists(pid)",
-"def run_processes(*procs): [p.start() for p in procs]",
-"from queue import Queue; q = Queue()",
-"from multiprocessing import Pipe; parent_conn, child_conn = Pipe()",
-"import os; def limit_cpu_usage(percent): os.system(f'cpulimit -p {os.getpid()} -l {percent}')",
-"import subprocess; def run_command(cmd): subprocess.run(cmd, shell=True)",
-"import subprocess; def get_command_output(cmd): return subprocess.check_output(cmd, shell=True).decode()",
-"def get_exit_code(cmd): return subprocess.call(cmd, shell=True)",
-"def is_success(code): return code == 0",
-"import os; def script_path(): return os.path.realpath(__file__)",
-"import sys; def get_cli_args(): return sys.argv[1:]",
-"import argparse; parser = argparse.ArgumentParser()",
-"parser.print_help()",
-"help('modules')",
-"import pip; def install_pkg(pkg): pip.main(['install', pkg])",
-"import pip; def uninstall_pkg(pkg): pip.main(['uninstall', pkg])",
-"import pkg_resources; def get_pkg_version(pkg): return pkg_resources.get_distribution(pkg).version",
-"import venv; def create_venv(path): venv.create(path)",
-"import pip; def list_pkgs(): return pip.get_installed_distributions()",
-"import pip; def upgrade_pkg(pkg): pip.main(['install', '--upgrade', pkg])",
-"import sqlite3; conn = sqlite3.connect(':memory:')",
-"def execute_query(conn, query): return conn.execute(query)",
-"""def insert_record(conn, table, data): conn.execute(f'INSERT INTO {table} VALUES ({",".join("?"*len(data))})', data)""",
-"def delete_record(conn, table, condition): conn.execute(f'DELETE FROM {table} WHERE {condition}')",
-"def update_record(conn, table, set_clause, condition): conn.execute(f'UPDATE {table} SET {set_clause} WHERE {condition}')",
-"def fetch_all(conn, query): return conn.execute(query).fetchall()",
-"def safe_query(conn, query, params): return conn.execute(query, params)",
-"def close_db(conn): conn.close()",
-"def create_table(conn, name, columns): conn.execute(f'CREATE TABLE {name} ({columns})')",
-"def drop_table(conn, name): conn.execute(f'DROP TABLE {name}')",
-"def table_exists(conn, name): return conn.execute(f\"SELECT name FROM sqlite_master WHERE type='table' AND name='{name}'\").fetchone()",
-"def list_tables(conn): return conn.execute(\"SELECT name FROM sqlite_master WHERE type='table'\").fetchall()",
-"""from sqlalchemy import Column, Integer, String
-class User(Base):
-    __tablename__ = 'users'
-    id = Column(Integer, primary_key=True)
-    name = Column(String)""",
-"session.add(User(name='John'))",
-"session.query(User).filter_by(name='John')",
-"session.query(User).filter_by(name='John').delete()",
-"session.query(User).filter_by(name='John').update({'name': 'Bob'})",
-"Base = declarative_base()",
-"class Admin(User): pass",
-"id = Column(Integer, primary_key=True)",
-"name = Column(String, unique=True)",
-"name = Column(String, default='Unknown')",
-"import csv; def export_csv(data, path): open(path, 'w').write('\\n'.join([','.join(map(str, row)) for row in data]))",
-"import pandas as pd; pd.DataFrame(data).to_excel(path)",
-"import json; json.dump(data, open(path, 'w'))",
-"pd.read_excel(path).values.tolist()",
-"pd.concat([pd.read_excel(f) for f in files])",
-"with pd.ExcelWriter(path, mode='a') as writer: df.to_excel(writer, sheet_name='New')",
-"from openpyxl.styles import copy; copy.copy(style)",
-"from openpyxl.styles import PatternFill; cell.fill = PatternFill(start_color='FFFF00', fill_type='solid')",
-"from openpyxl.styles import Font; cell.font = Font(bold=True)",
-"sheet['A1'].value",
-"sheet['A1'] = value",
-"from PIL import Image; Image.open(path).size",
-"from PIL import Image; Image.open(path).resize((w, h))"
+    "System.out.println(\"Hello, World!\");",
+"public static int sum(int a, int b) { return a + b; }",
+"import java.util.Random; public static int generateRandomNumber() { return new Random().nextInt(); }",
+"public static boolean isEven(int number) { return number % 2 == 0; }",
+"public static int stringLength(String str) { return str.length(); }",
+"import java.time.LocalDate; public static LocalDate getCurrentDate() { return LocalDate.now(); }",
+"import java.io.File; public static boolean fileExists(String path) { return new File(path).exists(); }",
+"import java.nio.file.Files; import java.nio.file.Paths; public static String readFileContent(String path) throws Exception { return new String(Files.readAllBytes(Paths.get(path))); }",
+"import java.nio.file.Files; import java.nio.file.Paths; public static void writeToFile(String path, String content) throws Exception { Files.write(Paths.get(path), content.getBytes()); }",
+"import java.time.LocalTime; public static LocalTime getCurrentTime() { return LocalTime.now(); }",
+"public static String toUpperCase(String str) { return str.toUpperCase(); }",
+"public static String toLowerCase(String str) { return str.toLowerCase(); }",
+"public static String reverseString(String str) { return new StringBuilder(str).reverse().toString(); }",
+"public static int countListElements(List<?> list) { return list.size(); }",
+"public static int findMax(List<Integer> list) { return Collections.max(list); }",
+"public static int findMin(List<Integer> list) { return Collections.min(list); }",
+"public static List<Integer> sortList(List<Integer> list) { Collections.sort(list); return list; }",
+"public static List<?> mergeLists(List<?> list1, List<?> list2) { List<Object> mergedList = new ArrayList<>(list1); mergedList.addAll(list2); return mergedList; }",
+"public static void removeElement(List<?> list, Object element) { list.remove(element); }",
+"public static boolean isListEmpty(List<?> list) { return list.isEmpty(); }",
+"public static int countCharOccurrences(String str, char ch) { return (int) str.chars().filter(c -> c == ch).count(); }",
+"public static boolean containsSubstring(String str, String sub) { return str.contains(sub); }",
+"public static String numberToString(int number) { return Integer.toString(number); }",
+"public static int stringToNumber(String str) { return Integer.parseInt(str); }",
+"public static boolean isNumeric(String str) { return str.matches(\"\\\\d+\"); }",
+"public static int getElementIndex(List<?> list, Object element) { return list.indexOf(element); }",
+"public static void clearList(List<?> list) { list.clear(); }",
+"public static void reverseList(List<?> list) { Collections.reverse(list); }",
+"public static List<?> removeDuplicates(List<?> list) { return new ArrayList<>(new HashSet<>(list)); }",
+"public static boolean isInList(List<?> list, Object element) { return list.contains(element); }",
+"public static Map<Object, Object> createDictionary() { return new HashMap<>(); }",
+"public static void addToDictionary(Map<Object, Object> dict, Object key, Object value) { dict.put(key, value); }",
+"public static void removeFromDictionary(Map<Object, Object> dict, Object key) { dict.remove(key); }",
+"public static Set<Object> getDictionaryKeys(Map<Object, Object> dict) { return dict.keySet(); }",
+"public static Collection<Object> getDictionaryValues(Map<Object, Object> dict) { return dict.values(); }",
+"public static Map<Object, Object> mergeDictionaries(Map<Object, Object> dict1, Map<Object, Object> dict2) { Map<Object, Object> mergedDict = new HashMap<>(dict1); mergedDict.putAll(dict2); return mergedDict; }",
+"public static boolean isDictionaryEmpty(Map<Object, Object> dict) { return dict.isEmpty(); }",
+"public static Object getDictionaryValue(Map<Object, Object> dict, Object key) { return dict.get(key); }",
+"public static boolean keyExistsInDictionary(Map<Object, Object> dict, Object key) { return dict.containsKey(key); }",
+"public static void clearDictionary(Map<Object, Object> dict) { dict.clear(); }",
+"import java.io.BufferedReader; import java.io.FileReader; public static int countFileLines(String path) throws Exception { return (int) new BufferedReader(new FileReader(path)).lines().count(); }",
+"import java.nio.file.Files; import java.nio.file.Paths; public static void writeListToFile(String path, List<?> list) throws Exception { Files.write(Paths.get(path), list.toString().getBytes()); }",
+"import java.nio.file.Files; import java.nio.file.Paths; public static List<String> readListFromFile(String path) throws Exception { return Files.readAllLines(Paths.get(path)); }",
+"import java.io.BufferedReader; import java.io.FileReader; public static int countFileWords(String path) throws Exception { return new BufferedReader(new FileReader(path)).lines().mapToInt(line -> line.split(\"\\\\s+\").length).sum(); }",
+"public static boolean isLeapYear(int year) { return (year % 4 == 0 && year % 100 != 0) || (year % 400 == 0); }",
+"import java.time.format.DateTimeFormatter; public static String formatTime(LocalTime time, String pattern) { return time.format(DateTimeFormatter.ofPattern(pattern)); }",
+"import java.time.LocalDate; import java.time.temporal.ChronoUnit; public static long daysBetween(LocalDate date1, LocalDate date2) { return ChronoUnit.DAYS.between(date1, date2); }",
+"import java.nio.file.Paths; public static String getCurrentWorkingDirectory() { return Paths.get(\"\").toAbsolutePath().toString(); }",
+"import java.io.File; public static List<String> listFilesInDirectory(String path) { return Arrays.asList(new File(path).list()); }",
+"import java.nio.file.Files; import java.nio.file.Paths; public static void createDirectory(String path) throws Exception { Files.createDirectory(Paths.get(path)); }",
+"import java.nio.file.Files; import java.nio.file.Paths; public static void deleteDirectory(String path) throws Exception { Files.delete(Paths.get(path)); }",
+"import java.nio.file.Files; import java.nio.file.Paths; public static boolean isFile(String path) { return Files.isRegularFile(Paths.get(path)); }",
+"import java.nio.file.Files; import java.nio.file.Paths; public static boolean isDirectory(String path) { return Files.isDirectory(Paths.get(path)); }",
+"import java.nio.file.Files; import java.nio.file.Paths; public static long getFileSize(String path) throws Exception { return Files.size(Paths.get(path)); }",
+"import java.nio.file.Files; import java.nio.file.Paths; public static void renameFile(String oldPath, String newPath) throws Exception { Files.move(Paths.get(oldPath), Paths.get(newPath)); }",
+"import java.nio.file.Files; import java.nio.file.Paths; public static void copyFile(String sourcePath, String destinationPath) throws Exception { Files.copy(Paths.get(sourcePath), Paths.get(destinationPath)); }",
+"import java.nio.file.Files; import java.nio.file.Paths; public static void moveFile(String sourcePath, String destinationPath) throws Exception { Files.move(Paths.get(sourcePath), Paths.get(destinationPath)); }",
+"import java.nio.file.Files; import java.nio.file.Paths; public static void deleteFile(String path) throws Exception { Files.delete(Paths.get(path)); }",
+"public static String getEnvVariable(String name) { return System.getenv(name); }",
+"public static void setEnvVariable(String name, String value) { System.setProperty(name, value); }",
+"import java.awt.Desktop; import java.net.URI; public static void openWebLink(String url) throws Exception { Desktop.getDesktop().browse(new URI(url)); }",
+"import java.net.HttpURLConnection; import java.net.URL; public static String sendGetRequest(String url) throws Exception { HttpURLConnection connection = (HttpURLConnection) new URL(url).openConnection(); connection.setRequestMethod(\"GET\"); return new String(connection.getInputStream().readAllBytes()); }",
+"import com.google.gson.JsonParser; public static Object parseJson(String json) { return JsonParser.parseString(json); }",
+"import com.google.gson.Gson; import java.nio.file.Files; import java.nio.file.Paths; public static void writeJsonToFile(String path, Object obj) throws Exception { Files.write(Paths.get(path), new Gson().toJson(obj).getBytes()); }",
+"import com.google.gson.Gson; import java.nio.file.Files; import java.nio.file.Paths; public static Object readJsonFromFile(String path) throws Exception { return new Gson().fromJson(new String(Files.readAllBytes(Paths.get(path))), Object.class); }",
+"public static String listToString(List<?> list) { return list.toString(); }",
+"public static List<String> stringToList(String str) { return Arrays.asList(str.split(\",\")); }",
+"public static String joinWithComma(List<?> list) { return String.join(\",\", list.stream().map(Object::toString).toArray(String[]::new)); }",
+"public static String joinWithNewline(List<?> list) { return String.join(\"\\n\", list.stream().map(Object::toString).toArray(String[]::new)); }",
+"public static String[] splitBySpace(String str) { return str.split(\"\\\\s+\"); }",
+"public static String[] splitByDelimiter(String str, String delimiter) { return str.split(delimiter); }",
+"public static String[] splitIntoChars(String str) { return str.split(\"\"); }",
+"public static String replaceInString(String str, String target, String replacement) { return str.replace(target, replacement); }",
+"public static String removeSpaces(String str) { return str.replaceAll(\"\\\\s\", \"\"); }",
+"public static String removePunctuation(String str) { return str.replaceAll(\"[^a-zA-Z0-9]\", \"\"); }",
+"public static boolean isStringEmpty(String str) { return str.isEmpty(); }",
+"public static boolean isPalindrome(String str) { return str.equals(new StringBuilder(str).reverse().toString()); }",
+"import com.opencsv.CSVWriter; import java.io.FileWriter; public static void writeToCsv(String path, List<String[]> data) throws Exception { CSVWriter writer = new CSVWriter(new FileWriter(path)); writer.writeAll(data); writer.close(); }",
+"import com.opencsv.CSVReader; import java.io.FileReader; public static List<String[]> readFromCsv(String path) throws Exception { CSVReader reader = new CSVReader(new FileReader(path)); return reader.readAll(); }",
+"import com.opencsv.CSVReader; import java.io.FileReader; public static int countCsvLines(String path) throws Exception { return readFromCsv(path).size(); }",
+"public static void shuffleList(List<?> list) { Collections.shuffle(list); }",
+"public static Object getRandomElement(List<?> list) { return list.get(new Random().nextInt(list.size())); }",
+"public static List<?> getRandomElements(List<?> list, int count) { Collections.shuffle(list); return list.subList(0, count); }",
+"public static int rollDice() { return new Random().nextInt(6) + 1; }",
+"public static String flipCoin() { return new Random().nextBoolean() ? \"Heads\" : \"Tails\"; }",
+"import java.util.Random; public static String generateRandomPassword(int length) { String chars = \"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789\"; StringBuilder password = new StringBuilder(); for (int i = 0; i < length; i++) { password.append(chars.charAt(new Random().nextInt(chars.length()))); } return password.toString(); }",
+"import java.util.Random; public static String generateRandomColor() { Random random = new Random(); return String.format(\"#%06x\", random.nextInt(0xFFFFFF + 1)); }",
+"import java.util.UUID; public static String generateUniqueId() { return UUID.randomUUID().toString(); }",
+"public class MyClass {}",
+"MyClass myObject = new MyClass();",
+"public class MyClass { public void myMethod() {} }",
+"public class MyClass { public String myAttribute; }",
+"public class ChildClass extends MyClass {}",
+"public class ChildClass extends MyClass { @Override public void myMethod() {} }",
+"public class MyClass { public static void myClassMethod() {} }",
+"public class MyClass { public static void myStaticMethod() {} }",
+"public static boolean isInstanceOf(Object obj, Class<?> clazz) { return clazz.isInstance(obj); }",
+"public static Object getAttribute(Object obj, String attribute) throws Exception { return obj.getClass().getDeclaredField(attribute).get(obj); }",
+"public static void setAttribute(Object obj, String attribute, Object value) throws Exception { obj.getClass().getDeclaredField(attribute).set(obj, value); }",
+"public static void deleteAttribute(Object obj, String attribute) throws Exception { obj.getClass().getDeclaredField(attribute).set(obj, null); }"
+"try { int result = 10 / 0; } catch (Exception e) { System.out.println(\"Exception caught\"); }",
+"class CustomException extends Exception { public CustomException(String message) { super(message); } }",
+"try { int result = 10 / 0; } catch (Exception e) { System.out.println(e.getMessage()); }",
+"import java.util.logging.Logger; Logger logger = Logger.getLogger(MyClass.class.getName()); logger.severe(\"Error occurred\");",
+"long startTime = System.currentTimeMillis();",
+"long endTime = System.currentTimeMillis(); long elapsedTime = endTime - startTime;",
+"for (int i = 0; i <= 100; i++) { System.out.print(\"\\rProgress: \" + i + \"%\"); Thread.sleep(50); }",
+"Thread.sleep(1000);",
+"Runnable r = () -> System.out.println(\"Lambda expression\"); r.run();",
+"List<Integer> numbers = Arrays.asList(1, 2, 3); List<Integer> squares = numbers.stream().map(x -> x * x).collect(Collectors.toList());",
+"List<Integer> numbers = Arrays.asList(1, 2, 3); List<Integer> evens = numbers.stream().filter(x -> x % 2 == 0).collect(Collectors.toList());",
+"import java.util.stream.Collectors; List<Integer> numbers = Arrays.asList(1, 2, 3); int sum = numbers.stream().reduce(0, Integer::sum);",
+"List<Integer> squares = IntStream.range(0, 10).map(x -> x * x).boxed().collect(Collectors.toList());",
+"Map<String, Integer> map = IntStream.range(0, 10).boxed().collect(Collectors.toMap(i -> \"key\" + i, i -> i));",
+"Set<Integer> set = IntStream.range(0, 10).boxed().collect(Collectors.toSet());",
+"Set<Integer> set1 = new HashSet<>(Arrays.asList(1, 2, 3)); Set<Integer> set2 = new HashSet<>(Arrays.asList(2, 3, 4)); set1.retainAll(set2);",
+"Set<Integer> set1 = new HashSet<>(Arrays.asList(1, 2, 3)); Set<Integer> set2 = new HashSet<>(Arrays.asList(2, 3, 4)); set1.addAll(set2);",
+"Set<Integer> set1 = new HashSet<>(Arrays.asList(1, 2, 3)); Set<Integer> set2 = new HashSet<>(Arrays.asList(2, 3, 4)); set1.removeAll(set2);",
+"List<Integer> list = Arrays.asList(1, null, 2, null); list.removeIf(Objects::isNull);",
+"try (BufferedReader br = new BufferedReader(new FileReader(\"file.txt\"))) { br.readLine(); } catch (IOException e) { System.out.println(\"File cannot be opened\"); }",
+"if (variable instanceof Integer) { System.out.println(\"Variable is an Integer\"); }",
+"boolean bool = Boolean.parseBoolean(\"true\");",
+"if (condition) { System.out.println(\"Condition is true\"); }",
+"while (condition) { System.out.println(\"Looping\"); }",
+"for (int i : list) { System.out.println(i); }",
+"for (Map.Entry<String, Integer> entry : map.entrySet()) { System.out.println(entry.getKey() + \": \" + entry.getValue()); }",
+"for (char c : str.toCharArray()) { System.out.println(c); }",
+"for (int i = 0; i < 10; i++) { if (i == 5) break; System.out.println(i); }",
+"for (int i = 0; i < 10; i++) { if (i == 5) continue; System.out.println(i); }",
+"public void myFunction() { System.out.println(\"Function executed\"); }",
+"public void myFunction(String param = \"default\") { System.out.println(param); }",
+"public int[] returnMultipleValues() { return new int[]{1, 2}; }",
+"public void myFunction(int... numbers) { for (int num : numbers) System.out.println(num); }",
+"public void myFunction(Map<String, Object> kwargs) { System.out.println(kwargs); }",
+"long startTime = System.nanoTime(); myFunction(); long endTime = System.nanoTime(); long duration = (endTime - startTime);",
+"public static <T> Function<T, T> memoize(Function<T, T> function) { return new Function<T, T>() { private final Map<T, T> cache = new HashMap<>(); public T apply(T input) { return cache.computeIfAbsent(input, function); } }; }",
+"public class MyGenerator implements Iterator<Integer> { private int current = 0; public boolean hasNext() { return current < 10; } public Integer next() { return current++; } }",
+"public class MyGenerator { public Iterator<Integer> iterator() { return new Iterator<Integer>() { private int current = 0; public boolean hasNext() { return current < 10; } public Integer next() { return current++; } }; } }",
+"MyGenerator generator = new MyGenerator(); while (generator.hasNext()) { System.out.println(generator.next()); }",
+"for (int i = 0; i < list.size(); i++) { System.out.println(i + \": \" + list.get(i)); }",
+"List<Integer> list1 = Arrays.asList(1, 2, 3); List<Integer> list2 = Arrays.asList(4, 5, 6); List<Integer> zipped = IntStream.range(0, Math.min(list1.size(), list2.size())).mapToObj(i -> list1.get(i) + list2.get(i)).collect(Collectors.toList());",
+"List<String> keys = Arrays.asList(\"a\", \"b\"); List<Integer> values = Arrays.asList(1, 2); Map<String, Integer> map = IntStream.range(0, keys.size()).boxed().collect(Collectors.toMap(keys::get, values::get));",
+"boolean areEqual = list1.equals(list2);",
+"boolean areEqual = map1.equals(map2);",
+"boolean areEqual = set1.equals(set2);",
+"Set<Integer> set = new HashSet<>(Arrays.asList(1, 2, 2, 3));",
+"set.clear();",
+"boolean isEmpty = set.isEmpty();",
+"set.add(4);",
+"set.remove(3);",
+"boolean contains = set.contains(2);",
+"int size = set.size();",
+"boolean hasIntersection = !Collections.disjoint(set1, set2);",
+"boolean isSubset = new HashSet<>(list1).containsAll(list2);",
+"boolean isSubstring = str.contains(sub);",
+"char firstChar = str.charAt(0);",
+"char lastChar = str.charAt(str.length() - 1);",
+"boolean isTextFile = Files.probeContentType(Paths.get(\"file.txt\")).startsWith(\"text\");",
+"boolean isImageFile = Files.probeContentType(Paths.get(\"file.jpg\")).startsWith(\"image\");",
+"double rounded = Math.round(3.14159);",
+"double ceil = Math.ceil(3.14159);",
+"double floor = Math.floor(3.14159);",
+"double formatted = Double.parseDouble(String.format(\"%.2f\", 3.14159));",
+"String randomString = new Random().ints(48, 122).filter(i -> (i <= 57 || i >= 65) && (i <= 90 || i >= 97)).limit(10).collect(StringBuilder::new, StringBuilder::appendCodePoint, StringBuilder::append).toString();",
+"boolean pathExists = Files.exists(Paths.get(\"path\"));",
+"Files.walk(Paths.get(\"path\")).forEach(System.out::println);",
+"String extension = FilenameUtils.getExtension(\"file.txt\");",
+"String fileName = FilenameUtils.getName(\"path/to/file.txt\");",
+"String fullPath = Paths.get(\"path/to/file.txt\").toAbsolutePath().toString();",
+"String version = System.getProperty(\"java.version\");",
+"String os = System.getProperty(\"os.name\");",
+"int cores = Runtime.getRuntime().availableProcessors();",
+"long memory = Runtime.getRuntime().totalMemory();",
+"File[] roots = File.listRoots(); for (File root : roots) { System.out.println(root.getUsableSpace()); }",
+"String ip = InetAddress.getLocalHost().getHostAddress();",
+"boolean isConnected = InetAddress.getByName(\"www.google.com\").isReachable(5000);",
+"URL url = new URL(\"http://example.com/file.txt\"); Files.copy(url.openStream(), Paths.get(\"file.txt\"));",
+"String response = new HttpPost(\"http://example.com/upload\").execute().returnContent().asString();",
+"String response = new HttpPost(\"http://example.com\").execute().returnContent().asString();",
+"String response = new HttpPost(\"http://example.com\").addParameter(\"key\", \"value\").execute().returnContent().asString();",
+"String response = new HttpPost(\"http://example.com\").addHeader(\"key\", \"value\").execute().returnContent().asString();",
+"Document doc = Jsoup.connect(\"http://example.com\").get();",
+"String title = doc.title();",
+"Elements links = doc.select(\"a[href]\");",
+"Elements images = doc.select(\"img[src]\"); for (Element img : images) { URL imgUrl = new URL(img.attr(\"src\")); Files.copy(imgUrl.openStream(), Paths.get(imgUrl.getFile())); }",
+"Map<String, Integer> wordCount = new HashMap<>(); for (String word : doc.text().split(\"\\\\s+\")) { wordCount.put(word, wordCount.getOrDefault(word, 0) + 1); }",
+"String response = new HttpPost(\"http://example.com/login\").addParameter(\"username\", \"user\").addParameter(\"password\", \"pass\").execute().returnContent().asString();",
+"String text = Jsoup.parse(html).text();",
+"Pattern emailPattern = Pattern.compile(\"[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\\\\.[a-zA-Z]{2,}\"); Matcher matcher = emailPattern.matcher(text); while (matcher.find()) { System.out.println(matcher.group()); }",
+"Pattern phonePattern = Pattern.compile(\"\\\\+?\\\\d{10,13}\"); Matcher matcher = phonePattern.matcher(text); while (matcher.find()) { System.out.println(matcher.group()); }",
+"Pattern numberPattern = Pattern.compile(\"\\\\d+\"); Matcher matcher = numberPattern.matcher(text); while (matcher.find()) { System.out.println(matcher.group()); }",
+"String replaced = text.replaceAll(\"pattern\", \"replacement\");",
+"boolean matches = text.matches(\"pattern\");",
+"String stripped = Jsoup.parse(html).text();",
+"String encoded = StringEscapeUtils.escapeHtml4(html);",
+"String decoded = StringEscapeUtils.unescapeHtml4(html);",
+"JFrame frame = new JFrame(\"Simple GUI\"); frame.setSize(300, 200); frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); frame.setVisible(true);"
+"JButton button = new JButton(\"Click Me\"); frame.add(button);",
+"button.addActionListener(e -> System.out.println(\"Button clicked\"));",
+"JOptionPane.showMessageDialog(frame, \"This is a message\");",
+"JTextField textField = new JTextField(); String input = textField.getText();",
+"frame.setTitle(\"New Title\");",
+"frame.setSize(400, 300);",
+"frame.setLocationRelativeTo(null);",
+"JMenuBar menuBar = new JMenuBar(); JMenu menu = new JMenu(\"File\"); menuBar.add(menu); frame.setJMenuBar(menuBar);",
+"JComboBox<String> comboBox = new JComboBox<>(new String[]{\"Option 1\", \"Option 2\"}); frame.add(comboBox);",
+"JRadioButton radioButton = new JRadioButton(\"Select Me\"); frame.add(radioButton);",
+"JCheckBox checkBox = new JCheckBox(\"Check Me\"); frame.add(checkBox);",
+"JLabel label = new JLabel(new ImageIcon(\"image.jpg\")); frame.add(label);",
+"Clip clip = AudioSystem.getClip(); clip.open(AudioSystem.getAudioInputStream(new File(\"audio.wav\"))); clip.start();",
+"Player player = Manager.createRealizedPlayer(new File(\"video.mp4\").toURI().toURL()); player.start();",
+"long currentTime = player.getTimeNanoseconds();",
+"Robot robot = new Robot(); BufferedImage screenShot = robot.createScreenCapture(new Rectangle(Toolkit.getDefaultToolkit().getScreenSize()));",
+"ScreenRecorder screenRecorder = new ScreenRecorder(new ScreenRecorderParameters()); screenRecorder.start(); Thread.sleep(5000); screenRecorder.stop();",
+"PointerInfo pointerInfo = MouseInfo.getPointerInfo(); Point point = pointerInfo.getLocation();",
+"robot.keyPress(KeyEvent.VK_A); robot.keyRelease(KeyEvent.VK_A);",
+"robot.mousePress(InputEvent.BUTTON1_DOWN_MASK); robot.mouseRelease(InputEvent.BUTTON1_DOWN_MASK);",
+"long timestamp = System.currentTimeMillis();",
+"Date date = new Date(timestamp);",
+"long timestamp = date.getTime();",
+"int dayOfWeek = Calendar.getInstance().get(Calendar.DAY_OF_WEEK);",
+"int daysInMonth = Calendar.getInstance().getActualMaximum(Calendar.DAY_OF_MONTH);",
+"Calendar cal = Calendar.getInstance(); cal.set(Calendar.DAY_OF_YEAR, 1); Date firstDay = cal.getTime();",
+"Calendar cal = Calendar.getInstance(); cal.set(Calendar.DAY_OF_YEAR, cal.getActualMaximum(Calendar.DAY_OF_YEAR)); Date lastDay = cal.getTime();",
+"Calendar cal = Calendar.getInstance(); cal.set(Calendar.DAY_OF_MONTH, 1); Date firstDay = cal.getTime();",
+"Calendar cal = Calendar.getInstance(); cal.set(Calendar.DAY_OF_MONTH, cal.getActualMaximum(Calendar.DAY_OF_MONTH)); Date lastDay = cal.getTime();",
+"int dayOfWeek = Calendar.getInstance().get(Calendar.DAY_OF_WEEK); boolean isWeekday = dayOfWeek != Calendar.SATURDAY && dayOfWeek != Calendar.SUNDAY;",
+"int dayOfWeek = Calendar.getInstance().get(Calendar.DAY_OF_WEEK); boolean isWeekend = dayOfWeek == Calendar.SATURDAY || dayOfWeek == Calendar.SUNDAY;",
+"int hour = Calendar.getInstance().get(Calendar.HOUR_OF_DAY);",
+"int minute = Calendar.getInstance().get(Calendar.MINUTE);",
+"int second = Calendar.getInstance().get(Calendar.SECOND);",
+"Thread.sleep(1000);",
+"long millis = System.currentTimeMillis();",
+"SimpleDateFormat sdf = new SimpleDateFormat(\"yyyy-MM-dd HH:mm:ss\"); String formattedDate = sdf.format(new Date());",
+"SimpleDateFormat sdf = new SimpleDateFormat(\"yyyy-MM-dd HH:mm:ss\"); Date date = sdf.parse(\"2023-10-01 12:00:00\");",
+"Thread thread = new Thread(() -> System.out.println(\"Thread running\")); thread.start();",
+"Thread.sleep(1000);",
+"ExecutorService executor = Executors.newFixedThreadPool(2); executor.submit(() -> System.out.println(\"Task 1\")); executor.submit(() -> System.out.println(\"Task 2\"));",
+"String threadName = Thread.currentThread().getName();",
+"thread.setDaemon(true);",
+"ReentrantLock lock = new ReentrantLock(); lock.lock(); try { System.out.println(\"Locked\"); } finally { lock.unlock(); }",
+"Process process = Runtime.getRuntime().exec(\"notepad.exe\");",
+"long pid = process.pid();",
+"boolean isAlive = process.isAlive();",
+"ExecutorService executor = Executors.newFixedThreadPool(2); executor.submit(() -> System.out.println(\"Task 1\")); executor.submit(() -> System.out.println(\"Task 2\"));",
+"BlockingQueue<String> queue = new LinkedBlockingQueue<>(); queue.put(\"Message\"); String message = queue.take();",
+"PipedInputStream in = new PipedInputStream(); PipedOutputStream out = new PipedOutputStream(in); out.write(\"Message\".getBytes());",
+"Thread.sleep(1000);",
+"Process process = Runtime.getRuntime().exec(\"ls\"); BufferedReader reader = new BufferedReader(new InputStreamReader(process.getInputStream())); String line; while ((line = reader.readLine()) != null) { System.out.println(line); }",
+"int exitCode = process.waitFor();",
+"boolean success = exitCode == 0;",
+"String scriptPath = new File(\"\").getAbsolutePath();",
+"String[] args = new String[]{\"arg1\", \"arg2\"};",
+"ArgumentParser parser = ArgumentParser(); parser.addArgument(\"--arg\"); Namespace ns = parser.parseArgs(args);",
+"parser.printHelp();",
+"ModuleFinder finder = ModuleFinder.ofSystem(); Set<ModuleReference> modules = finder.findAll();",
+"Process process = Runtime.getRuntime().exec(\"pip install package\");",
+"Process process = Runtime.getRuntime().exec(\"pip uninstall package\");",
+"String version = Package.getPackage(\"package\").getImplementationVersion();",
+"Process process = Runtime.getRuntime().exec(\"python -m venv venv\");",
+"Process process = Runtime.getRuntime().exec(\"pip list\");",
+"Process process = Runtime.getRuntime().exec(\"pip install --upgrade package\");",
+"Connection conn = DriverManager.getConnection(\"jdbc:sqlite:sample.db\");",
+"Statement stmt = conn.createStatement(); ResultSet rs = stmt.executeQuery(\"SELECT * FROM table\");",
+"stmt.executeUpdate(\"INSERT INTO table (column) VALUES ('value')\");",
+"stmt.executeUpdate(\"DELETE FROM table WHERE id = 1\");",
+"stmt.executeUpdate(\"UPDATE table SET column = 'new_value' WHERE id = 1\");",
+"while (rs.next()) { System.out.println(rs.getString(\"column\")); }",
+"PreparedStatement pstmt = conn.prepareStatement(\"SELECT * FROM table WHERE id = ?\"); pstmt.setInt(1, 1); ResultSet rs = pstmt.executeQuery();",
+"conn.close();",
+"stmt.executeUpdate(\"CREATE TABLE table (id INT, name TEXT)\");",
+"stmt.executeUpdate(\"DROP TABLE table\");",
+"DatabaseMetaData meta = conn.getMetaData(); ResultSet rs = meta.getTables(null, null, \"table\", null); boolean exists = rs.next();",
+"ResultSet rs = meta.getTables(null, null, \"%\", null); while (rs.next()) { System.out.println(rs.getString(\"TABLE_NAME\")); }",
+"EntityManager em = Persistence.createEntityManagerFactory(\"pu\").createEntityManager(); em.getTransaction().begin(); em.persist(entity); em.getTransaction().commit();",
+"EntityManager em = Persistence.createEntityManagerFactory(\"pu\").createEntityManager(); Query query = em.createQuery(\"SELECT e FROM Entity e\"); List<Entity> entities = query.getResultList();",
+"EntityManager em = Persistence.createEntityManagerFactory(\"pu\").createEntityManager(); em.getTransaction().begin(); em.remove(entity); em.getTransaction().commit();",
+"EntityManager em = Persistence.createEntityManagerFactory(\"pu\").createEntityManager(); em.getTransaction().begin(); em.merge(entity); em.getTransaction().commit();",
+"@Entity public class Entity { @Id @GeneratedValue private Long id; private String name; }",
+"@Entity public class ChildEntity extends ParentEntity { private String childField; }",
+"@Id @GeneratedValue private Long id;",
+"@Column(unique = true) private String uniqueField;",
+"@Column(columnDefinition = \"varchar(255) default 'default_value'\") private String field;",
+"CSVWriter writer = new CSVWriter(new FileWriter(\"data.csv\")); writer.writeAll(data); writer.close();",
+"Workbook workbook = new XSSFWorkbook(); Sheet sheet = workbook.createSheet(\"Sheet1\"); FileOutputStream fileOut = new FileOutputStream(\"workbook.xlsx\"); workbook.write(fileOut); fileOut.close();",
+"ObjectMapper mapper = new ObjectMapper(); mapper.writeValue(new File(\"data.json\"), data);",
+"Workbook workbook = WorkbookFactory.create(new File(\"workbook.xlsx\")); Sheet sheet = workbook.getSheetAt(0);",
+"Workbook workbook1 = WorkbookFactory.create(new File(\"workbook1.xlsx\")); Workbook workbook2 = WorkbookFactory.create(new File(\"workbook2.xlsx\")); Sheet sheet1 = workbook1.getSheetAt(0); Sheet sheet2 = workbook2.getSheetAt(0); Sheet newSheet = workbook1.createSheet(\"Merged\");",
+"Workbook workbook = new XSSFWorkbook(); Sheet sheet = workbook.createSheet(\"New Sheet\");",
+"CellStyle style = workbook.createCellStyle(); style.cloneStyleFrom(cell.getCellStyle());",
+"CellStyle style = workbook.createCellStyle(); style.setFillForegroundColor(IndexedColors.RED.getIndex()); style.setFillPattern(FillPatternType.SOLID_FOREGROUND);",
+"Font font = workbook.createFont(); font.setBold(true); CellStyle style = workbook.createCellStyle(); style.setFont(font);",
+"Row row = sheet.getRow(0); Cell cell = row.getCell(0); String cellValue = cell.getStringCellValue();",
+"Row row = sheet.createRow(0); Cell cell = row.createCell(0); cell.setCellValue(\"New Value\");",
+"BufferedImage img = ImageIO.read(new File(\"image.jpg\")); int width = img.getWidth(); int height = img.getHeight();",
+"BufferedImage resizedImg = new BufferedImage(newWidth, newHeight, BufferedImage.TYPE_INT_RGB); Graphics2D g = resizedImg.createGraphics(); g.drawImage(img, 0, 0, newWidth, newHeight, null); g.dispose();"
+
+
+
 
 ]